$ apt-get install libmongoc-1.0-0

$ dnf install mongo-c-driver

$ yum install mongo-c-driver

$ brew install mongo-c-driver

$ apt-get install libbson-1.0-0

$ dnf install libbson

$ yum install libbson

$ sudo yum install cmake openssl-devel cyrus-sasl-devel

$ sudo apt-get install cmake libssl-dev libsasl2-dev

$ su -c 'pkg install cmake openssl cyrus-sasl'

$ xcode-select --install

$ brew install cmake

$ pacman --noconfirm -Syu
$ pacman --noconfirm -S mingw-w64-x86_64-gcc mingw-w64-x86_64-cmake
$ pacman --noconfirm -S mingw-w64-x86_64-extra-cmake-modules make tar
$ pacman --noconfirm -S mingw64/mingw-w64-x86_64-cyrus-sasl

$ wget https://github.com/mongodb/mongo-c-driver/releases/download/1.23.0/mongo-c-driver-1.23.0.tar.gz
$ tar xzf mongo-c-driver-1.23.0.tar.gz
$ cd mongo-c-driver-1.23.0
$ mkdir cmake-build
$ cd cmake-build
$ cmake -DENABLE_AUTOMATIC_INIT_AND_CLEANUP=OFF ..

-- Build files have been written to: /home/user/mongo-c-driver-1.23.0/cmake-build

$ cmake -DENABLE_AUTOMATIC_INIT_AND_CLEANUP=OFF -DENABLE_MONGOC=OFF ..

$ git clone https://github.com/mongodb/mongo-c-driver.git
$ cd mongo-c-driver
$ git checkout 1.23.0  # To build a particular release
$ python build/calc_release_version.py > VERSION_CURRENT
$ mkdir cmake-build
$ cd cmake-build
$ cmake -DENABLE_AUTOMATIC_INIT_AND_CLEANUP=OFF ..

$ cd mongo-c-driver-1.23.0
$ mkdir cmake-build
$ cd cmake-build
$ cmake -G "Visual Studio 14 2015 Win64" \


    "-DCMAKE_INSTALL_PREFIX=C:\mongo-c-driver" \


    "-DCMAKE_PREFIX_PATH=C:\mongo-c-driver" \


    ..

$ cmake --help

$ cmake --build .
$ sudo cmake --build . --target install

$ cmake --build . help

$ cmake --build . --config RelWithDebInfo

$ cmake --build . --config RelWithDebInfo --target install

$ cmake --build . -- /targets

$ cmake -DENABLE_MAN_PAGES=ON -DENABLE_HTML_DOCS=ON ..
$ cmake --build . --target mongoc-doc

$ cmake -DENABLE_MAN_PAGES=ON -DENABLE_HTML_DOCS=ON ..
$ cmake --build . --target bson-doc

$ sudo /usr/local/share/mongo-c-driver/uninstall.sh

$ C:\mongo-c-driver\share\mongo-c-driver\uninstall.bat

$ sudo cmake --build . --target uninstall

$ cmake -DBSON_OUTPUT_BASENAME=custom_bson -DMONGOC_OUTPUT_BASENAME=custom_mongoc ..

• Installing
• Starting MongoDB
• Include and link libmongoc in your C program
• Use libmongoc in a Microsoft Visual Studio Project
• Making a Connection
• Creating BSON Documents
• Basic CRUD Operations
• Executing Commands
• Threading
• Next Steps

$ mongo --host localhost --port 27017
MongoDB shell version: 3.0.6
connecting to: localhost:27017/test
>

#include <mongoc/mongoc.h>

# Specify the minimum version you require.
find_package (mongoc-1.0 1.7 REQUIRED)
# The "hello_mongoc.c" sample program is shared among four tests.
add_executable (hello_mongoc ../../hello_mongoc.c)
target_link_libraries (hello_mongoc PRIVATE mongo::mongoc_shared)

# Specify the minimum version you require.
find_package (mongoc-1.0 1.7 REQUIRED)
# The "hello_mongoc.c" sample program is shared among four tests.
add_executable (hello_mongoc ../../hello_mongoc.c)
target_link_libraries (hello_mongoc PRIVATE mongo::mongoc_static)

gcc -o hello_mongoc hello_mongoc.c $(pkg-config --libs --cflags libmongoc-1.0)

gcc -o hello_mongoc hello_mongoc.c $(pkg-config --libs --cflags libmongoc-static-1.0)

$ gcc -o hello_mongoc hello_mongoc.c \


    -I/usr/local/include/libbson-1.0 -I/usr/local/include/libmongoc-1.0 \


    -lmongoc-1.0 -lbson-1.0
$ ./hello_mongoc
{ "ok" : 1.000000 }

C:\> cl.exe /IC:\mongo-c-driver\include\libbson-1.0 /IC:\mongo-c-driver\include\libmongoc-1.0 hello_mongoc.c
C:\> hello_mongoc
{ "ok" : 1.000000 }

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

{


   born : ISODate("1906-12-09"),


   died : ISODate("1992-01-01"),


   name : {


      first : "Grace",


      last : "Hopper"


   },


   languages : [ "MATH-MATIC", "FLOW-MATIC", "COBOL" ],


   degrees: [ { degree: "BA", school: "Vassar" }, { degree: "PhD", school: "Yale" } ]
}

#include <bson/bson.h>
int
main (int   argc,


      char *argv[])
{


   struct tm   born = { 0 };


   struct tm   died = { 0 };


   const char *lang_names[] = {"MATH-MATIC", "FLOW-MATIC", "COBOL"};


   const char *schools[] = {"Vassar", "Yale"};


   const char *degrees[] = {"BA", "PhD"};


   uint32_t    i;


   char        buf[16];


   const       char *key;


   size_t      keylen;


   bson_t     *document;


   bson_t      child;


   bson_t      child2;


   char       *str;


   document = bson_new ();


   /*


    * Append { "born" : ISODate("1906-12-09") } to the document.


    * Passing -1 for the length argument tells libbson to calculate the string length.


    */


   born.tm_year = 6;  /* years are 1900-based */


   born.tm_mon = 11;  /* months are 0-based */


   born.tm_mday = 9;


   bson_append_date_time (document, "born", -1, mktime (&born) * 1000);


   /*


    * Append { "died" : ISODate("1992-01-01") } to the document.


    */


   died.tm_year = 92;


   died.tm_mon = 0;


   died.tm_mday = 1;


   /*


    * For convenience, this macro passes length -1 by default.


    */


   BSON_APPEND_DATE_TIME (document, "died", mktime (&died) * 1000);


   /*


    * Append a subdocument.


    */


   BSON_APPEND_DOCUMENT_BEGIN (document, "name", &child);


   BSON_APPEND_UTF8 (&child, "first", "Grace");


   BSON_APPEND_UTF8 (&child, "last", "Hopper");


   bson_append_document_end (document, &child);


   /*


    * Append array of strings. Generate keys "0", "1", "2".


    */


   BSON_APPEND_ARRAY_BEGIN (document, "languages", &child);


   for (i = 0; i < sizeof lang_names / sizeof (char *); ++i) {


      keylen = bson_uint32_to_string (i, &key, buf, sizeof buf);


      bson_append_utf8 (&child, key, (int) keylen, lang_names[i], -1);


   }


   bson_append_array_end (document, &child);


   /*


    * Array of subdocuments:


    *    degrees: [ { degree: "BA", school: "Vassar" }, ... ]


    */


   BSON_APPEND_ARRAY_BEGIN (document, "degrees", &child);


   for (i = 0; i < sizeof degrees / sizeof (char *); ++i) {


      keylen = bson_uint32_to_string (i, &key, buf, sizeof buf);


      bson_append_document_begin (&child, key, (int) keylen, &child2);


      BSON_APPEND_UTF8 (&child2, "degree", degrees[i]);


      BSON_APPEND_UTF8 (&child2, "school", schools[i]);


      bson_append_document_end (&child, &child2);


   }


   bson_append_array_end (document, &child);


   /*


    * Print the document as a JSON string.


    */


   str = bson_as_canonical_extended_json (document, NULL);


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


   bson_free (str);


   /*


    * Clean up allocated bson documents.


    */


   bson_destroy (document);


   return 0;
}

#include <bson/bson.h>
int
main (int   argc,


      char *argv[])
{


   struct tm born = { 0 };


   struct tm died = { 0 };


   bson_t   *document;


   char     *str;


   born.tm_year = 6;


   born.tm_mon = 11;


   born.tm_mday = 9;


   died.tm_year = 92;


   died.tm_mon = 0;


   died.tm_mday = 1;


   document = BCON_NEW (


      "born", BCON_DATE_TIME (mktime (&born) * 1000),


      "died", BCON_DATE_TIME (mktime (&died) * 1000),


      "name", "{",


      "first", BCON_UTF8 ("Grace"),


      "last", BCON_UTF8 ("Hopper"),


      "}",


      "languages", "[",


      BCON_UTF8 ("MATH-MATIC"),


      BCON_UTF8 ("FLOW-MATIC"),


      BCON_UTF8 ("COBOL"),


      "]",


      "degrees", "[",


      "{", "degree", BCON_UTF8 ("BA"), "school", BCON_UTF8 ("Vassar"), "}",


      "{", "degree", BCON_UTF8 ("PhD"), "school", BCON_UTF8 ("Yale"), "}",


      "]");


   /*


    * Print the document as a JSON string.


    */


   str = bson_as_canonical_extended_json (document, NULL);


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


   bson_free (str);


   /*


    * Clean up allocated bson documents.


    */


   bson_destroy (document);


   return 0;
}

#include <bson/bson.h>
int
main (int   argc,


      char *argv[])
{


   bson_error_t error;


   bson_t      *bson;


   char        *string;


   const char *json = "{\"name\": {\"first\":\"Grace\", \"last\":\"Hopper\"}}";


   bson = bson_new_from_json ((const uint8_t *)json, -1, &error);


   if (!bson) {


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


      return EXIT_FAILURE;


   }


   string = bson_as_canonical_extended_json (bson, NULL);


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


   bson_free (string);


   return 0;
}

#include <bson/bson.h>
#include <mongoc/mongoc.h>
#include <stdio.h>
int
main (int   argc,


      char *argv[])
{


    mongoc_client_t *client;


    mongoc_collection_t *collection;


    bson_error_t error;


    bson_oid_t oid;


    bson_t *doc;


    mongoc_init ();


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


    collection = mongoc_client_get_collection (client, "mydb", "mycoll");


    doc = bson_new ();


    bson_oid_init (&oid, NULL);


    BSON_APPEND_OID (doc, "_id", &oid);


    BSON_APPEND_UTF8 (doc, "hello", "world");


    if (!mongoc_collection_insert_one (


           collection, doc, NULL, NULL, &error)) {


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


    }


    bson_destroy (doc);


    mongoc_collection_destroy (collection);


    mongoc_client_destroy (client);


    mongoc_cleanup ();


    return 0;
}

$ gcc -o insert insert.c $(pkg-config --cflags --libs libmongoc-1.0)
$ ./insert

C:\> cl.exe /IC:\mongo-c-driver\include\libbson-1.0 /IC:\mongo-c-driver\include\libmongoc-1.0 insert.c
C:\> insert

$ mongo
MongoDB shell version: 3.0.6
connecting to: test
> use mydb
switched to db mydb
> db.mycoll.find()
{ "_id" : ObjectId("55ef43766cb5f36a3bae6ee4"), "hello" : "world" }
>

{ "color" : "red" }

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


   mongoc_client_t *client;


   mongoc_collection_t *collection;


   mongoc_cursor_t *cursor;


   const bson_t *doc;


   bson_t *query;


   char *str;


   mongoc_init ();


   client =


      mongoc_client_new ("mongodb://localhost:27017/?appname=find-example");


   collection = mongoc_client_get_collection (client, "mydb", "mycoll");


   query = bson_new ();


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


   while (mongoc_cursor_next (cursor, &doc)) {


      str = bson_as_canonical_extended_json (doc, NULL);


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


      bson_free (str);


   }


   bson_destroy (query);


   mongoc_cursor_destroy (cursor);


   mongoc_collection_destroy (collection);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return 0;
}

$ gcc -o find find.c $(pkg-config --cflags --libs libmongoc-1.0)
$ ./find
{ "_id" : { "$oid" : "55ef43766cb5f36a3bae6ee4" }, "hello" : "world" }

C:\> cl.exe /IC:\mongo-c-driver\include\libbson-1.0 /IC:\mongo-c-driver\include\libmongoc-1.0 find.c
C:\> find
{ "_id" : { "$oid" : "55ef43766cb5f36a3bae6ee4" }, "hello" : "world" }

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


   mongoc_client_t *client;


   mongoc_collection_t *collection;


   mongoc_cursor_t *cursor;


   const bson_t *doc;


   bson_t *query;


   char *str;


   mongoc_init ();


   client = mongoc_client_new (


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


   collection = mongoc_client_get_collection (client, "mydb", "mycoll");


   query = bson_new ();


   BSON_APPEND_UTF8 (query, "hello", "world");


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


   while (mongoc_cursor_next (cursor, &doc)) {


      str = bson_as_canonical_extended_json (doc, NULL);


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


      bson_free (str);


   }


   bson_destroy (query);


   mongoc_cursor_destroy (cursor);


   mongoc_collection_destroy (collection);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return 0;
}

$ gcc -o find-specific find-specific.c $(pkg-config --cflags --libs libmongoc-1.0)
$ ./find-specific
{ "_id" : { "$oid" : "55ef43766cb5f36a3bae6ee4" }, "hello" : "world" }

C:\> cl.exe /IC:\mongo-c-driver\include\libbson-1.0 /IC:\mongo-c-driver\include\libmongoc-1.0 find-specific.c
C:\> find-specific
{ "_id" : { "$oid" : "55ef43766cb5f36a3bae6ee4" }, "hello" : "world" }

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


   mongoc_collection_t *collection;


   mongoc_client_t *client;


   bson_error_t error;


   bson_oid_t oid;


   bson_t *doc = NULL;


   bson_t *update = NULL;


   bson_t *query = NULL;


   mongoc_init ();


   client =


      mongoc_client_new ("mongodb://localhost:27017/?appname=update-example");


   collection = mongoc_client_get_collection (client, "mydb", "mycoll");


   bson_oid_init (&oid, NULL);


   doc = BCON_NEW ("_id", BCON_OID (&oid), "key", BCON_UTF8 ("old_value"));


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


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


      goto fail;


   }


   query = BCON_NEW ("_id", BCON_OID (&oid));


   update = BCON_NEW ("$set",


                      "{",


                      "key",


                      BCON_UTF8 ("new_value"),


                      "updated",


                      BCON_BOOL (true),


                      "}");


   if (!mongoc_collection_update_one (


          collection, query, update, NULL, NULL, &error)) {


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


      goto fail;


   }
fail:


   if (doc)


      bson_destroy (doc);


   if (query)


      bson_destroy (query);


   if (update)


      bson_destroy (update);


   mongoc_collection_destroy (collection);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return 0;
}

$ gcc -o update update.c $(pkg-config --cflags --libs libmongoc-1.0)
$ ./update

C:\> cl.exe /IC:\mongo-c-driver\include\libbson-1.0 /IC:\mongo-c-driver\include\libmongoc-1.0 update.c
C:\> update
{ "_id" : { "$oid" : "55ef43766cb5f36a3bae6ee4" }, "hello" : "world" }

$ mongo
MongoDB shell version: 3.0.6
connecting to: test
> use mydb
switched to db mydb
> db.mycoll.find({"updated" : true})
{ "_id" : ObjectId("55ef549236fe322f9490e17b"), "updated" : true, "key" : "new_value" }
>

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


   mongoc_client_t *client;


   mongoc_collection_t *collection;


   bson_error_t error;


   bson_oid_t oid;


   bson_t *doc;


   mongoc_init ();


   client =


      mongoc_client_new ("mongodb://localhost:27017/?appname=delete-example");


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


   doc = bson_new ();


   bson_oid_init (&oid, NULL);


   BSON_APPEND_OID (doc, "_id", &oid);


   BSON_APPEND_UTF8 (doc, "hello", "world");


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


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


   }


   bson_destroy (doc);


   doc = bson_new ();


   BSON_APPEND_OID (doc, "_id", &oid);


   if (!mongoc_collection_delete_one (


          collection, doc, NULL, NULL, &error)) {


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


   }


   bson_destroy (doc);


   mongoc_collection_destroy (collection);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return 0;
}

$ gcc -o delete delete.c $(pkg-config --cflags --libs libmongoc-1.0)
$ ./delete

C:\> cl.exe /IC:\mongo-c-driver\include\libbson-1.0 /IC:\mongo-c-driver\include\libmongoc-1.0 delete.c
C:\> delete

$ mongo
MongoDB shell version: 3.0.6
connecting to: test
> use mydb
switched to db mydb
> db.mycoll.count({"hello" : "world"})
0
>

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


   mongoc_client_t *client;


   mongoc_collection_t *collection;


   bson_error_t error;


   bson_t *doc;


   int64_t count;


   mongoc_init ();


   client =


      mongoc_client_new ("mongodb://localhost:27017/?appname=count-example");


   collection = mongoc_client_get_collection (client, "mydb", "mycoll");


   doc = bson_new_from_json (


      (const uint8_t *) "{\"hello\" : \"world\"}", -1, &error);


   count = mongoc_collection_count (


      collection, MONGOC_QUERY_NONE, doc, 0, 0, NULL, &error);


   if (count < 0) {


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


   } else {


      printf ("%" PRId64 "\n", count);


   }


   bson_destroy (doc);


   mongoc_collection_destroy (collection);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return 0;
}

$ gcc -o count count.c $(pkg-config --cflags --libs libmongoc-1.0)
$ ./count
1

C:\> cl.exe /IC:\mongo-c-driver\include\libbson-1.0 /IC:\mongo-c-driver\include\libmongoc-1.0 count.c
C:\> count
1

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


   mongoc_client_t *client;


   mongoc_collection_t *collection;


   bson_error_t error;


   bson_t *command;


   bson_t reply;


   char *str;


   mongoc_init ();


   client = mongoc_client_new (


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


   collection = mongoc_client_get_collection (client, "mydb", "mycoll");


   command = BCON_NEW ("collStats", BCON_UTF8 ("mycoll"));


   if (mongoc_collection_command_simple (


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


      str = bson_as_canonical_extended_json (&reply, NULL);


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


      bson_free (str);


   } else {


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


   }


   bson_destroy (command);


   bson_destroy (&reply);


   mongoc_collection_destroy (collection);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return 0;
}

$ gcc -o executing executing.c $(pkg-config --cflags --libs libmongoc-1.0)
$ ./executing
{ "ns" : "mydb.mycoll", "count" : 1, "size" : 48, "avgObjSize" : 48, "numExtents" : 1, "storageSize" : 8192,
"lastExtentSize" : 8192.000000, "paddingFactor" : 1.000000, "userFlags" : 1, "capped" : false, "nindexes" : 1,
"indexDetails" : {  }, "totalIndexSize" : 8176, "indexSizes" : { "_id_" : 8176 }, "ok" : 1.000000 }

C:\> cl.exe /IC:\mongo-c-driver\include\libbson-1.0 /IC:\mongo-c-driver\include\libmongoc-1.0 executing.c
C:\> executing
{ "ns" : "mydb.mycoll", "count" : 1, "size" : 48, "avgObjSize" : 48, "numExtents" : 1, "storageSize" : 8192,
"lastExtentSize" : 8192.000000, "paddingFactor" : 1.000000, "userFlags" : 1, "capped" : false, "nindexes" : 1,
"indexDetails" : {  }, "totalIndexSize" : 8176, "indexSizes" : { "_id_" : 8176 }, "ok" : 1.000000 }

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

mongoc_client_t *client = mongoc_client_new ("mongodb://user:password@localhost/?authSource=mydb");

mongoc_client_t *client =  mongoc_client_new ("mongodb://user:password@localhost/?authSource=mydb");
/* the correct authMechanism is negotiated between the driver and server. */

mongoc_client_t *client =  mongoc_client_new ("mongodb://user:password@localhost/?authMechanism=SCRAM-SHA-256&authSource=mydb");

mongoc_client_t *client = mongoc_client_new ("mongodb://user:password@localhost/?authMechanism=SCRAM-SHA-1&authSource=mydb");

SCRAM-SHA-1 authenticates against the admin database by default. If the user is created in another database, then specifying the authSource is required.

On UNIX-like environments, Kerberos support requires compiling the driver against cyrus-sasl.

On Windows, Kerberos support requires compiling the driver against Windows Native SSPI or cyrus-sasl. The default configuration of the driver will use Windows Native SSPI.

To modify the default configuration, use the cmake option ENABLE_SASL.

$ kinit mongodbuser@EXAMPLE.COM
mongodbuser@EXAMPLE.COM's Password:
$ klistCredentials cache: FILE:/tmp/krb5cc_1000


        Principal: mongodbuser@EXAMPLE.COM


  Issued                Expires               Principal
Feb  9 13:48:51 2013  Feb  9 23:48:51 2013  krbtgt/EXAMPLE.COM@EXAMPLE.COM

mongoc_client_t *client;
client = mongoc_client_new ("mongodb://mongodbuser%40EXAMPLE.COM@mongo-server.example.com/?authMechanism=GSSAPI");

GSSAPI authenticates against the $external database, so specifying the authSource database is not required.

mongoc_client_t *client;
client = mongoc_client_new ("mongodb://mongodbuser%40EXAMPLE.COM@mongo-server.example.com/?authMechanism=GSSAPI&"


                            "authMechanismProperties=SERVICE_NAME:other,CANONICALIZE_HOST_NAME:true");

$ kinit -f -A mongodbuser@EXAMPLE.COM

The MongoDB C Driver must be compiled with SASL support in order to use SASL PLAIN authentication.

SASL PLAIN is a clear-text authentication mechanism. It is strongly recommended to connect to MongoDB using TLS with certificate validation when using the PLAIN mechanism.

mongoc_client_t *client;
client = mongoc_client_new ("mongodb://user:password@example.com/?authMechanism=PLAIN");

The MongoDB C Driver must be compiled with TLS support for X.509 authentication support. Once this is done, start a server with the following options:

mongoc_client_t *client;
mongoc_ssl_opt_t ssl_opts = { 0 };
ssl_opts.pem_file = "mycert.pem";
ssl_opts.pem_pwd = "mycertpassword";
ssl_opts.ca_file = "myca.pem";
ssl_opts.ca_dir = "trust_dir";
ssl_opts.weak_cert_validation = false;
client = mongoc_client_new ("mongodb://x509_derived_username@localhost/?authMechanism=MONGODB-X509");
mongoc_client_set_ssl_opts (client, &ssl_opts);

The MongoDB C Driver will attempt to determine the x509 derived username when none is provided, and as of MongoDB 3.4 providing the username is not required at all.

mongoc_uri_t *uri = mongoc_uri_new ("mongodb://localhost/?authMechanism=MONGODB-AWS");

mongoc_uri_t *uri = mongoc_uri_new ("mongodb://<access key id>:<secret access key>localhost/?authMechanism=MONGODB-AWS");

mongoc_uri_t *uri = mongoc_uri_new ("mongodb://<access key id>:<secret access key>localhost/?authMechanism=MONGODB-AWS&authMechanismProperties=AWS_SESSION_TOKEN:<token>");

$ mongoc-stat 22203


   Operations : Egress Total        : The number of sent operations.                    : 13247


   Operations : Ingress Total       : The number of received operations.                : 13246


   Operations : Egress Queries      : The number of sent Query operations.              : 13247


   Operations : Ingress Queries     : The number of received Query operations.          : 0


   Operations : Egress GetMore      : The number of sent GetMore operations.            : 0


   Operations : Ingress GetMore     : The number of received GetMore operations.        : 0


   Operations : Egress Insert       : The number of sent Insert operations.             : 0


   Operations : Ingress Insert      : The number of received Insert operations.         : 0


   Operations : Egress Delete       : The number of sent Delete operations.             : 0


   Operations : Ingress Delete      : The number of received Delete operations.         : 0


   Operations : Egress Update       : The number of sent Update operations.             : 0


   Operations : Ingress Update      : The number of received Update operations.         : 0


   Operations : Egress KillCursors  : The number of sent KillCursors operations.        : 0


   Operations : Ingress KillCursors : The number of received KillCursors operations.    : 0


   Operations : Egress Msg          : The number of sent Msg operations.                : 0


   Operations : Ingress Msg         : The number of received Msg operations.            : 0


   Operations : Egress Reply        : The number of sent Reply operations.              : 0


   Operations : Ingress Reply       : The number of received Reply operations.          : 13246


      Cursors : Active              : The number of active cursors.                     : 1


      Cursors : Disposed            : The number of disposed cursors.                   : 13246


      Clients : Active              : The number of active clients.                     : 1


      Clients : Disposed            : The number of disposed clients.                   : 0


      Streams : Active              : The number of active streams.                     : 1


      Streams : Disposed            : The number of disposed streams.                   : 0


      Streams : Egress Bytes        : The number of bytes sent.                         : 794931


      Streams : Ingress Bytes       : The number of bytes received.                     : 589694


      Streams : N Socket Timeouts   : The number of socket timeouts.                    : 0


 Client Pools : Active              : The number of active client pools.                : 1


 Client Pools : Disposed            : The number of disposed client pools.              : 0


     Protocol : Ingress Errors      : The number of protocol errors on ingress.         : 0


         Auth : Failures            : The number of failed authentication requests.     : 0


         Auth : Success             : The number of successful authentication requests. : 0

mongoc_uri_t *uri = mongoc_uri_new ("mongodb://localhost:27017/");
mongoc_uri_set_option_as_bool (uri, MONGOC_URI_TLS, true);
mongoc_client_t *client = mongoc_client_new_from_uri (uri);

mongoc_uri_t *uri = mongoc_uri_new ("mongodb://localhost:27017/");
mongoc_uri_set_option_as_bool (uri, MONGOC_URI_TLS, true);
mongoc_uri_set_option_as_utf8 (uri, MONGOC_URI_TLSCERTIFICATEKEYFILE, "/path/to/client-certificate.pem");
mongoc_client_t *client = mongoc_client_new_from_uri (uri);

$ openssl version

cmake -DOPENSSL_ROOT_DIR=/absolute/path/to/openssl

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

/*


 * 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"
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;


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


   }


   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;


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

$ mongod

$ mkdir /tmp/db2
$ mongod --dbpath /tmp/db2 --port 27018 # second instance

$ cd examples/common_operations/$ gcc -Wall -o example common-operations.c $(pkg-config --cflags --libs libmongoc-1.0)$ ./example localhost:27017 localhost:27018
Inserting data
explain
{


   "executionStats" : {


      "allPlansExecution" : [],


      "executionStages" : {


         "advanced" : 19,


         "direction" : "forward" ,


         "docsExamined" : 76,


         "executionTimeMillisEstimate" : 0,


         "filter" : {


            "x" : {


               "$eq" : 1


            }


         },


         "invalidates" : 0,


         "isEOF" : 1,


         "nReturned" : 19,


         "needTime" : 58,


         "needYield" : 0,


         "restoreState" : 0,


         "saveState" : 0,


         "stage" : "COLLSCAN" ,


         "works" : 78


      },


      "executionSuccess" : true,


      "executionTimeMillis" : 0,


      "nReturned" : 19,


      "totalDocsExamined" : 76,


      "totalKeysExamined" : 0


   },


   "ok" : 1,


   "queryPlanner" : {


      "indexFilterSet" : false,


      "namespace" : "test.things",


      "parsedQuery" : {


         "x" : {


            "$eq" : 1


         }


      },


      "plannerVersion" : 1,


      "rejectedPlans" : [],


      "winningPlan" : {


         "direction" : "forward" ,


         "filter" : {


            "x" : {


               "$eq" : 1


            }


         },


         "stage" : "COLLSCAN"


      }


   },


   "serverInfo" : {


      "gitVersion" : "05552b562c7a0b3143a729aaa0838e558dc49b25" ,


      "host" : "MacBook-Pro-57.local",


      "port" : 27017,


      "version" : "3.2.6"


   }
}

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


   mongoc_client_t *client;


   mongoc_init ();


   /* Create our MongoDB Client */


   client = mongoc_client_new (


      "mongodb://host01:27017,host02:27017,host03:27017/?replicaSet=myreplset");


   /* Do some work */


   /* TODO */


   /* Clean up */


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return 0;
}

Multiple hostnames can be specified in the MongoDB connection string URI, with a comma separating hosts in the seed list.

It is recommended to use a seed list of members of the replica set to allow the driver to connect to any node.

Specifying the replicaSet parameter when connecting to a mongos sharding server is invalid.

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


   mongoc_client_t *client;


   mongoc_init ();


   /* Create our MongoDB Client */


   client = mongoc_client_new ("mongodb://myshard01:27017/");


   /* Do something with client ... */


   /* Free the client */


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return 0;
}

mongoc_uri_t *uri = mongoc_uri_new ("mongodb://[::1]:27017");

mongoc_uri_t *uri = mongoc_uri_new ("mongodb://%2Ftmp%2Fmongodb-27017.sock");

mongoc_uri_t *uri = mongoc_uri_new ("mongodb://user:pass@%2Ftmp%2Fmongodb-27017.sock");

$ mongod --port 27017 --tlsMode requireTLS --tlsCertificateKeyFile server.pem --tlsCAFile ca.pem

mongoc_client_t *client = NULL;
client = mongoc_client_new ("mongodb://localhost:27017/?tls=true");

mongoc_client_t *client = NULL;
mongoc_uri_t *uri = mongoc_uri_new ("mongodb://localhost:27017/?tls=true");
mongoc_uri_set_option_as_utf8 (uri, MONGOC_URI_TLSCERTIFICATEKEYFILE, "client.pem");
client = mongoc_client_new_from_uri (uri);

mongoc_client_t *client = NULL;
client = mongoc_client_new ("mongodb://localhost:27017/?compressors=snappy,zlib,zstd");

mongoc_client_t *client = mongoc_client_new (


   "mongodb://hostA,hostB/?replicaSet=my_rs");

mongoc_uri_t *uri = mongoc_uri_new (


   "mongodb://hostA,hostB/?replicaSet=my_rs");
mongoc_client_pool_t *pool = mongoc_client_pool_new (uri);

mongoc_client_t *client = mongoc_client_pool_pop (pool);
/* use the client for operations ... */
mongoc_client_pool_push (pool, client);

mongoc_uri_t *uri = mongoc_uri_new (


   "mongodb://hostA,hostB/?replicaSet=my_rs&waitQueueTimeoutMS=1000");
mongoc_client_pool_t *pool = mongoc_client_pool_new (uri);
mongoc_client_t *client = mongoc_client_pool_pop (pool);
if (client) {


   /* use the client for operations ... */


   mongoc_client_pool_push (pool, client);
} else {


   /* take appropriate action for a timeout */
}

static void
print_all_documents (mongoc_collection_t *collection)
{


   mongoc_cursor_t *cursor;


   const bson_t *doc;


   bson_error_t error;


   bson_t query = BSON_INITIALIZER;


   char *str;


   cursor = mongoc_collection_find_with_opts (collection, query, 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, "Failed to iterate all documents: %s\n", error.message);


   }


   mongoc_cursor_destroy (cursor);
}

Tailable cursors are for capped collections only.

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

$ gcc -Wall -o mongoc-tail mongoc-tail.c $(pkg-config --cflags --libs libmongoc-1.0)
$ ./mongoc-tail mongodb://example.com/?replicaSet=myReplSet
{


    "h" : -8458503739429355503,


    "ns" : "test.test",


    "o" : {


        "_id" : {


            "$oid" : "5372ab0a25164be923d10d50"


        }


    },


    "op" : "i",


    "ts" : {


        "$timestamp" : {


            "i" : 1,


            "t" : 1400023818


        }


    },


    "v" : 2
}

mongoc_cursor_set_max_await_time_ms().

mongoc_bulk_operation_t *bulk =


   mongoc_collection_create_bulk_operation_with_opts (collection, NULL);

#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 (void)
{


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

{"nInserted"   : 10000,


 "nMatched"    : 0,


 "nModified"   : 0,


 "nRemoved"    : 0,


 "nUpserted"   : 0,


 "writeErrors" : []


 "writeConcernErrors" : [] }

#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 (void)
{


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

{ "nInserted"   : 3,


  "nMatched"    : 2,


  "nModified"   : 2,


  "nRemoved"    : 10000,


  "nUpserted"   : 1,


  "upserted"    : [{"index" : 5, "_id" : 4}],


  "writeErrors" : []


  "writeConcernErrors" : [] }

#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 (void)
{


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

{ "nInserted"    : 0,


  "nMatched"     : 1,


  "nModified"    : 1,


  "nRemoved"     : 1,


  "nUpserted"    : 0,


  "writeErrors"  : [


    { "index"  : 0,


      "code"   : 11000,


      "errmsg" : "E11000 duplicate key error index: test.test.$_id_ dup key: { : 1 }" },


    { "index"  : 2,


      "code"   : 11000,


      "errmsg" : "E11000 duplicate key error index: test.test.$_id_ dup key: { : 3 }" } ],


  "writeConcernErrors" : [] }
Error: E11000 duplicate key error index: test.test.$_id_ dup key: { : 1 }

#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 (void)
{


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

{ "nInserted" : 0,


  "nMatched" : 0,


  "nModified" : 0,


  "nRemoved" : 0,


  "nUpserted" : 0,


  "writeErrors" : [


    { "index" : 0,


      "code" : 121,


      "errmsg" : "Document failed validation" } ] }
Error: Document failed validation
{ "nInserted" : 2,


  "nMatched" : 0,


  "nModified" : 0,


  "nRemoved" : 0,


  "nUpserted" : 0,


  "writeErrors" : [] }

#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_int64 (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 (void)
{


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

{ "nInserted"    : 2,


  "nMatched"     : 0,


  "nModified"    : 0,


  "nRemoved"     : 0,


  "nUpserted"    : 0,


  "writeErrors"  : [],


  "writeConcernErrors" : [


    { "code"   : 64,


      "errmsg" : "waiting for replication timed out" }
] }
Error: waiting for replication timed out

#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 (void)
{


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

{ "nInserted" : 2,


   "nMatched" : 1,


   "nModified" : 1,


   "nRemoved" : 0,


   "nUpserted" : 0,


   "writeErrors" : [  ]
}

#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 (void)
{


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

{ }

$ mongoimport --drop -d test -c zipcodes zips.json

$ mongo test
connecting to: test
> db.zipcodes.count()
29467
> db.zipcodes.findOne()
{


      "_id" : "35004",


      "city" : "ACMAR",


      "loc" : [


              -86.51557,


              33.584132


      ],


      "pop" : 6055,


      "state" : "AL"
}

{


  "_id" : "35004",


  "city" : "Acmar",


  "state" : "AL",


  "pop" : 6055,


  "loc" : [-86.51557, 33.584132]
}

#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 (void)
{


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

{ "_id" : "PA", "total_pop" : 11881643 }
{ "_id" : "OH", "total_pop" : 10847115 }
{ "_id" : "NY", "total_pop" : 17990455 }
{ "_id" : "FL", "total_pop" : 12937284 }
{ "_id" : "TX", "total_pop" : 16986510 }
{ "_id" : "IL", "total_pop" : 11430472 }
{ "_id" : "CA", "total_pop" : 29760021 }

{ "_id" : "WA", "total_pop" : 4866692 }

pipeline = BCON_NEW ("pipeline", "[",


   "{", "$group", "{", "_id", "{", "state", "$state", "city", "$city", "}", "pop", "{", "$sum", "$pop", "}", "}", "}",


   "{", "$group", "{", "_id", "$_id.state", "avg_city_pop", "{", "$avg", "$pop", "}", "}", "}",


   "{", "$sort", "{", "avg_city_pop", BCON_INT32 (-1), "}", "}",


   "{", "$limit", BCON_INT32 (3) "}",
"]");

{ "_id" : "DC", "avg_city_pop" : 303450.0 }
{ "_id" : "FL", "avg_city_pop" : 27942.29805615551 }
{ "_id" : "CA", "avg_city_pop" : 27735.341099720412 }

{ "_id" : { "state" : "WY", "city" : "Smoot" }, "pop" : 414 }

{ "_id" : "FL", "avg_city_pop" : 27942.29805615551 }

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

$ mongod

$ cd examples/basic_aggregation/
$ gcc -Wall -o agg-example basic-aggregation.c $(pkg-config --cflags --libs libmongoc-1.0)
$ ./agg-example localhost
Inserting data
distinct
Next double: 2.000000
Next double: 3.000000
map reduce
{ "result" : "outCollection", "timeMillis" : 155, "counts" : { "input" : 84, "emit" : 126, "reduce" : 3, "output" : 3 }, "ok" : 1 }
{ "_id" : "cat", "value" : 63 }
{ "_id" : "dog", "value" : 42 }
{ "_id" : "mouse", "value" : 21 }
more complicated map reduce
{ "results" : [ { "_id" : "cat", "value" : 63 }, { "_id" : "dog", "value" : 42 }, { "_id" : "mouse", "value" : 21 } ], "timeMillis" : 14, "counts" : { "input" : 84, "emit" : 126, "reduce" : 3, "output" : 3 }, "ok" : 1 }

C:\mongo-c-driver\include\libbson-1.0
C:\mongo-c-driver\include\libmongoc-1.0

C:\mongo-c-driver\lib\bson-1.0.lib
C:\mongo-c-driver\lib\mongoc-1.0.lib

PATH=c:/mongo-c-driver/bin

#include <mongoc/mongoc.h>

C:\mongo-c-driver\lib\bson-static-1.0.lib
C:\mongo-c-driver\lib\mongoc-static-1.0.lib
ws2_32.lib
Secur32.lib
Crypt32.lib
BCrypt.lib

#define BSON_STATIC
#define MONGOC_STATIC
#include <mongoc/mongoc.h>

The commitQuorum option to the createIndexes command is only supported in MongoDB 4.4+ servers, but it is not validated in the command functions. Do not pass commitQuorum if connected to server versions less than 4.4. Using the commitQuorum option on server versions less than 4.4 may have adverse effects on index builds.

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

add-auto-load-safe-path /path/to/mongo-c-driver

source path/to/mongo-c-driver/.gdbinit

(gdb) printbson bson
ALLOC [0x555556cd7310 + 0] (len=475)
{


    'bool' : true,


    'int32' : NumberInt("42"),


    'int64' : NumberLong("3000000042"),


    'string' : "Stŕìñg",


    'objectId' : ObjectID("5A1442F3122D331C3C6757E1"),


    'utcDateTime' : UTCDateTime(1511277299031),


    'arrayOfInts' : [


        '0' : NumberInt("1"),


        '1' : NumberInt("2")


    ],


    'embeddedDocument' : {


        'arrayOfStrings' : [


            '0' : "one",


            '1' : "two"


        ],


        'double' : 2.718280,


        'notherDoc' : {


            'true' : NumberInt("1"),


            'false' : false


        }


    },


    'binary' : Binary("02", "3031343532333637"),


    'regex' : Regex("@[a-z]+@", "im"),


    'null' : null,


    'js' : JavaScript("print foo"),


    'jsws' : JavaScript("print foo") with scope: {


        'f' : NumberInt("42"),


        'a' : [


            '0' : 3.141593,


            '1' : 2.718282


        ]


    },


    'timestamp' : Timestamp(4294967295, 4294967295),


    'double' : 3.141593
}

(lldb) print b
(bson_t) $0 = {"x": 1, "y": 2}

(lldb) bson --verbose b
len=19
flags=INLINE|STATIC
{


  "x": 1,


  "y": 2
}
(lldb) bson --raw b
'\x13\x00\x00\x00\x10x\x00\x01\x00\x00\x00\x10y\x00\x02\x00\x00\x00\x00'

python -m pip install pymongo

command script import /path/to/mongo-c-driver/lldb_bson.py

$ cd mongo-c-driver
$ mkdir cmake-build && cd cmake-build
$ cmake -DENABLE_AUTOMATIC_INIT_AND_CLEANUP=OFF -DENABLE_MONGOC=OFF ..
$ cmake --build . --target install

$ cd libmongocrypt
$ mkdir cmake-build && cd cmake-build
$ cmake -DENABLE_SHARED_BSON=ON ..
$ cmake --build . --target install

$ cd mongo-c-driver
$ mkdir cmake-build && cd cmake-build
$ cmake -DENABLE_AUTOMATIC_INIT_AND_CLEANUP=OFF -DENABLE_MONGOC=ON -DENABLE_CLIENT_SIDE_ENCRYPTION=ON ..
$ cmake --build . --target install

bson_t *extra = BCON_NEW ("mongocryptdSpawnPath", "/path/to/mongocryptd");
mongoc_auto_encryption_opts_set_extra (opts, extra);

bson_t *extra = BCON_NEW ("mongocryptdSpawnArgs",


   "[", "--logpath=/path/to/mongocryptd.log", "--logappend", "]");
mongoc_auto_encryption_opts_set_extra (opts, extra);

bson_t *extra = BCON_NEW ("mongocryptdBypassSpawn",


   BCON_BOOL(true), "mongocryptdURI", "mongodb://localhost:27020");
mongoc_auto_encryption_opts_set_extra (opts, extra);

Automatic client-side field level encryption requires MongoDB 4.2 enterprise or a MongoDB 4.2 Atlas cluster. The community version of the server supports automatic decryption as well as Explicit Encryption.

#include <mongoc/mongoc.h>
#include <stdio.h>
#include <stdlib.h>
#include "client-side-encryption-helpers.h"
/* Helper method to create a new data key in the key vault, a schema to use that


 * key, and writes the schema to a file for later use. */
static bool
create_schema_file (bson_t *kms_providers,


                    const char *keyvault_db,


                    const char *keyvault_coll,


                    mongoc_client_t *keyvault_client,


                    bson_error_t *error)
{


   mongoc_client_encryption_t *client_encryption = NULL;


   mongoc_client_encryption_opts_t *client_encryption_opts = NULL;


   mongoc_client_encryption_datakey_opts_t *datakey_opts = NULL;


   bson_value_t datakey_id = {0};


   char *keyaltnames[] = {"mongoc_encryption_example_1"};


   bson_t *schema = NULL;


   char *schema_string = NULL;


   size_t schema_string_len;


   FILE *outfile = NULL;


   bool ret = false;


   client_encryption_opts = mongoc_client_encryption_opts_new ();


   mongoc_client_encryption_opts_set_kms_providers (client_encryption_opts,


                                                    kms_providers);


   mongoc_client_encryption_opts_set_keyvault_namespace (


      client_encryption_opts, keyvault_db, keyvault_coll);


   mongoc_client_encryption_opts_set_keyvault_client (client_encryption_opts,


                                                      keyvault_client);


   client_encryption =


      mongoc_client_encryption_new (client_encryption_opts, error);


   if (!client_encryption) {


      goto fail;


   }


   /* Create a new data key and json schema for the encryptedField.


    * https://dochub.mongodb.org/core/client-side-field-level-encryption-automatic-encryption-rules


    */


   datakey_opts = mongoc_client_encryption_datakey_opts_new ();


   mongoc_client_encryption_datakey_opts_set_keyaltnames (


      datakey_opts, keyaltnames, 1);


   if (!mongoc_client_encryption_create_datakey (


          client_encryption, "local", datakey_opts, &datakey_id, error)) {


      goto fail;


   }


   /* Create a schema describing that "encryptedField" is a string encrypted


    * with the newly created data key using deterministic encryption. */


   schema = BCON_NEW ("properties",


                      "{",


                      "encryptedField",


                      "{",


                      "encrypt",


                      "{",


                      "keyId",


                      "[",


                      BCON_BIN (datakey_id.value.v_binary.subtype,


                                datakey_id.value.v_binary.data,


                                datakey_id.value.v_binary.data_len),


                      "]",


                      "bsonType",


                      "string",


                      "algorithm",


                      MONGOC_AEAD_AES_256_CBC_HMAC_SHA_512_DETERMINISTIC,


                      "}",


                      "}",


                      "}",


                      "bsonType",


                      "object");


   /* Use canonical JSON so that other drivers and tools will be


    * able to parse the MongoDB extended JSON file. */


   schema_string = bson_as_canonical_extended_json (schema, &schema_string_len);


   outfile = fopen ("jsonSchema.json", "w");


   if (0 == fwrite (schema_string, sizeof (char), schema_string_len, outfile)) {


      fprintf (stderr, "failed to write to file\n");


      goto fail;


   }


   ret = true;
fail:


   mongoc_client_encryption_destroy (client_encryption);


   mongoc_client_encryption_datakey_opts_destroy (datakey_opts);


   mongoc_client_encryption_opts_destroy (client_encryption_opts);


   bson_free (schema_string);


   bson_destroy (schema);


   bson_value_destroy (&datakey_id);


   if (outfile) {


      fclose (outfile);


   }


   return ret;
}
/* This example demonstrates how to use automatic encryption with a client-side


 * schema map using the enterprise version of MongoDB */
int
main (void)
{
/* The collection used to store the encryption data keys. */
#define KEYVAULT_DB "encryption"
#define KEYVAULT_COLL "__libmongocTestKeyVault"
/* The collection used to store the encrypted documents in this example. */
#define ENCRYPTED_DB "test"
#define ENCRYPTED_COLL "coll"


   int exit_status = EXIT_FAILURE;


   bool ret;


   uint8_t *local_masterkey = NULL;


   uint32_t local_masterkey_len;


   bson_t *kms_providers = NULL;


   bson_error_t error = {0};


   bson_t *index_keys = NULL;


   char *index_name = NULL;


   bson_t *create_index_cmd = NULL;


   bson_json_reader_t *reader = NULL;


   bson_t schema = BSON_INITIALIZER;


   bson_t *schema_map = NULL;


   /* The MongoClient used to access the key vault (keyvault_namespace). */


   mongoc_client_t *keyvault_client = NULL;


   mongoc_collection_t *keyvault_coll = NULL;


   mongoc_auto_encryption_opts_t *auto_encryption_opts = NULL;


   mongoc_client_t *client = NULL;


   mongoc_collection_t *coll = NULL;


   bson_t *to_insert = NULL;


   mongoc_client_t *unencrypted_client = NULL;


   mongoc_collection_t *unencrypted_coll = NULL;


   mongoc_init ();


   /* Configure the master key. This must be the same master key that was used


    * to create the encryption key. */


   local_masterkey =


      hex_to_bin (getenv ("LOCAL_MASTERKEY"), &local_masterkey_len);


   if (!local_masterkey || local_masterkey_len != 96) {


      fprintf (stderr,


               "Specify LOCAL_MASTERKEY environment variable as a "


               "secure random 96 byte hex value.\n");


      goto fail;


   }


   kms_providers = BCON_NEW ("local",


                             "{",


                             "key",


                             BCON_BIN (0, local_masterkey, local_masterkey_len),


                             "}");


   /* Set up the key vault for this example. */


   keyvault_client = mongoc_client_new (


      "mongodb://localhost/?appname=client-side-encryption-keyvault");


   keyvault_coll = mongoc_client_get_collection (


      keyvault_client, KEYVAULT_DB, KEYVAULT_COLL);


   mongoc_collection_drop (keyvault_coll, NULL);


   /* Create a unique index to ensure that two data keys cannot share the same


    * keyAltName. This is recommended practice for the key vault. */


   index_keys = BCON_NEW ("keyAltNames", BCON_INT32 (1));


   index_name = mongoc_collection_keys_to_index_string (index_keys);


   create_index_cmd = BCON_NEW ("createIndexes",


                                KEYVAULT_COLL,


                                "indexes",


                                "[",


                                "{",


                                "key",


                                BCON_DOCUMENT (index_keys),


                                "name",


                                index_name,


                                "unique",


                                BCON_BOOL (true),


                                "partialFilterExpression",


                                "{",


                                "keyAltNames",


                                "{",


                                "$exists",


                                BCON_BOOL (true),


                                "}",


                                "}",


                                "}",


                                "]");


   ret = mongoc_client_command_simple (keyvault_client,


                                       KEYVAULT_DB,


                                       create_index_cmd,


                                       NULL /* read prefs */,


                                       NULL /* reply */,


                                       &error);


   if (!ret) {


      goto fail;


   }


   /* Create a new data key and a schema using it for encryption. Save the


    * schema to the file jsonSchema.json */


   ret = create_schema_file (


      kms_providers, KEYVAULT_DB, KEYVAULT_COLL, keyvault_client, &error);


   if (!ret) {


      goto fail;


   }


   /* Load the JSON Schema and construct the local schema_map option. */


   reader = bson_json_reader_new_from_file ("jsonSchema.json", &error);


   if (!reader) {


      goto fail;


   }


   bson_json_reader_read (reader, &schema, &error);


   /* Construct the schema map, mapping the namespace of the collection to the


    * schema describing encryption. */


   schema_map =


      BCON_NEW (ENCRYPTED_DB "." ENCRYPTED_COLL, BCON_DOCUMENT (&schema));


   auto_encryption_opts = mongoc_auto_encryption_opts_new ();


   mongoc_auto_encryption_opts_set_keyvault_client (auto_encryption_opts,


                                                    keyvault_client);


   mongoc_auto_encryption_opts_set_keyvault_namespace (


      auto_encryption_opts, KEYVAULT_DB, KEYVAULT_COLL);


   mongoc_auto_encryption_opts_set_kms_providers (auto_encryption_opts,


                                                  kms_providers);


   mongoc_auto_encryption_opts_set_schema_map (auto_encryption_opts,


                                               schema_map);


   client =


      mongoc_client_new ("mongodb://localhost/?appname=client-side-encryption");


   /* Enable automatic encryption. It will determine that encryption is


    * necessary from the schema map instead of relying on the server to provide


    * a schema. */


   ret = mongoc_client_enable_auto_encryption (


      client, auto_encryption_opts, &error);


   if (!ret) {


      goto fail;


   }


   coll = mongoc_client_get_collection (client, ENCRYPTED_DB, ENCRYPTED_COLL);


   /* Clear old data */


   mongoc_collection_drop (coll, NULL);


   to_insert = BCON_NEW ("encryptedField", "123456789");


   ret = mongoc_collection_insert_one (


      coll, to_insert, NULL /* opts */, NULL /* reply */, &error);


   if (!ret) {


      goto fail;


   }


   printf ("decrypted document: ");


   if (!print_one_document (coll, &error)) {


      goto fail;


   }


   printf ("\n");


   unencrypted_client = mongoc_client_new (


      "mongodb://localhost/?appname=client-side-encryption-unencrypted");


   unencrypted_coll = mongoc_client_get_collection (


      unencrypted_client, ENCRYPTED_DB, ENCRYPTED_COLL);


   printf ("encrypted document: ");


   if (!print_one_document (unencrypted_coll, &error)) {


      goto fail;


   }


   printf ("\n");


   exit_status = EXIT_SUCCESS;
fail:


   if (error.code) {


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


   }


   bson_free (local_masterkey);


   bson_destroy (kms_providers);


   mongoc_collection_destroy (keyvault_coll);


   bson_destroy (index_keys);


   bson_free (index_name);


   bson_destroy (create_index_cmd);


   bson_json_reader_destroy (reader);


   mongoc_auto_encryption_opts_destroy (auto_encryption_opts);


   mongoc_collection_destroy (coll);


   mongoc_client_destroy (client);


   bson_destroy (to_insert);


   mongoc_collection_destroy (unencrypted_coll);


   mongoc_client_destroy (unencrypted_client);


   mongoc_client_destroy (keyvault_client);


   bson_destroy (&schema);


   bson_destroy (schema_map);


   mongoc_cleanup ();


   return exit_status;
}

#include <mongoc/mongoc.h>
#include <stdio.h>
#include <stdlib.h>
#include "client-side-encryption-helpers.h"
/* Helper method to create and return a JSON schema to use for encryption.
The caller will use the returned schema for server-side encryption validation.
*/
static bson_t *
create_schema (bson_t *kms_providers,


               const char *keyvault_db,


               const char *keyvault_coll,


               mongoc_client_t *keyvault_client,


               bson_error_t *error)
{


   mongoc_client_encryption_t *client_encryption = NULL;


   mongoc_client_encryption_opts_t *client_encryption_opts = NULL;


   mongoc_client_encryption_datakey_opts_t *datakey_opts = NULL;


   bson_value_t datakey_id = {0};


   char *keyaltnames[] = {"mongoc_encryption_example_2"};


   bson_t *schema = NULL;


   client_encryption_opts = mongoc_client_encryption_opts_new ();


   mongoc_client_encryption_opts_set_kms_providers (client_encryption_opts,


                                                    kms_providers);


   mongoc_client_encryption_opts_set_keyvault_namespace (


      client_encryption_opts, keyvault_db, keyvault_coll);


   mongoc_client_encryption_opts_set_keyvault_client (client_encryption_opts,


                                                      keyvault_client);


   client_encryption =


      mongoc_client_encryption_new (client_encryption_opts, error);


   if (!client_encryption) {


      goto fail;


   }


   /* Create a new data key and json schema for the encryptedField.


    * https://dochub.mongodb.org/core/client-side-field-level-encryption-automatic-encryption-rules


    */


   datakey_opts = mongoc_client_encryption_datakey_opts_new ();


   mongoc_client_encryption_datakey_opts_set_keyaltnames (


      datakey_opts, keyaltnames, 1);


   if (!mongoc_client_encryption_create_datakey (


          client_encryption, "local", datakey_opts, &datakey_id, error)) {


      goto fail;


   }


   /* Create a schema describing that "encryptedField" is a string encrypted


    * with the newly created data key using deterministic encryption. */


   schema = BCON_NEW ("properties",


                      "{",


                      "encryptedField",


                      "{",


                      "encrypt",


                      "{",


                      "keyId",


                      "[",


                      BCON_BIN (datakey_id.value.v_binary.subtype,


                                datakey_id.value.v_binary.data,


                                datakey_id.value.v_binary.data_len),


                      "]",


                      "bsonType",


                      "string",


                      "algorithm",


                      MONGOC_AEAD_AES_256_CBC_HMAC_SHA_512_DETERMINISTIC,


                      "}",


                      "}",


                      "}",


                      "bsonType",


                      "object");
fail:


   mongoc_client_encryption_destroy (client_encryption);


   mongoc_client_encryption_datakey_opts_destroy (datakey_opts);


   mongoc_client_encryption_opts_destroy (client_encryption_opts);


   bson_value_destroy (&datakey_id);


   return schema;
}
/* This example demonstrates how to use automatic encryption with a server-side


 * schema using the enterprise version of MongoDB */
int
main (void)
{
/* The collection used to store the encryption data keys. */
#define KEYVAULT_DB "encryption"
#define KEYVAULT_COLL "__libmongocTestKeyVault"
/* The collection used to store the encrypted documents in this example. */
#define ENCRYPTED_DB "test"
#define ENCRYPTED_COLL "coll"


   int exit_status = EXIT_FAILURE;


   bool ret;


   uint8_t *local_masterkey = NULL;


   uint32_t local_masterkey_len;


   bson_t *kms_providers = NULL;


   bson_error_t error = {0};


   bson_t *index_keys = NULL;


   char *index_name = NULL;


   bson_t *create_index_cmd = NULL;


   bson_json_reader_t *reader = NULL;


   bson_t *schema = NULL;


   /* The MongoClient used to access the key vault (keyvault_namespace). */


   mongoc_client_t *keyvault_client = NULL;


   mongoc_collection_t *keyvault_coll = NULL;


   mongoc_auto_encryption_opts_t *auto_encryption_opts = NULL;


   mongoc_client_t *client = NULL;


   mongoc_collection_t *coll = NULL;


   bson_t *to_insert = NULL;


   mongoc_client_t *unencrypted_client = NULL;


   mongoc_collection_t *unencrypted_coll = NULL;


   bson_t *create_cmd = NULL;


   bson_t *create_cmd_opts = NULL;


   mongoc_write_concern_t *wc = NULL;


   mongoc_init ();


   /* Configure the master key. This must be the same master key that was used


    * to create


    * the encryption key. */


   local_masterkey =


      hex_to_bin (getenv ("LOCAL_MASTERKEY"), &local_masterkey_len);


   if (!local_masterkey || local_masterkey_len != 96) {


      fprintf (stderr,


               "Specify LOCAL_MASTERKEY environment variable as a "


               "secure random 96 byte hex value.\n");


      goto fail;


   }


   kms_providers = BCON_NEW ("local",


                             "{",


                             "key",


                             BCON_BIN (0, local_masterkey, local_masterkey_len),


                             "}");


   /* Set up the key vault for this example. */


   keyvault_client = mongoc_client_new (


      "mongodb://localhost/?appname=client-side-encryption-keyvault");


   keyvault_coll = mongoc_client_get_collection (


      keyvault_client, KEYVAULT_DB, KEYVAULT_COLL);


   mongoc_collection_drop (keyvault_coll, NULL);


   /* Create a unique index to ensure that two data keys cannot share the same


    * keyAltName. This is recommended practice for the key vault. */


   index_keys = BCON_NEW ("keyAltNames", BCON_INT32 (1));


   index_name = mongoc_collection_keys_to_index_string (index_keys);


   create_index_cmd = BCON_NEW ("createIndexes",


                                KEYVAULT_COLL,


                                "indexes",


                                "[",


                                "{",


                                "key",


                                BCON_DOCUMENT (index_keys),


                                "name",


                                index_name,


                                "unique",


                                BCON_BOOL (true),


                                "partialFilterExpression",


                                "{",


                                "keyAltNames",


                                "{",


                                "$exists",


                                BCON_BOOL (true),


                                "}",


                                "}",


                                "}",


                                "]");


   ret = mongoc_client_command_simple (keyvault_client,


                                       KEYVAULT_DB,


                                       create_index_cmd,


                                       NULL /* read prefs */,


                                       NULL /* reply */,


                                       &error);


   if (!ret) {


      goto fail;


   }


   auto_encryption_opts = mongoc_auto_encryption_opts_new ();


   mongoc_auto_encryption_opts_set_keyvault_client (auto_encryption_opts,


                                                    keyvault_client);


   mongoc_auto_encryption_opts_set_keyvault_namespace (


      auto_encryption_opts, KEYVAULT_DB, KEYVAULT_COLL);


   mongoc_auto_encryption_opts_set_kms_providers (auto_encryption_opts,


                                                  kms_providers);


   schema = create_schema (


      kms_providers, KEYVAULT_DB, KEYVAULT_COLL, keyvault_client, &error);


   if (!schema) {


      goto fail;


   }


   client =


      mongoc_client_new ("mongodb://localhost/?appname=client-side-encryption");


   ret = mongoc_client_enable_auto_encryption (


      client, auto_encryption_opts, &error);


   if (!ret) {


      goto fail;


   }


   coll = mongoc_client_get_collection (client, ENCRYPTED_DB, ENCRYPTED_COLL);


   /* Clear old data */


   mongoc_collection_drop (coll, NULL);


   /* Create the collection with the encryption JSON Schema. */


   create_cmd = BCON_NEW ("create",


                          ENCRYPTED_COLL,


                          "validator",


                          "{",


                          "$jsonSchema",


                          BCON_DOCUMENT (schema),


                          "}");


   wc = mongoc_write_concern_new ();


   mongoc_write_concern_set_wmajority (wc, 0);


   create_cmd_opts = bson_new ();


   mongoc_write_concern_append (wc, create_cmd_opts);


   ret = mongoc_client_command_with_opts (client,


                                          ENCRYPTED_DB,


                                          create_cmd,


                                          NULL /* read prefs */,


                                          create_cmd_opts,


                                          NULL /* reply */,


                                          &error);


   if (!ret) {


      goto fail;


   }


   to_insert = BCON_NEW ("encryptedField", "123456789");


   ret = mongoc_collection_insert_one (


      coll, to_insert, NULL /* opts */, NULL /* reply */, &error);


   if (!ret) {


      goto fail;


   }


   printf ("decrypted document: ");


   if (!print_one_document (coll, &error)) {


      goto fail;


   }


   printf ("\n");


   unencrypted_client = mongoc_client_new (


      "mongodb://localhost/?appname=client-side-encryption-unencrypted");


   unencrypted_coll = mongoc_client_get_collection (


      unencrypted_client, ENCRYPTED_DB, ENCRYPTED_COLL);


   printf ("encrypted document: ");


   if (!print_one_document (unencrypted_coll, &error)) {


      goto fail;


   }


   printf ("\n");


   /* Expect a server-side error if inserting with the unencrypted collection.


    */


   ret = mongoc_collection_insert_one (


      unencrypted_coll, to_insert, NULL /* opts */, NULL /* reply */, &error);


   if (!ret) {


      printf ("insert with unencrypted collection failed: %s\n", error.message);


      memset (&error, 0, sizeof (error));


   }


   exit_status = EXIT_SUCCESS;
fail:


   if (error.code) {


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


   }


   bson_free (local_masterkey);


   bson_destroy (kms_providers);


   mongoc_collection_destroy (keyvault_coll);


   bson_destroy (index_keys);


   bson_free (index_name);


   bson_destroy (create_index_cmd);


   bson_json_reader_destroy (reader);


   mongoc_auto_encryption_opts_destroy (auto_encryption_opts);


   mongoc_collection_destroy (coll);


   mongoc_client_destroy (client);


   bson_destroy (to_insert);


   mongoc_collection_destroy (unencrypted_coll);


   mongoc_client_destroy (unencrypted_client);


   mongoc_client_destroy (keyvault_client);


   bson_destroy (schema);


   bson_destroy (create_cmd);


   bson_destroy (create_cmd_opts);


   mongoc_write_concern_destroy (wc);


   mongoc_cleanup ();


   return exit_status;
}

#include <mongoc/mongoc.h>
#include <stdio.h>
#include <stdlib.h>
#include "client-side-encryption-helpers.h"
/* This example demonstrates how to use explicit encryption and decryption using


 * the community version of MongoDB */
int
main (void)
{
/* The collection used to store the encryption data keys. */
#define KEYVAULT_DB "encryption"
#define KEYVAULT_COLL "__libmongocTestKeyVault"
/* The collection used to store the encrypted documents in this example. */
#define ENCRYPTED_DB "test"
#define ENCRYPTED_COLL "coll"


   int exit_status = EXIT_FAILURE;


   bool ret;


   uint8_t *local_masterkey = NULL;


   uint32_t local_masterkey_len;


   bson_t *kms_providers = NULL;


   bson_error_t error = {0};


   bson_t *index_keys = NULL;


   char *index_name = NULL;


   bson_t *create_index_cmd = NULL;


   bson_t *schema = NULL;


   mongoc_client_t *client = NULL;


   mongoc_collection_t *coll = NULL;


   mongoc_collection_t *keyvault_coll = NULL;


   bson_t *to_insert = NULL;


   bson_t *create_cmd = NULL;


   bson_t *create_cmd_opts = NULL;


   mongoc_write_concern_t *wc = NULL;


   mongoc_client_encryption_t *client_encryption = NULL;


   mongoc_client_encryption_opts_t *client_encryption_opts = NULL;


   mongoc_client_encryption_datakey_opts_t *datakey_opts = NULL;


   char *keyaltnames[] = {"mongoc_encryption_example_3"};


   bson_value_t datakey_id = {0};


   bson_value_t encrypted_field = {0};


   bson_value_t to_encrypt = {0};


   mongoc_client_encryption_encrypt_opts_t *encrypt_opts = NULL;


   bson_value_t decrypted = {0};


   mongoc_init ();


   /* Configure the master key. This must be the same master key that was used


    * to create the encryption key. */


   local_masterkey =


      hex_to_bin (getenv ("LOCAL_MASTERKEY"), &local_masterkey_len);


   if (!local_masterkey || local_masterkey_len != 96) {


      fprintf (stderr,


               "Specify LOCAL_MASTERKEY environment variable as a "


               "secure random 96 byte hex value.\n");


      goto fail;


   }


   kms_providers = BCON_NEW ("local",


                             "{",


                             "key",


                             BCON_BIN (0, local_masterkey, local_masterkey_len),


                             "}");


   /* The mongoc_client_t used to read/write application data. */


   client =


      mongoc_client_new ("mongodb://localhost/?appname=client-side-encryption");


   coll = mongoc_client_get_collection (client, ENCRYPTED_DB, ENCRYPTED_COLL);


   /* Clear old data */


   mongoc_collection_drop (coll, NULL);


   /* Set up the key vault for this example. */


   keyvault_coll =


      mongoc_client_get_collection (client, KEYVAULT_DB, KEYVAULT_COLL);


   mongoc_collection_drop (keyvault_coll, NULL);


   /* Create a unique index to ensure that two data keys cannot share the same


    * keyAltName. This is recommended practice for the key vault. */


   index_keys = BCON_NEW ("keyAltNames", BCON_INT32 (1));


   index_name = mongoc_collection_keys_to_index_string (index_keys);


   create_index_cmd = BCON_NEW ("createIndexes",


                                KEYVAULT_COLL,


                                "indexes",


                                "[",


                                "{",


                                "key",


                                BCON_DOCUMENT (index_keys),


                                "name",


                                index_name,


                                "unique",


                                BCON_BOOL (true),


                                "partialFilterExpression",


                                "{",


                                "keyAltNames",


                                "{",


                                "$exists",


                                BCON_BOOL (true),


                                "}",


                                "}",


                                "}",


                                "]");


   ret = mongoc_client_command_simple (client,


                                       KEYVAULT_DB,


                                       create_index_cmd,


                                       NULL /* read prefs */,


                                       NULL /* reply */,


                                       &error);


   if (!ret) {


      goto fail;


   }


   client_encryption_opts = mongoc_client_encryption_opts_new ();


   mongoc_client_encryption_opts_set_kms_providers (client_encryption_opts,


                                                    kms_providers);


   mongoc_client_encryption_opts_set_keyvault_namespace (


      client_encryption_opts, KEYVAULT_DB, KEYVAULT_COLL);


   /* Set a mongoc_client_t to use for reading/writing to the key vault. This


    * can be the same mongoc_client_t used by the main application. */


   mongoc_client_encryption_opts_set_keyvault_client (client_encryption_opts,


                                                      client);


   client_encryption =


      mongoc_client_encryption_new (client_encryption_opts, &error);


   if (!client_encryption) {


      goto fail;


   }


   /* Create a new data key for the encryptedField.


    * https://dochub.mongodb.org/core/client-side-field-level-encryption-automatic-encryption-rules


    */


   datakey_opts = mongoc_client_encryption_datakey_opts_new ();


   mongoc_client_encryption_datakey_opts_set_keyaltnames (


      datakey_opts, keyaltnames, 1);


   if (!mongoc_client_encryption_create_datakey (


          client_encryption, "local", datakey_opts, &datakey_id, &error)) {


      goto fail;


   }


   /* Explicitly encrypt a field */


   encrypt_opts = mongoc_client_encryption_encrypt_opts_new ();


   mongoc_client_encryption_encrypt_opts_set_algorithm (


      encrypt_opts, MONGOC_AEAD_AES_256_CBC_HMAC_SHA_512_DETERMINISTIC);


   mongoc_client_encryption_encrypt_opts_set_keyid (encrypt_opts, &datakey_id);


   to_encrypt.value_type = BSON_TYPE_UTF8;


   to_encrypt.value.v_utf8.str = "123456789";


   to_encrypt.value.v_utf8.len = strlen (to_encrypt.value.v_utf8.str);


   ret = mongoc_client_encryption_encrypt (


      client_encryption, &to_encrypt, encrypt_opts, &encrypted_field, &error);


   if (!ret) {


      goto fail;


   }


   to_insert = bson_new ();


   BSON_APPEND_VALUE (to_insert, "encryptedField", &encrypted_field);


   ret = mongoc_collection_insert_one (


      coll, to_insert, NULL /* opts */, NULL /* reply */, &error);


   if (!ret) {


      goto fail;


   }


   printf ("encrypted document: ");


   if (!print_one_document (coll, &error)) {


      goto fail;


   }


   printf ("\n");


   /* Explicitly decrypt a field */


   ret = mongoc_client_encryption_decrypt (


      client_encryption, &encrypted_field, &decrypted, &error);


   if (!ret) {


      goto fail;


   }


   printf ("decrypted value: %s\n", decrypted.value.v_utf8.str);


   exit_status = EXIT_SUCCESS;
fail:


   if (error.code) {


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


   }


   bson_free (local_masterkey);


   bson_destroy (kms_providers);


   mongoc_collection_destroy (keyvault_coll);


   bson_destroy (index_keys);


   bson_free (index_name);


   bson_destroy (create_index_cmd);


   mongoc_collection_destroy (coll);


   mongoc_client_destroy (client);


   bson_destroy (to_insert);


   bson_destroy (schema);


   bson_destroy (create_cmd);


   bson_destroy (create_cmd_opts);


   mongoc_write_concern_destroy (wc);


   mongoc_client_encryption_destroy (client_encryption);


   mongoc_client_encryption_datakey_opts_destroy (datakey_opts);


   mongoc_client_encryption_opts_destroy (client_encryption_opts);


   bson_value_destroy (&encrypted_field);


   mongoc_client_encryption_encrypt_opts_destroy (encrypt_opts);


   bson_value_destroy (&decrypted);


   bson_value_destroy (&datakey_id);


   mongoc_cleanup ();


   return exit_status;
}

#include <mongoc/mongoc.h>
#include <stdio.h>
#include <stdlib.h>
#include "client-side-encryption-helpers.h"
/* This example demonstrates how to set up automatic decryption without


 * automatic encryption using the community version of MongoDB */
int
main (void)
{
/* The collection used to store the encryption data keys. */
#define KEYVAULT_DB "encryption"
#define KEYVAULT_COLL "__libmongocTestKeyVault"
/* The collection used to store the encrypted documents in this example. */
#define ENCRYPTED_DB "test"
#define ENCRYPTED_COLL "coll"


   int exit_status = EXIT_FAILURE;


   bool ret;


   uint8_t *local_masterkey = NULL;


   uint32_t local_masterkey_len;


   bson_t *kms_providers = NULL;


   bson_error_t error = {0};


   bson_t *index_keys = NULL;


   char *index_name = NULL;


   bson_t *create_index_cmd = NULL;


   bson_t *schema = NULL;


   mongoc_client_t *client = NULL;


   mongoc_collection_t *coll = NULL;


   mongoc_collection_t *keyvault_coll = NULL;


   bson_t *to_insert = NULL;


   bson_t *create_cmd = NULL;


   bson_t *create_cmd_opts = NULL;


   mongoc_write_concern_t *wc = NULL;


   mongoc_client_encryption_t *client_encryption = NULL;


   mongoc_client_encryption_opts_t *client_encryption_opts = NULL;


   mongoc_client_encryption_datakey_opts_t *datakey_opts = NULL;


   char *keyaltnames[] = {"mongoc_encryption_example_4"};


   bson_value_t datakey_id = {0};


   bson_value_t encrypted_field = {0};


   bson_value_t to_encrypt = {0};


   mongoc_client_encryption_encrypt_opts_t *encrypt_opts = NULL;


   bson_value_t decrypted = {0};


   mongoc_auto_encryption_opts_t *auto_encryption_opts = NULL;


   mongoc_client_t *unencrypted_client = NULL;


   mongoc_collection_t *unencrypted_coll = NULL;


   mongoc_init ();


   /* Configure the master key. This must be the same master key that was used


    * to create the encryption key. */


   local_masterkey =


      hex_to_bin (getenv ("LOCAL_MASTERKEY"), &local_masterkey_len);


   if (!local_masterkey || local_masterkey_len != 96) {


      fprintf (stderr,


               "Specify LOCAL_MASTERKEY environment variable as a "


               "secure random 96 byte hex value.\n");


      goto fail;


   }


   kms_providers = BCON_NEW ("local",


                             "{",


                             "key",


                             BCON_BIN (0, local_masterkey, local_masterkey_len),


                             "}");


   client =


      mongoc_client_new ("mongodb://localhost/?appname=client-side-encryption");


   auto_encryption_opts = mongoc_auto_encryption_opts_new ();


   mongoc_auto_encryption_opts_set_keyvault_namespace (


      auto_encryption_opts, KEYVAULT_DB, KEYVAULT_COLL);


   mongoc_auto_encryption_opts_set_kms_providers (auto_encryption_opts,


                                                  kms_providers);


   /* Setting bypass_auto_encryption to true disables automatic encryption but


    * keeps the automatic decryption behavior. bypass_auto_encryption will also


    * disable spawning mongocryptd */


   mongoc_auto_encryption_opts_set_bypass_auto_encryption (auto_encryption_opts,


                                                           true);


   /* Once bypass_auto_encryption is set, community users can enable auto


    * encryption on the client. This will, in fact, only perform automatic


    * decryption. */


   ret = mongoc_client_enable_auto_encryption (


      client, auto_encryption_opts, &error);


   if (!ret) {


      goto fail;


   }


   /* Now that automatic decryption is on, we can test it by inserting a


    * document with an explicitly encrypted value into the collection. When we


    * look up the document later, it should be automatically decrypted for us.


    */


   coll = mongoc_client_get_collection (client, ENCRYPTED_DB, ENCRYPTED_COLL);


   /* Clear old data */


   mongoc_collection_drop (coll, NULL);


   /* Set up the key vault for this example. */


   keyvault_coll =


      mongoc_client_get_collection (client, KEYVAULT_DB, KEYVAULT_COLL);


   mongoc_collection_drop (keyvault_coll, NULL);


   /* Create a unique index to ensure that two data keys cannot share the same


    * keyAltName. This is recommended practice for the key vault. */


   index_keys = BCON_NEW ("keyAltNames", BCON_INT32 (1));


   index_name = mongoc_collection_keys_to_index_string (index_keys);


   create_index_cmd = BCON_NEW ("createIndexes",


                                KEYVAULT_COLL,


                                "indexes",


                                "[",


                                "{",


                                "key",


                                BCON_DOCUMENT (index_keys),


                                "name",


                                index_name,


                                "unique",


                                BCON_BOOL (true),


                                "partialFilterExpression",


                                "{",


                                "keyAltNames",


                                "{",


                                "$exists",


                                BCON_BOOL (true),


                                "}",


                                "}",


                                "}",


                                "]");


   ret = mongoc_client_command_simple (client,


                                       KEYVAULT_DB,


                                       create_index_cmd,


                                       NULL /* read prefs */,


                                       NULL /* reply */,


                                       &error);


   if (!ret) {


      goto fail;


   }


   client_encryption_opts = mongoc_client_encryption_opts_new ();


   mongoc_client_encryption_opts_set_kms_providers (client_encryption_opts,


                                                    kms_providers);


   mongoc_client_encryption_opts_set_keyvault_namespace (


      client_encryption_opts, KEYVAULT_DB, KEYVAULT_COLL);


   /* The key vault client is used for reading to/from the key vault. This can


    * be the same mongoc_client_t used by the application. */


   mongoc_client_encryption_opts_set_keyvault_client (client_encryption_opts,


                                                      client);


   client_encryption =


      mongoc_client_encryption_new (client_encryption_opts, &error);


   if (!client_encryption) {


      goto fail;


   }


   /* Create a new data key for the encryptedField.


    * https://dochub.mongodb.org/core/client-side-field-level-encryption-automatic-encryption-rules


    */


   datakey_opts = mongoc_client_encryption_datakey_opts_new ();


   mongoc_client_encryption_datakey_opts_set_keyaltnames (


      datakey_opts, keyaltnames, 1);


   ret = mongoc_client_encryption_create_datakey (


      client_encryption, "local", datakey_opts, &datakey_id, &error);


   if (!ret) {


      goto fail;


   }


   /* Explicitly encrypt a field. */


   encrypt_opts = mongoc_client_encryption_encrypt_opts_new ();


   mongoc_client_encryption_encrypt_opts_set_algorithm (


      encrypt_opts, MONGOC_AEAD_AES_256_CBC_HMAC_SHA_512_DETERMINISTIC);


   mongoc_client_encryption_encrypt_opts_set_keyaltname (


      encrypt_opts, "mongoc_encryption_example_4");


   to_encrypt.value_type = BSON_TYPE_UTF8;


   to_encrypt.value.v_utf8.str = "123456789";


   to_encrypt.value.v_utf8.len = strlen (to_encrypt.value.v_utf8.str);


   ret = mongoc_client_encryption_encrypt (


      client_encryption, &to_encrypt, encrypt_opts, &encrypted_field, &error);


   if (!ret) {


      goto fail;


   }


   to_insert = bson_new ();


   BSON_APPEND_VALUE (to_insert, "encryptedField", &encrypted_field);


   ret = mongoc_collection_insert_one (


      coll, to_insert, NULL /* opts */, NULL /* reply */, &error);


   if (!ret) {


      goto fail;


   }


   /* When we retrieve the document, any encrypted fields will get automatically


    * decrypted by the driver. */


   printf ("decrypted document: ");


   if (!print_one_document (coll, &error)) {


      goto fail;


   }


   printf ("\n");


   unencrypted_client =


      mongoc_client_new ("mongodb://localhost/?appname=client-side-encryption");


   unencrypted_coll = mongoc_client_get_collection (


      unencrypted_client, ENCRYPTED_DB, ENCRYPTED_COLL);


   printf ("encrypted document: ");


   if (!print_one_document (unencrypted_coll, &error)) {


      goto fail;


   }


   printf ("\n");


   exit_status = EXIT_SUCCESS;
fail:


   if (error.code) {


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


   }


   bson_free (local_masterkey);


   bson_destroy (kms_providers);


   mongoc_collection_destroy (keyvault_coll);


   bson_destroy (index_keys);


   bson_free (index_name);


   bson_destroy (create_index_cmd);


   mongoc_collection_destroy (coll);


   mongoc_client_destroy (client);


   bson_destroy (to_insert);


   bson_destroy (schema);


   bson_destroy (create_cmd);


   bson_destroy (create_cmd_opts);


   mongoc_write_concern_destroy (wc);


   mongoc_client_encryption_destroy (client_encryption);


   mongoc_client_encryption_datakey_opts_destroy (datakey_opts);


   mongoc_client_encryption_opts_destroy (client_encryption_opts);


   bson_value_destroy (&encrypted_field);


   mongoc_client_encryption_encrypt_opts_destroy (encrypt_opts);


   bson_value_destroy (&decrypted);


   bson_value_destroy (&datakey_id);


   mongoc_collection_destroy (unencrypted_coll);


   mongoc_client_destroy (unencrypted_client);


   mongoc_auto_encryption_opts_destroy (auto_encryption_opts);


   mongoc_cleanup ();


   return exit_status;
}

cmake -DENABLE_AUTOMATIC_INIT_AND_CLEANUP=OFF

typedef enum {


   MONGOC_LOG_LEVEL_ERROR,


   MONGOC_LOG_LEVEL_CRITICAL,


   MONGOC_LOG_LEVEL_WARNING,


   MONGOC_LOG_LEVEL_MESSAGE,


   MONGOC_LOG_LEVEL_INFO,


   MONGOC_LOG_LEVEL_DEBUG,


   MONGOC_LOG_LEVEL_TRACE,
} mongoc_log_level_t;
#define MONGOC_ERROR(...)
#define MONGOC_CRITICAL(...)
#define MONGOC_WARNING(...)
#define MONGOC_MESSAGE(...)
#define MONGOC_INFO(...)
#define MONGOC_DEBUG(...)
typedef void (*mongoc_log_func_t) (mongoc_log_level_t log_level,


                                   const char *log_domain,


                                   const char *message,


                                   void *user_data);
void
mongoc_log_set_handler (mongoc_log_func_t log_func, void *user_data);
void
mongoc_log (mongoc_log_level_t log_level,


            const char *log_domain,


            const char *format,


            ...) BSON_GNUC_PRINTF (3, 4);
const char *
mongoc_log_level_str (mongoc_log_level_t log_level);
void
mongoc_log_default_handler (mongoc_log_level_t log_level,


                            const char *log_domain,


                            const char *message,


                            void *user_data);
void
mongoc_log_trace_enable (void);
void
mongoc_log_trace_disable (void);

#undef MONGOC_LOG_DOMAIN
#define MONGOC_LOG_DOMAIN "my-custom-domain"
MONGOC_WARNING ("An error occurred: %s", strerror (errno));

void
my_logger (mongoc_log_level_t log_level,


           const char *log_domain,


           const char *message,


           void *user_data)
{


   /* smaller values are more important */


   if (log_level < MONGOC_LOG_LEVEL_INFO) {


      mongoc_log_default_handler (log_level, log_domain, message, user_data);


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


   mongoc_log_set_handler (my_logger, NULL);


   mongoc_init ();


   /* ... your code ...  */


   mongoc_cleanup ();


   return 0;
}

mongoc_log_set_handler (mongoc_log_default_handler, NULL);

mongoc_log_set_handler (NULL, NULL);

Compiling the driver with -DENABLE_TRACING=ON will affect its performance. Disabling tracing with mongoc_log_trace_disable() significantly reduces the overhead, but cannot remove it completely.

Handling Errors in libbson.

{ "errorLabels": [ "TransientTransactionError" ] }

MongoDB Server Error Codes

typedef struct _mongoc_auto_encryption_opts_t mongoc_auto_encryption_opts_t;

The guide for Using Client-Side Field Level Encryption

typedef struct _mongoc_bulk_operation_t mongoc_bulk_operation_t;

It is only valid to call mongoc_bulk_operation_execute() once. The mongoc_bulk_operation_t must be destroyed afterwards.

Bulk Write Operations

#include <mongoc/mongoc.h>
typedef struct _mongoc_change_stream_t mongoc_change_stream_t;

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

typedef struct _mongoc_client_encryption_t mongoc_client_encryption_t;

mongoc_client_enable_auto_encryption()

mongoc_client_pool_enable_auto_encryption()

The guide for Using Client-Side Field Level Encryption for libmongoc

The MongoDB Manual for Client-Side Field Level Encryption

typedef struct _mongoc_client_encryption_datakey_opts_t mongoc_client_encryption_datakey_opts_t;

mongoc_client_encryption_create_datakey()

typedef struct _mongoc_client_encryption_rewrap_many_datakey_result_t


   mongoc_client_encryption_rewrap_many_datakey_result_t;

mongoc_client_encryption_rewrap_many_datakey()

typedef struct _mongoc_client_encryption_encrypt_opts_t mongoc_client_encryption_encrypt_opts_t;

mongoc_client_encryption_encrypt()

typedef struct _mongoc_client_encryption_opts_t mongoc_client_encryption_opts_t;

mongoc_client_encryption_new()

typedef struct _mongoc_client_pool_t mongoc_client_pool_t

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

typedef bool (*mongoc_client_session_with_transaction_cb_t) (


   mongoc_client_session_t *session,


   void *ctx,


   bson_t **reply,


   bson_error_t *error);

mongoc_client_session_with_transaction()

typedef struct _mongoc_client_t mongoc_client_t;
typedef mongoc_stream_t *(*mongoc_stream_initiator_t) (


   const mongoc_uri_t *uri,


   const mongoc_host_list_t *host,


   void *user_data,


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


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

typedef struct _mongoc_collection_t mongoc_collection_t;

typedef struct _mongoc_cursor_t mongoc_cursor_t;

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


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

typedef struct _mongoc_database_t mongoc_database_t;

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


   mongoc_database_t *database;


   mongoc_client_t *client;


   mongoc_init ();


   client = mongoc_client_new ("mongodb://localhost/");


   database = mongoc_client_get_database (client, "test");


   mongoc_database_destroy (database);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return 0;
}

typedef enum {


   MONGOC_DELETE_NONE = 0,


   MONGOC_DELETE_SINGLE_REMOVE = 1 << 0,
} mongoc_delete_flags_t;

These flags are deprecated and should not be used in new code.

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

{


    "lastErrorObject": {


        "updatedExisting": false,


        "n": 1,


        "upserted": {


            "$oid": "56562a99d13e6d86239c7b00"


        }


    },


    "value": {


        "_id": {


            "$oid": "56562a99d13e6d86239c7b00"


        },


        "age": 34,


        "firstname": "Zlatan",


        "goals": 342,


        "lastname": "Ibrahimovic",


        "profession": "Football player",


        "position": "striker"


    },


    "ok": 1
}
{


    "lastErrorObject": {


        "updatedExisting": true,


        "n": 1


    },


    "value": {


        "_id": {


            "$oid": "56562a99d13e6d86239c7b00"


        },


        "age": 34,


        "firstname": "Zlatan",


        "goals": 342,


        "lastname": "Ibrahimovic",


        "profession": "Football player",


        "position": "striker"


    },


    "ok": 1
}
{


    "lastErrorObject": {


        "updatedExisting": true,


        "n": 1


    },


    "value": {


        "_id": {


            "$oid": "56562a99d13e6d86239c7b00"


        },


        "age": 35,


        "firstname": "Zlatan",


        "goals": 342,


        "lastname": "Ibrahimovic",


        "profession": "Football player",


        "position": "striker"


    },


    "ok": 1
}
{


    "lastErrorObject": {


        "updatedExisting": true,


        "n": 1


    },


    "value": {


        "_id": {


            "$oid": "56562a99d13e6d86239c7b00"


        },


        "goals": 343


    },


    "ok": 1
}
{


    "lastErrorObject": {


        "updatedExisting": true,


        "n": 1


    },


    "value": {


        "_id": {


            "$oid": "56562a99d13e6d86239c7b00"


        },


        "age": 35,


        "firstname": "Zlatan",


        "goals": 343,


        "lastname": "Ibrahimovic",


        "profession": "Football player",


        "position": "striker",


        "author": true


    },


    "ok": 1
}

#include <mongoc/mongoc.h>
typedef struct _mongoc_gridfs_file_list_t mongoc_gridfs_file_list_t;

mongoc_gridfs_file_list_t *list;
mongoc_gridfs_file_t *file;
list = mongoc_gridfs_find (gridfs, query);
while ((file = mongoc_gridfs_file_list_next (list))) {


   do_something (file);


   mongoc_gridfs_file_destroy (file);
}
mongoc_gridfs_file_list_destroy (list);

typedef struct {


   const char *md5;


   const char *filename;


   const char *content_type;


   const bson_t *aliases;


   const bson_t *metadata;


   uint32_t chunk_size;
} mongoc_gridfs_file_opt_t;

typedef struct _mongoc_gridfs_file_t mongoc_gridfs_file_t;

#include <mongoc/mongoc.h>
typedef struct _mongoc_gridfs_bucket_t mongoc_gridfs_bucket_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.

This GridFS implementation does not conform to the MongoDB GridFS specification. For a spec compliant implementation, use mongoc_gridfs_bucket_t.

#include <mongoc/mongoc.h>
typedef struct _mongoc_gridfs_t mongoc_gridfs_t;

mongoc_gridfs_t does not support read preferences. In a replica set, GridFS queries are always routed to the primary.

#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.

typedef struct {


   mongoc_host_list_t *next;


   char host[BSON_HOST_NAME_MAX + 1];


   char host_and_port[BSON_HOST_NAME_MAX + 7];


   uint16_t port;


   int family;


   void *padding[4];
} mongoc_host_list_t;

mongoc_uri_get_hosts() and mongoc_cursor_get_host().

#include <mongoc/mongoc.h>
typedef struct {


   uint8_t twod_sphere_version;


   uint8_t twod_bits_precision;


   double twod_location_min;


   double twod_location_max;


   double haystack_bucket_size;


   uint8_t *padding[32];
} mongoc_index_opt_geo_t;

mongoc_index_opt_t

mongoc_index_opt_wt_t