• Archlinux
• Debian 8.1
• macOS 10.10
• Microsoft Windows Server 2008
• RHEL 7.0, 7.1, 7.2
• SUSE 12
• Ubuntu 12.04, 14.04, 16.04
• Clang 3.4, 3.5, 3.7, 3.8
• GCC 4.6, 4.8, 4.9, 5.3
• MinGW-W64
• Visual Studio 2010, 2013, 2015
• x86, x86_64, ARM (aarch64), Power8 (ppc64le), zSeries (s390x)

•

Tutorial

# Specify the minimum version you require.
find_package (libmongoc-1.0 1.7 REQUIRED)
message ("--   mongoc found version \"${MONGOC_VERSION}\"")
message ("--   mongoc include path \"${MONGOC_INCLUDE_DIRS}\"")
message ("--   mongoc libraries \"${MONGOC_LIBRARIES}\"")
# The "hello_mongoc.c" sample program is shared among four tests.
add_executable (hello_mongoc ../../hello_mongoc.c)
target_include_directories (hello_mongoc PRIVATE "${MONGOC_INCLUDE_DIRS}")
target_link_libraries (hello_mongoc PRIVATE "${MONGOC_LIBRARIES}")
target_compile_definitions (hello_mongoc PRIVATE "${MONGOC_DEFINITIONS}")

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


   const char *uri_string = "mongodb://localhost:27017";


   mongoc_uri_t *uri;


   mongoc_client_t *client;


   mongoc_database_t *database;


   mongoc_collection_t *collection;


   bson_t *command, reply, *insert;


   bson_error_t error;


   char *str;


   bool retval;


   /*


    * Required to initialize libmongoc's internals


    */


   mongoc_init ();


   /*


    * Optionally get MongoDB URI from command line


    */


   if (argc > 1) {


      uri_string = argv[1];


   }


   /*


    * Safely create a MongoDB URI object from the given string


    */


   uri = mongoc_uri_new_with_error (uri_string, &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               uri_string,


               error.message);


      return EXIT_FAILURE;


   }


   /*


    * Create a new client instance


    */


   client = mongoc_client_new_from_uri (uri);


   if (!client) {


      return EXIT_FAILURE;


   }


   /*


    * Register the application name so we can track it in the profile logs


    * on the server. This can also be done from the URI (see other examples).


    */


   mongoc_client_set_appname (client, "connect-example");


   /*


    * Get a handle on the database "db_name" and collection "coll_name"


    */


   database = mongoc_client_get_database (client, "db_name");


   collection = mongoc_client_get_collection (client, "db_name", "coll_name");


   /*


    * Do work. This example pings the database, prints the result as JSON and


    * performs an insert


    */


   command = BCON_NEW ("ping", BCON_INT32 (1));


   retval = mongoc_client_command_simple (


      client, "admin", command, NULL, &reply, &error);


   if (!retval) {


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


      return EXIT_FAILURE;


   }


   str = bson_as_json (&reply, NULL);


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


   insert = BCON_NEW ("hello", BCON_UTF8 ("world"));


   if (!mongoc_collection_insert_one (collection, insert, NULL, NULL, &error)) {


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


   }


   bson_destroy (insert);


   bson_destroy (&reply);


   bson_destroy (command);


   bson_free (str);


   /*


    * Release our handles and clean up libmongoc


    */


   mongoc_collection_destroy (collection);


   mongoc_database_destroy (database);


   mongoc_uri_destroy (uri);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return EXIT_SUCCESS;
}

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


 * libmongoc-1.0) */
/* ./example-pool [CONNECTION_STRING] */
#include <mongoc/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 *uri_string = "mongodb://127.0.0.1/?appname=pool-example";


   mongoc_uri_t *uri;


   bson_error_t error;


   mongoc_client_pool_t *pool;


   pthread_t threads[10];


   unsigned i;


   void *ret;


   pthread_mutex_init (&mutex, NULL);


   mongoc_init ();


   if (argc > 1) {


      uri_string = argv[1];


   }


   uri = mongoc_uri_new_with_error (uri_string, &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               uri_string,


               error.message);


      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 EXIT_SUCCESS;
}

• SCRAM-SHA-1
• MONGODB-CR (deprecated)
• GSSAPI
• PLAIN
• X509

• CANONICALIZE_HOST_NAME: This might be required with Cyrus-SASL 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 using the cmake option -DENABLE_TRACING=ON 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_with_opts (collection, 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)
{


   char *str;


   BSON_ASSERT (reply);


   str = bson_as_canonical_extended_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;
}

/*


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


   mongoc_database_t *database = NULL;


   mongoc_client_t *client = NULL;


   mongoc_collection_t *collection = NULL;


   mongoc_uri_t *uri = NULL;


   bson_error_t error;


   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 EXIT_FAILURE;


   }


   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;


   uri = mongoc_uri_new_with_error (host_and_port, &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               host_and_port,


               error.message);


      res = EXIT_FAILURE;


      goto cleanup;


   }


   client = mongoc_client_new_from_uri (uri);


   if (!client) {


      res = EXIT_FAILURE;


      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 = EXIT_FAILURE;


      goto cleanup;


   }


   printf ("explain\n");


   if (!explain (collection)) {


      res = EXIT_FAILURE;


      goto cleanup;


   }


   if (other_host_and_port) {


      printf ("copydb\n");


      if (!copydb (client, other_host_and_port)) {


         res = EXIT_FAILURE;


         goto cleanup;


      }


   }
cleanup:


   if (collection) {


      mongoc_collection_destroy (collection);


   }


   if (database) {


      mongoc_database_destroy (database);


   }


   if (client) {


      mongoc_client_destroy (client);


   }


   if (uri) {


      mongoc_uri_destroy (uri);


   }


   bson_free (host_and_port);


   mongoc_cleanup ();


   return res;
}

#include <bson/bson.h>
#include <mongoc/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_canonical_extended_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;


   mongoc_uri_t *uri;


   bson_error_t error;


   if (argc != 2) {


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


      return EXIT_FAILURE;


   }


   mongoc_init ();


   uri = mongoc_uri_new_with_error (argv[1], &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               argv[1],


               error.message);


      return EXIT_FAILURE;


   }


   client = mongoc_client_new_from_uri (uri);


   if (!client) {


      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_uri_destroy (uri);


   mongoc_client_destroy (client);


   return EXIT_SUCCESS;
}

#include <assert.h>
#include <mongoc/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_with_opts (collection, 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_canonical_extended_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;


   const char *uri_string = "mongodb://localhost/?appname=bulk1-example";


   mongoc_uri_t *uri;


   bson_error_t error;


   mongoc_init ();


   uri = mongoc_uri_new_with_error (uri_string, &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               uri_string,


               error.message);


      return EXIT_FAILURE;


   }


   client = mongoc_client_new_from_uri (uri);


   if (!client) {


      return EXIT_FAILURE;


   }


   mongoc_client_set_error_api (client, 2);


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


   bulk1 (collection);


   mongoc_uri_destroy (uri);


   mongoc_collection_destroy (collection);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return EXIT_SUCCESS;
}

#include <assert.h>
#include <mongoc/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_with_opts (collection, 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_canonical_extended_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;


   const char *uri_string = "mongodb://localhost/?appname=bulk2-example";


   mongoc_uri_t *uri;


   bson_error_t error;


   mongoc_init ();


   uri = mongoc_uri_new_with_error (uri_string, &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               uri_string,


               error.message);


      return EXIT_FAILURE;


   }


   client = mongoc_client_new_from_uri (uri);


   if (!client) {


      return EXIT_FAILURE;


   }


   mongoc_client_set_error_api (client, 2);


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


   bulk2 (collection);


   mongoc_uri_destroy (uri);


   mongoc_collection_destroy (collection);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return EXIT_SUCCESS;
}

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


   bson_t opts = BSON_INITIALIZER;


   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 */


   BSON_APPEND_BOOL (&opts, "ordered", false);


   bulk = mongoc_collection_create_bulk_operation_with_opts (collection, &opts);


   bson_destroy (&opts);


   /* 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_canonical_extended_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);


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


   mongoc_client_t *client;


   mongoc_collection_t *collection;


   const char *uri_string = "mongodb://localhost/?appname=bulk3-example";


   mongoc_uri_t *uri;


   bson_error_t error;


   mongoc_init ();


   uri = mongoc_uri_new_with_error (uri_string, &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               uri_string,


               error.message);


      return EXIT_FAILURE;


   }


   client = mongoc_client_new_from_uri (uri);


   if (!client) {


      return EXIT_FAILURE;


   }


   mongoc_client_set_error_api (client, 2);


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


   bulk3 (collection);


   mongoc_uri_destroy (uri);


   mongoc_collection_destroy (collection);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return EXIT_SUCCESS;
}

#include <assert.h>
#include <mongoc/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_with_opts (collection, 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_canonical_extended_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_with_opts (collection, 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_canonical_extended_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;


   const char *uri_string = "mongodb://localhost/?appname=bulk5-example";


   mongoc_uri_t *uri;


   mongoc_init ();


   uri = mongoc_uri_new_with_error (uri_string, &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               uri_string,


               error.message);


      return EXIT_FAILURE;


   }


   client = mongoc_client_new_from_uri (uri);


   if (!client) {


      return EXIT_FAILURE;


   }


   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_uri_destroy (uri);


   mongoc_database_destroy (database);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return EXIT_SUCCESS;
}

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


   bson_t opts = BSON_INITIALIZER;


   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 */


   mongoc_write_concern_append (wc, &opts);


   bulk = mongoc_collection_create_bulk_operation_with_opts (collection, &opts);


   /* 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_canonical_extended_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);


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


   mongoc_client_t *client;


   mongoc_collection_t *collection;


   const char *uri_string = "mongodb://localhost/?appname=bulk4-example";


   mongoc_uri_t *uri;


   bson_error_t error;


   mongoc_init ();


   uri = mongoc_uri_new_with_error (uri_string, &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               uri_string,


               error.message);


      return EXIT_FAILURE;


   }


   client = mongoc_client_new_from_uri (uri);


   if (!client) {


      return EXIT_FAILURE;


   }


   mongoc_client_set_error_api (client, 2);


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


   bulk4 (collection);


   mongoc_uri_destroy (uri);


   mongoc_collection_destroy (collection);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return EXIT_SUCCESS;
}

#include <mongoc/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_with_opts (


      collection, 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_canonical_extended_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;


   const char *uri_string = "mongodb://localhost/?appname=bulk-collation";


   mongoc_uri_t *uri;


   bson_error_t error;


   mongoc_init ();


   uri = mongoc_uri_new_with_error (uri_string, &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               uri_string,


               error.message);


      return EXIT_FAILURE;


   }


   client = mongoc_client_new_from_uri (uri);


   if (!client) {


      return EXIT_FAILURE;


   }


   mongoc_client_set_error_api (client, 2);


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


   bulk_collation (collection);


   mongoc_uri_destroy (uri);


   mongoc_collection_destroy (collection);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return EXIT_SUCCESS;
}

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


   bson_t opts = BSON_INITIALIZER;


   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);


   mongoc_write_concern_append (wc, &opts);


   bulk = mongoc_collection_create_bulk_operation_with_opts (collection, &opts);


   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_canonical_extended_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);


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


   mongoc_client_t *client;


   mongoc_collection_t *collection;


   const char *uri_string = "mongodb://localhost/?appname=bulk6-example";


   mongoc_uri_t *uri;


   bson_error_t error;


   mongoc_init ();


   uri = mongoc_uri_new_with_error (uri_string, &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               uri_string,


               error.message);


      return EXIT_FAILURE;


   }


   client = mongoc_client_new_from_uri (uri);


   if (!client) {


      return EXIT_FAILURE;


   }


   mongoc_client_set_error_api (client, 2);


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


   bulk6 (collection);


   mongoc_uri_destroy (uri);


   mongoc_collection_destroy (collection);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return EXIT_SUCCESS;
}

• 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/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_canonical_extended_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;


   const char *uri_string =


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


   mongoc_uri_t *uri;


   bson_error_t error;


   mongoc_init ();


   uri = mongoc_uri_new_with_error (uri_string, &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               uri_string,


               error.message);


      return EXIT_FAILURE;


   }


   client = mongoc_client_new_from_uri (uri);


   if (!client) {


      return EXIT_FAILURE;


   }


   mongoc_client_set_error_api (client, 2);


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


   print_pipeline (collection);


   mongoc_uri_destroy (uri);


   mongoc_collection_destroy (collection);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return EXIT_SUCCESS;
}

/* 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_with_opts (collection, 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)
{


   char *str;


   BSON_ASSERT (reply);


   str = bson_as_canonical_extended_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 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);


   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);


   }


   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/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;


   mongoc_uri_t *uri = NULL;


   bson_error_t error;


   char *host_and_port = NULL;


   int exit_code = EXIT_FAILURE;


   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 exit_code;


   }


   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]);


   }


   uri = mongoc_uri_new_with_error (host_and_port, &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               host_and_port,


               error.message);


      goto cleanup;


   }


   client = mongoc_client_new_from_uri (uri);


   if (!client) {


      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)) {


      goto cleanup;


   }


   printf ("distinct\n");


   if (!distinct (database)) {


      goto cleanup;


   }


   printf ("map reduce\n");


   if (!map_reduce_basic (database)) {


      goto cleanup;


   }


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


   if (!map_reduce_advanced (database)) {


      goto cleanup;


   }


   


   exit_code = EXIT_SUCCESS;
cleanup:


   if (collection) {


      mongoc_collection_destroy (collection);


   }


   if (database) {


      mongoc_database_destroy (database);


   }


   if (client) {


      mongoc_client_destroy (client);


   }


   if (uri) {


      mongoc_uri_destroy (uri);


   }


   if (host_and_port) {


      bson_free (host_and_port);


   }


   mongoc_cleanup ();


   return exit_code;
}

/* gcc example-create-indexes.c -o example-create-indexes $(pkg-config --cflags


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


   mongoc_client_t *client;


   const char *uri_string =


      "mongodb://127.0.0.1/?appname=create-indexes-example";


   mongoc_uri_t *uri;


   mongoc_database_t *db;


   const char *collection_name = "test";


   bson_t keys;


   char *index_name;


   bson_t *create_indexes;


   bson_t reply;


   char *reply_str;


   bson_error_t error;


   bool r;


   mongoc_init ();


   if (argc > 1) {


      uri_string = argv[1];


   }


   if (argc > 2) {


      collection_name = argv[2];


   }


   uri = mongoc_uri_new_with_error (uri_string, &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               uri_string,


               error.message);


      return EXIT_FAILURE;


   }


   client = mongoc_client_new_from_uri (uri);


   if (!client) {


      return EXIT_FAILURE;


   }


   mongoc_client_set_error_api (client, 2);


   db = mongoc_client_get_database (client, "test");


   /* ascending index on field "x" */


   bson_init (&keys);


   BSON_APPEND_INT32 (&keys, "x", 1);


   index_name = mongoc_collection_keys_to_index_string (&keys);


   create_indexes = BCON_NEW ("createIndexes",


                              BCON_UTF8 (collection_name),


                              "indexes",


                              "[",


                              "{",


                              "key",


                              BCON_DOCUMENT (&keys),


                              "name",


                              BCON_UTF8 (index_name),


                              "}",


                              "]");


   r = mongoc_database_write_command_with_opts (


      db, create_indexes, NULL /* opts */, &reply, &error);


   reply_str = bson_as_json (&reply, NULL);


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


   if (!r) {


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


   }


   bson_free (index_name);


   bson_free (reply_str);


   bson_destroy (&reply);


   bson_destroy (create_indexes);


   mongoc_database_destroy (db);


   mongoc_uri_destroy (uri);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return r ? EXIT_SUCCESS : EXIT_FAILURE;
}

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.

#include <mongoc/mongoc.h>
int
main ()
{


   bson_t empty = BSON_INITIALIZER;


   const bson_t *doc;


   bson_t *to_insert = BCON_NEW ("x", BCON_INT32 (1));


   const bson_t *err_doc;


   bson_error_t error;


   const char *uri_string;


   mongoc_uri_t *uri;


   mongoc_client_t *client;


   mongoc_collection_t *coll;


   mongoc_change_stream_t *stream;


   mongoc_write_concern_t *wc = mongoc_write_concern_new ();


   bson_t opts = BSON_INITIALIZER;


   bool r;


   mongoc_init ();


   uri_string = "mongodb://"


                "localhost:27017,localhost:27018,localhost:"


                "27019/db?replicaSet=rs0";


   uri = mongoc_uri_new_with_error (uri_string, &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               uri_string,


               error.message);


      return EXIT_FAILURE;


   }


   client = mongoc_client_new_from_uri (uri);


   if (!client) {


      return EXIT_FAILURE;


   }


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


   stream = mongoc_collection_watch (coll, &empty, NULL);


   mongoc_write_concern_set_wmajority (wc, 10000);


   mongoc_write_concern_append (wc, &opts);


   r = mongoc_collection_insert_one (coll, to_insert, &opts, NULL, &error);


   if (!r) {


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


      return EXIT_FAILURE;


   }


   while (mongoc_change_stream_next (stream, &doc)) {


      char *as_json = bson_as_relaxed_extended_json (doc, NULL);


      fprintf (stderr, "Got document: %s\n", as_json);


      bson_free (as_json);


   }


   if (mongoc_change_stream_error_document (stream, &error, &err_doc)) {


      if (!bson_empty (err_doc)) {


         fprintf (stderr,


                  "Server Error: %s\n",


                  bson_as_relaxed_extended_json (err_doc, NULL));


      } else {


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


      }


      return EXIT_FAILURE;


   }


   bson_destroy (to_insert);


   mongoc_write_concern_destroy (wc);


   bson_destroy (&opts);


   mongoc_change_stream_destroy (stream);


   mongoc_collection_destroy (coll);


   mongoc_uri_destroy (uri);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return EXIT_SUCCESS;
}

#include <mongoc/mongoc.h>
/* An example implementation of custom resume logic in a change stream.
* example-resume starts a client-wide change stream and persists the resume
* token in a file "resume-token.json". On restart, if "resume-token.json"
* exists, the change stream starts watching after the persisted resume token.
*
* This behavior allows a user to exit example-resume, and restart it later
* without missing any change events.
*/
#include <unistd.h>
static const char *RESUME_TOKEN_PATH = "resume-token.json";
static bool
_save_resume_token (const bson_t *doc)
{


   FILE *file_stream;


   bson_iter_t iter;


   bson_t resume_token_doc;


   char *as_json = NULL;


   size_t as_json_len;


   ssize_t r, n_written;


   const bson_value_t *resume_token;


   if (!bson_iter_init_find (&iter, doc, "_id")) {


      fprintf (stderr, "reply does not contain operationTime.");


      return false;


   }


   resume_token = bson_iter_value (&iter);


   /* store the resume token in a document, { resumeAfter: <resume token> }


    * which we can later append easily. */


   file_stream = fopen (RESUME_TOKEN_PATH, "w+");


   if (!file_stream) {


      fprintf (stderr, "failed to open %s for writing\n", RESUME_TOKEN_PATH);


      return false;


   }


   bson_init (&resume_token_doc);


   BSON_APPEND_VALUE (&resume_token_doc, "resumeAfter", resume_token);


   as_json = bson_as_canonical_extended_json (&resume_token_doc, &as_json_len);


   bson_destroy (&resume_token_doc);


   n_written = 0;


   while (n_written < as_json_len) {


      r = fwrite ((void *) (as_json + n_written),


                  sizeof (char),


                  as_json_len - n_written,


                  file_stream);


      if (r == -1) {


         fprintf (stderr, "failed to write to %s\n", RESUME_TOKEN_PATH);


         bson_free (as_json);


         fclose (file_stream);


         return false;


      }


      n_written += r;


   }


   bson_free (as_json);


   fclose (file_stream);


   return true;
}
bool
_load_resume_token (bson_t *opts)
{


   bson_error_t error;


   bson_json_reader_t *reader;


   bson_t doc;


   /* if the file does not exist, skip. */


   if (-1 == access (RESUME_TOKEN_PATH, R_OK)) {


      return true;


   }


   reader = bson_json_reader_new_from_file (RESUME_TOKEN_PATH, &error);


   if (!reader) {


      fprintf (stderr,


               "failed to open %s for reading: %s\n",


               RESUME_TOKEN_PATH,


               error.message);


      return false;


   }


   bson_init (&doc);


   if (-1 == bson_json_reader_read (reader, &doc, &error)) {


      fprintf (stderr, "failed to read doc from %s\n", RESUME_TOKEN_PATH);


      bson_destroy (&doc);


      bson_json_reader_destroy (reader);


      return false;


   }


   printf ("found cached resume token in %s, resuming change stream.\n",


           RESUME_TOKEN_PATH);


   bson_concat (opts, &doc);


   bson_destroy (&doc);


   bson_json_reader_destroy (reader);


   return true;
}
int
main ()
{


   int exit_code = EXIT_FAILURE;


   const char *uri_string;


   mongoc_uri_t *uri = NULL;


   bson_error_t error;


   mongoc_client_t *client = NULL;


   bson_t pipeline = BSON_INITIALIZER;


   bson_t opts = BSON_INITIALIZER;


   mongoc_change_stream_t *stream = NULL;


   const bson_t *doc;


   const int max_time = 30; /* max amount of time, in seconds, that


                               mongoc_change_stream_next can block. */


   mongoc_init ();


   uri_string = "mongodb://localhost:27017/db?replicaSet=rs0";


   uri = mongoc_uri_new_with_error (uri_string, &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               uri_string,


               error.message);


      goto cleanup;


   }


   client = mongoc_client_new_from_uri (uri);


   if (!client) {


      goto cleanup;


   }


   if (!_load_resume_token (&opts)) {


      goto cleanup;


   }


   BSON_APPEND_INT64 (&opts, "maxAwaitTimeMS", max_time * 1000);


   printf ("listening for changes on the client (max %d seconds).\n", max_time);


   stream = mongoc_client_watch (client, &pipeline, &opts);


   while (mongoc_change_stream_next (stream, &doc)) {


      char *as_json;


      as_json = bson_as_canonical_extended_json (doc, NULL);


      printf ("change received: %s\n", as_json);


      bson_free (as_json);


      if (!_save_resume_token (doc)) {


         goto cleanup;


      }


   }


   exit_code = EXIT_SUCCESS;
cleanup:


   mongoc_uri_destroy (uri);


   bson_destroy (&pipeline);


   bson_destroy (&opts);


   mongoc_change_stream_destroy (stream);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return exit_code;
}

/* An example of starting a change stream with startAtOperationTime. */
#include <mongoc/mongoc.h>
int
main ()
{


   int exit_code = EXIT_FAILURE;


   const char *uri_string;


   mongoc_uri_t *uri = NULL;


   bson_error_t error;


   mongoc_client_t *client = NULL;


   mongoc_collection_t *coll = NULL;


   bson_t pipeline = BSON_INITIALIZER;


   bson_t opts = BSON_INITIALIZER;


   mongoc_change_stream_t *stream = NULL;


   bson_iter_t iter;


   const bson_t *doc;


   bson_value_t cached_operation_time = {0};


   int i;


   bool r;


   mongoc_init ();


   uri_string = "mongodb://localhost:27017/db?replicaSet=rs0";


   uri = mongoc_uri_new_with_error (uri_string, &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               uri_string,


               error.message);


      goto cleanup;


   }


   client = mongoc_client_new_from_uri (uri);


   if (!client) {


      goto cleanup;


   }


   /* insert five documents. */


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


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


      bson_t reply;


      bson_t *insert_cmd = BCON_NEW ("insert",


                                     "coll",


                                     "documents",


                                     "[",


                                     "{",


                                     "x",


                                     BCON_INT64 (i),


                                     "}",


                                     "]");


      r = mongoc_collection_write_command_with_opts (


         coll, insert_cmd, NULL, &reply, &error);


      bson_destroy (insert_cmd);


      if (!r) {


         bson_destroy (&reply);


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


         goto cleanup;


      }


      if (i == 0) {


         /* cache the operation time in the first reply. */


         if (bson_iter_init_find (&iter, &reply, "operationTime")) {


            bson_value_copy (bson_iter_value (&iter), &cached_operation_time);


         } else {


            fprintf (stderr, "reply does not contain operationTime.");


            bson_destroy (&reply);


            goto cleanup;


         }


      }


      bson_destroy (&reply);


   }


   /* start a change stream at the first returned operationTime. */


   BSON_APPEND_VALUE (&opts, "startAtOperationTime", &cached_operation_time);


   stream = mongoc_collection_watch (coll, &pipeline, &opts);


   /* since the change stream started at the operation time of the first


    * insert, the five inserts are returned. */


   printf ("listening for changes on db.coll:\n");


   while (mongoc_change_stream_next (stream, &doc)) {


      char *as_json;


      as_json = bson_as_canonical_extended_json (doc, NULL);


      printf ("change received: %s\n", as_json);


      bson_free (as_json);


   }


   exit_code = EXIT_SUCCESS;
cleanup:


   mongoc_uri_destroy (uri);


   bson_destroy (&pipeline);


   bson_destroy (&opts);


   if (cached_operation_time.value_type) {


      bson_value_destroy (&cached_operation_time);


   }


   mongoc_change_stream_destroy (stream);


   mongoc_collection_destroy (coll);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return exit_code;
}

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


 * libmongoc-1.0) */
/* ./example-pool [CONNECTION_STRING] */
#include <mongoc/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 *uri_string = "mongodb://127.0.0.1/?appname=pool-example";


   mongoc_uri_t *uri;


   bson_error_t error;


   mongoc_client_pool_t *pool;


   pthread_t threads[10];


   unsigned i;


   void *ret;


   pthread_mutex_init (&mutex, NULL);


   mongoc_init ();


   if (argc > 1) {


      uri_string = argv[1];


   }


   uri = mongoc_uri_new_with_error (uri_string, &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               uri_string,


               error.message);


      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 EXIT_SUCCESS;
}

/* gcc example-session.c -o example-session \


 *     $(pkg-config --cflags --libs libmongoc-1.0) */
/* ./example-session [CONNECTION_STRING] */
#include <stdio.h>
#include <mongoc/mongoc.h>
int
main (int argc, char *argv[])
{


   int exit_code = EXIT_FAILURE;


   mongoc_client_t *client = NULL;


   const char *uri_string = "mongodb://127.0.0.1/?appname=session-example";


   mongoc_uri_t *uri = NULL;


   mongoc_client_session_t *client_session = NULL;


   mongoc_collection_t *collection = NULL;


   bson_error_t error;


   bson_t *selector = NULL;


   bson_t *update = NULL;


   bson_t *update_opts = NULL;


   bson_t *find_opts = NULL;


   mongoc_read_prefs_t *secondary = NULL;


   mongoc_cursor_t *cursor = NULL;


   const bson_t *doc;


   char *str;


   bool r;


   mongoc_init ();


   if (argc > 1) {


      uri_string = argv[1];


   }


   uri = mongoc_uri_new_with_error (uri_string, &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               uri_string,


               error.message);


      goto done;


   }


   client = mongoc_client_new_from_uri (uri);


   if (!client) {


      goto done;


   }


   mongoc_client_set_error_api (client, 2);


   /* pass NULL for options - by default the session is causally consistent */


   client_session = mongoc_client_start_session (client, NULL, &error);


   if (!client_session) {


      fprintf (stderr, "Failed to start session: %s\n", error.message);


      goto done;


   }


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


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


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


   update_opts = bson_new ();


   if (!mongoc_client_session_append (client_session, update_opts, &error)) {


      fprintf (stderr, "Could not add session to opts: %s\n", error.message);


      goto done;


   }


   r = mongoc_collection_update_one (


      collection, selector, update, update_opts, NULL /* reply */, &error);


   if (!r) {


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


      goto done;


   }


   bson_destroy (selector);


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


   secondary = mongoc_read_prefs_new (MONGOC_READ_SECONDARY);


   find_opts = BCON_NEW ("maxTimeMS", BCON_INT32 (2000));


   if (!mongoc_client_session_append (client_session, find_opts, &error)) {


      fprintf (stderr, "Could not add session to opts: %s\n", error.message);


      goto done;


   };


   /* read from secondary. since we're in a causally consistent session, the


    * data is guaranteed to reflect the update we did on the primary. the query


    * blocks waiting for the secondary to catch up, if necessary, or times out


    * and fails after 2000 ms.


    */


   cursor = mongoc_collection_find_with_opts (


      collection, selector, find_opts, secondary);


   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);


      goto done;


   }


   exit_code = EXIT_SUCCESS;
done:


   if (find_opts) {


      bson_destroy (find_opts);


   }


   if (update) {


      bson_destroy (update);


   }


   if (selector) {


      bson_destroy (selector);


   }


   if (update_opts) {


      bson_destroy (update_opts);


   }


   if (secondary) {


      mongoc_read_prefs_destroy (secondary);


   }


   /* destroy cursor, collection, session before the client they came from */


   if (cursor) {


      mongoc_cursor_destroy (cursor);


   }


   if (collection) {


      mongoc_collection_destroy (collection);


   }


   if (client_session) {


      mongoc_client_session_destroy (client_session);


   }


   if (uri) {


      mongoc_uri_destroy (uri);


   }


   if (client) {


      mongoc_client_destroy (client);


   }


   mongoc_cleanup ();


   return exit_code;
}

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


 * libmongoc-1.0) */
/* ./example-client [CONNECTION_STRING [COLLECTION_NAME]] */
#include <mongoc/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 *collection_name = "test";


   bson_t query;


   char *str;


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


   mongoc_uri_t *uri;


   mongoc_init ();


   if (argc > 1) {


      uri_string = argv[1];


   }


   if (argc > 2) {


      collection_name = argv[2];


   }


   uri = mongoc_uri_new_with_error (uri_string, &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               uri_string,


               error.message);


      return EXIT_FAILURE;


   }


   client = mongoc_client_new_from_uri (uri);


   if (!client) {


      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_canonical_extended_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_uri_destroy (uri);


   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/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 *collection_name = "test";


   bson_t query;


   char *str;


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


   mongoc_uri_t *uri;


   mongoc_init ();


   if (argc > 1) {


      uri_string = argv[1];


   }


   if (argc > 2) {


      collection_name = argv[2];


   }


   uri = mongoc_uri_new_with_error (uri_string, &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               uri_string,


               error.message);


      return EXIT_FAILURE;


   }


   client = mongoc_client_new_from_uri (uri);


   if (!client) {


      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_canonical_extended_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_uri_destroy (uri);


   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_canonical_extended_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_canonical_extended_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_canonical_extended_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_canonical_extended_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_canonical_extended_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;


   mongoc_write_concern_t *wc;


   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);


   /* Set write concern w: 2 */


   wc = mongoc_write_concern_new ();


   mongoc_write_concern_set_w (wc, 2);


   mongoc_write_concern_append (wc, &extra);


   /* 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_canonical_extended_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_write_concern_destroy (wc);


   mongoc_find_and_modify_opts_destroy (opts);
}

int
main (void)
{


   mongoc_collection_t *collection;


   mongoc_database_t *database;


   mongoc_client_t *client;


   const char *uri_string =


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


   mongoc_uri_t *uri;


   bson_error_t error;


   bson_t *options;


   mongoc_init ();


   uri = mongoc_uri_new_with_error (uri_string, &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               uri_string,


               error.message);


      return EXIT_FAILURE;


   }


   client = mongoc_client_new_from_uri (uri);


   if (!client) {


      return EXIT_FAILURE;


   }


   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 EXIT_FAILURE;


   }


   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_uri_destroy (uri);


   mongoc_database_destroy (database);


   mongoc_collection_destroy (collection);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return EXIT_SUCCESS;
}

• 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 <stdio.h>
#include <stdlib.h>
#include <mongoc/mongoc.h>
int
main (int argc, char *argv[])
{


   const char *uri_string =


      "mongodb://localhost:27017/?appname=new-gridfs-example";


   mongoc_client_t *client;


   mongoc_database_t *db;


   mongoc_stream_t *file_stream;


   mongoc_gridfs_bucket_t *bucket;


   mongoc_cursor_t *cursor;


   bson_t filter;


   bool res;


   bson_value_t file_id;


   bson_error_t error;


   const bson_t *doc;


   char *str;


   mongoc_init ();


   if (argc != 3) {


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


      return EXIT_FAILURE;


   }


   /* 1. Make a bucket. */


   client = mongoc_client_new (uri_string);


   db = mongoc_client_get_database (client, "test");


   bucket = mongoc_gridfs_bucket_new (db, NULL, NULL, &error);


   if (!bucket) {


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


      return EXIT_FAILURE;


   }


   /* 2. Insert a file.  */


   file_stream = mongoc_stream_file_new_for_path (argv[1], O_RDONLY, 0);


   res = mongoc_gridfs_bucket_upload_from_stream (


      bucket, "my-file", file_stream, NULL, &file_id, &error);


   if (!res) {


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


      return EXIT_FAILURE;


   }


   mongoc_stream_close (file_stream);


   mongoc_stream_destroy (file_stream);


   /* 3. Download the file in GridFS to a local file. */


   file_stream = mongoc_stream_file_new_for_path (argv[2], O_CREAT | O_RDWR, 0);


   if (!file_stream) {


      perror ("Error opening file stream");


      return EXIT_FAILURE;


   }


   res = mongoc_gridfs_bucket_download_to_stream (


      bucket, &file_id, file_stream, &error);


   if (!res) {


      printf ("Error downloading file to stream: %s\n", error.message);


      return EXIT_FAILURE;


   }


   mongoc_stream_close (file_stream);


   mongoc_stream_destroy (file_stream);


   /* 4. List what files are available in GridFS. */


   bson_init (&filter);


   cursor = mongoc_gridfs_bucket_find (bucket, &filter, NULL);


   while (mongoc_cursor_next (cursor, &doc)) {


      str = bson_as_canonical_extended_json (doc, NULL);


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


      bson_free (str);


   }


   /* 5. Delete the file that we added. */


   res = mongoc_gridfs_bucket_delete_by_id (bucket, &file_id, &error);


   if (!res) {


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


      return EXIT_FAILURE;


   }


   /* 6. Cleanup. */


   mongoc_stream_close (file_stream);


   mongoc_stream_destroy (file_stream);


   mongoc_cursor_destroy (cursor);


   bson_destroy (&filter);


   mongoc_gridfs_bucket_destroy (bucket);


   mongoc_database_destroy (db);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return EXIT_SUCCESS;
}

• The MongoDB GridFS specification.
• The non spec-compliant mongoc_gridfs_t.

#include <assert.h>
#include <mongoc/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;


   const char *uri_string = "mongodb://127.0.0.1:27017/?appname=gridfs-example";


   mongoc_uri_t *uri;


   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 EXIT_FAILURE;


   }


   mongoc_init ();


   iov.iov_base = (void *) buf;


   iov.iov_len = sizeof buf;


   /* connect to localhost client */


   uri = mongoc_uri_new_with_error (uri_string, &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               uri_string,


               error.message);


      return EXIT_FAILURE;


   }


   client = mongoc_client_new_from_uri (uri);


   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 EXIT_FAILURE;


      }


      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 EXIT_FAILURE;


      }


      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 EXIT_FAILURE;


      }


      if (!mongoc_gridfs_file_save (file)) {


         mongoc_gridfs_file_error (file, &error);


         fprintf (stderr, "Could not save: %s\n", error.message);


         return EXIT_FAILURE;


      }


      mongoc_gridfs_file_destroy (file);


   } else {


      fprintf (stderr, "Unknown command");


      return EXIT_FAILURE;


   }


   mongoc_gridfs_destroy (gridfs);


   mongoc_uri_destroy (uri);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return EXIT_SUCCESS;
}

• The MongoDB GridFS specification.
• The spec-compliant mongoc_gridfs_bucket_t.

#include <bson/bson.h>
#include <mongoc/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_canonical_extended_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

• mongoc_transaction_opts_set_read_concern
• mongoc_transaction_opts_set_write_concern
• mongoc_transaction_opts_set_read_prefs

/* gcc example-transaction.c -o example-transaction \


 *     $(pkg-config --cflags --libs libmongoc-1.0) */
/* ./example-transaction [CONNECTION_STRING] */
#include <stdio.h>
#include <mongoc/mongoc.h>
int
main (int argc, char *argv[])
{


   int exit_code = EXIT_FAILURE;


   mongoc_client_t *client = NULL;


   mongoc_database_t *database = NULL;


   mongoc_collection_t *collection = NULL;


   mongoc_client_session_t *session = NULL;


   mongoc_session_opt_t *session_opts = NULL;


   mongoc_transaction_opt_t *default_txn_opts = NULL;


   mongoc_transaction_opt_t *txn_opts = NULL;


   mongoc_read_concern_t *read_concern = NULL;


   mongoc_write_concern_t *write_concern = NULL;


   const char *uri_string = "mongodb://127.0.0.1/?appname=transaction-example";


   mongoc_uri_t *uri;


   bson_error_t error;


   bson_t *doc = NULL;


   bson_t *insert_opts = NULL;


   int32_t i;


   int64_t start;


   bson_t reply = BSON_INITIALIZER;


   char *reply_json;


   bool r;


   mongoc_init ();


   if (argc > 1) {


      uri_string = argv[1];


   }


   uri = mongoc_uri_new_with_error (uri_string, &error);


   if (!uri) {


      MONGOC_ERROR ("failed to parse URI: %s\n"


                    "error message:       %s\n",


                    uri_string,


                    error.message);


      goto done;


   }


   client = mongoc_client_new_from_uri (uri);


   if (!client) {


      goto done;


   }


   mongoc_client_set_error_api (client, 2);


   database = mongoc_client_get_database (client, "example-transaction");


   /* inserting into a nonexistent collection normally creates it, but a


    * collection can't be created in a transaction; create it now */


   collection =


      mongoc_database_create_collection (database, "collection", NULL, &error);


   if (!collection) {


      /* code 48 is NamespaceExists, see error_codes.err in mongodb source */


      if (error.code == 48) {


         collection = mongoc_database_get_collection (database, "collection");


      } else {


         MONGOC_ERROR ("Failed to create collection: %s", error.message);


         goto done;


      }


   }


   /* a transaction's read preferences, read concern, and write concern can be


    * set on the client, on the default transaction options, or when starting


    * the transaction. for the sake of this example, set read concern on the


    * default transaction options. */


   default_txn_opts = mongoc_transaction_opts_new ();


   read_concern = mongoc_read_concern_new ();


   mongoc_read_concern_set_level (read_concern, "snapshot");


   mongoc_transaction_opts_set_read_concern (default_txn_opts, read_concern);


   session_opts = mongoc_session_opts_new ();


   mongoc_session_opts_set_default_transaction_opts (session_opts,


                                                     default_txn_opts);


   session = mongoc_client_start_session (client, session_opts, &error);


   if (!session) {


      MONGOC_ERROR ("Failed to start session: %s", error.message);


      goto done;


   }


   /* in this example, set write concern when starting the transaction */


   txn_opts = mongoc_transaction_opts_new ();


   write_concern = mongoc_write_concern_new ();


   mongoc_write_concern_set_wmajority (write_concern, 1000 /* wtimeout */);


   mongoc_transaction_opts_set_write_concern (txn_opts, write_concern);


   insert_opts = bson_new ();


   if (!mongoc_client_session_append (session, insert_opts, &error)) {


      MONGOC_ERROR ("Could not add session to opts: %s", error.message);


      goto done;


   }
retry_transaction:


   r = mongoc_client_session_start_transaction (session, txn_opts, &error);


   if (!r) {


      MONGOC_ERROR ("Failed to start transaction: %s", error.message);


      goto done;


   }


   /* insert two documents - on error, retry the whole transaction */


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


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


      bson_destroy (&reply);


      r = mongoc_collection_insert_one (


         collection, doc, insert_opts, &reply, &error);


      bson_destroy (doc);


      if (!r) {


         MONGOC_ERROR ("Insert failed: %s", error.message);


         mongoc_client_session_abort_transaction (session, NULL);


         /* a network error, primary failover, or other temporary error in a


          * transaction includes {"errorLabels": ["TransientTransactionError"]},


          * meaning that trying the entire transaction again may succeed


          */


         if (mongoc_error_has_label (&reply, "TransientTransactionError")) {


            goto retry_transaction;


         }


         goto done;


      }


      reply_json = bson_as_json (&reply, NULL);


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


      bson_free (reply_json);


   }


   /* in case of transient errors, retry for 5 seconds to commit transaction */


   start = bson_get_monotonic_time ();


   while (bson_get_monotonic_time () - start < 5 * 1000 * 1000) {


      bson_destroy (&reply);


      r = mongoc_client_session_commit_transaction (session, &reply, &error);


      if (r) {


         /* success */


         break;


      } else {


         MONGOC_ERROR ("Warning: commit failed: %s", error.message);


         if (mongoc_error_has_label (&reply, "TransientTransactionError")) {


            goto retry_transaction;


         } else if (mongoc_error_has_label (&reply,


                                            "UnknownTransactionCommitResult")) {


            /* try again to commit */


            continue;


         }


         /* unrecoverable error trying to commit */


         break;


      }


   }


   exit_code = EXIT_SUCCESS;
done:


   bson_destroy (&reply);


   bson_destroy (insert_opts);


   mongoc_write_concern_destroy (write_concern);


   mongoc_read_concern_destroy (read_concern);


   mongoc_transaction_opts_destroy (txn_opts);


   mongoc_transaction_opts_destroy (default_txn_opts);


   mongoc_client_session_destroy (session);


   mongoc_collection_destroy (collection);


   mongoc_database_destroy (database);


   mongoc_uri_destroy (uri);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return exit_code;
}

1.

"mongodb" is the specifier of the MongoDB protocol. Use "mongodb+srv" with a single service name in place of "host1" to specify the initial list of servers with an SRV record.

2.

An optional username and password.

3.

The only required part of the uri. This specifies either a hostname, IPv4 address, IPv6 address enclosed in "[" and "]", 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/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_relaxed_extended_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_relaxed_extended_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;


   bson_error_t error;


   const char *uri_string =


      "mongodb://127.0.0.1/?appname=cmd-monitoring-example";


   mongoc_uri_t *uri;


   const char *collection_name = "test";


   bson_t *docs[2];


   mongoc_init ();


   if (argc > 1) {


      uri_string = argv[1];


   }


   uri = mongoc_uri_new_with_error (uri_string, &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               uri_string,


               error.message);


      return EXIT_FAILURE;


   }


   client = mongoc_client_new_from_uri (uri);


   if (!client) {


      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 */);


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


   mongoc_collection_drop (collection, NULL);


   docs[0] = BCON_NEW ("_id", BCON_INT32 (0));


   docs[1] = BCON_NEW ("_id", BCON_INT32 (1));


   mongoc_collection_insert_many (


      collection, (const bson_t **) docs, 2, NULL, NULL, NULL);


   /* duplicate key error on the second insert */


   mongoc_collection_insert_one (collection, docs[0], NULL, NULL, NULL);


   mongoc_collection_destroy (collection);


   mongoc_apm_callbacks_destroy (callbacks);


   mongoc_uri_destroy (uri);


   mongoc_client_destroy (client);


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


           stats.started,


           stats.succeeded,


           stats.failed);


   bson_destroy (docs[0]);


   bson_destroy (docs[1]);


   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/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;


   mongoc_read_prefs_t *prefs;


   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);


      }


   }


   prefs = mongoc_read_prefs_new (MONGOC_READ_SECONDARY);


   /* it is safe, and unfortunately necessary, to cast away const here */


   if (mongoc_topology_description_has_readable_server (


          (mongoc_topology_description_t *) new_td, prefs)) {


      printf ("  secondary AVAILABLE\n");


   } else {


      printf ("  secondary UNAVAILABLE\n");


   }


   if (mongoc_topology_description_has_writable_server (


          (mongoc_topology_description_t *) new_td)) {


      printf ("  primary AVAILABLE\n");


   } else {


      printf ("  primary UNAVAILABLE\n");


   }


   mongoc_read_prefs_destroy (prefs);


   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_canonical_extended_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 *uri_string =


      "mongodb://127.0.0.1/?appname=sdam-monitoring-example";


   mongoc_uri_t *uri;


   bson_t cmd = BSON_INITIALIZER;


   bson_t reply;


   bson_error_t error;


   mongoc_init ();


   if (argc > 1) {


      uri_string = argv[1];


   }


   uri = mongoc_uri_new_with_error (uri_string, &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               uri_string,


               error.message);


      return EXIT_FAILURE;


   }


   client = mongoc_client_new_from_uri (uri);


   if (!client) {


      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_uri_destroy (uri);


   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;
}