$ git clone https://github.com/mongodb/mongo-c-driver.git --branch="$VERSION" "$SOURCE"

## Download using wget:
$ wget "https://github.com/mongodb/mongo-c-driver/archive/refs/tags/$VERSION.tar.gz" \


    --output-document="mongo-c-driver-$VERSION.tar.gz"
## Extract using tar:
$ tar xf "mongo-c-driver-$VERSION.tar.gz"

## Using curl:
$ curl "https://github.com/mongodb/mongo-c-driver/archive/refs/tags/$VERSION.tar.gz" \


    --output="mongo-c-driver-$VERSION.tar.gz"
## Extract using tar:
$ tar xf "mongo-c-driver-$VERSION.tar.gz"

## Use Invoke-WebRequest:
PS> $url = "https://github.com/mongodb/mongo-c-driver/archive/refs/tags/$VERSION.zip"
PS> $file = "mongo-c-driver-$VERSION.zip"
PS> Invoke-WebRequest -UseBasicParsing -Uri $url -OutFile $file
## Extract using Expand-Archive:
PS> Expand-Archive mongo-c-driver-$VERSION.zip

$ sh cmake-3.27.0-linux-x86_64.sh --prefix="$HOME/.local" --exclude-subdir --skip-license

$ cmake --version
cmake version 3.21.4
CMake suite maintained and supported by Kitware (kitware.com/cmake).

$ cmake -S $SOURCE -B $BUILD \


  -D ENABLE_EXTRA_ALIGNMENT=OFF \


  -D ENABLE_AUTOMATIC_INIT_AND_CLEANUP=OFF \


  -D CMAKE_BUILD_TYPE=RelWithDebInfo \


  -D BUILD_VERSION="$VERSION" \


  -D ENABLE_MONGOC=OFF

$ cmake …
## … (Lines of output) …
-- Generating done
-- Build files have been written to: $BUILD

$ cmake --build $BUILD --config RelWithDebInfo --parallel

$ cmake --install "$BUILD" --prefix "$PREFIX" --config RelWithDebInfo

$ cmake -D ENABLE_MONGOC=ON $BUILD

For the most up-to-date versions of the C driver libraries, prefer to instead build from source.

{


  // ...


  "dependencies": [


    // ...


    "mongo-c-driver"


  ]
}

$ vcpkg install mongo-c-driver

find_package(mongoc-1.0 CONFIG REQUIRED)
target_link_libraries(my-application


    PRIVATE $<IF:$<TARGET_EXISTS:mongo::mongoc_shared>,mongo::mongoc_shared,mongo::mongoc_static>)

$ cmake -S . -B _build -D CMAKE_TOOLCHAIN_FILE=$VCPKG_ROOT/scripts/buildsystems/vcpkg.cmake

The C driver libraries are only available in version 7 and newer of the respective enterprise Linux distributions. However, the C driver libraries are not available in the default repositories, but can be obtained by enabling the EPEL repositories. This can be done by installing the epel-release package:

# yum install epel-release

epel-release must be installed before attempting to install the C driver libraries (i.e. one cannot install them both in a single yum install command).

# yum install libbson-devel

## (This package will transitively install libbson-devel)
# yum install mongo-c-driver-devel

## Update repository information, if necessary:
# apt update

# apt install libbson-dev

# apt install libmongoc-dev

$ brew install mongo-c-driver

$ poetry install --with=docs

$ poetry run sphinx-build -b dirhtml "./src/libmongoc/doc" "./_build/docs/html"

$ poetry run python -m http.server --directory=_build/docs/html

$ pkg-config "pkg-config" --variable="pc_path"

$ cmake --install "$BUILD" --prefix "$PREFIX"

$ mongosh --host localhost --port 27017 --quiet
Enterprise rs0 [direct: primary] test> db.version()
7.0.0
>

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


   bson_t *document;


   bson_t child;


   bson_array_builder_t *bab;


   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_BUILDER_BEGIN (document, "languages", &bab);


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


      bson_array_builder_append_utf8 (bab, lang_names[i], -1);


   }


   bson_append_array_builder_end (document, bab);


   /*


    * Array of subdocuments:


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


    */


   BSON_APPEND_ARRAY_BUILDER_BEGIN (document, "degrees", &bab);


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


      bson_array_builder_append_document_begin (bab, &child);


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


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


      bson_array_builder_append_document_end (bab, &child);


   }


   bson_append_array_builder_end (document, bab);


   /*


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


   bson_error_t error;


   bson_t *command;


   bson_t reply;


   char *str;


   mongoc_init ();


   client = mongoc_client_new (


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


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


   if (mongoc_client_command_simple (


          client, "mydb", 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_client_destroy (client);


   mongoc_cleanup ();


   return 0;
}

$ gcc -o executing executing.c $(pkg-config --cflags --libs libmongoc-1.0)
$ ./executing
{ "ok" : { "$numberDouble" : "1.0" }, "$clusterTime" : { "clusterTime" : { "$timestamp" : { "t" : 1682609211, "i" : 1 } }, "signature" : { "hash" : { "$binary" : { "base64" : "AAAAAAAAAAAAAAAAAAAAAAAAAAA=", "subType" : "00" } }, "keyId" : { "$numberLong" : "0" } } }, "operationTime" : { "$timestamp" : { "t" : 1682609211, "i" : 1 } } }

C:\> cl.exe /IC:\mongo-c-driver\include\libbson-1.0 /IC:\mongo-c-driver\include\libmongoc-1.0 executing.c
C:\> executing
{ "ok" : { "$numberDouble" : "1.0" }, "$clusterTime" : { "clusterTime" : { "$timestamp" : { "t" : 1682609211, "i" : 1 } }, "signature" : { "hash" : { "$binary" : { "base64" : "AAAAAAAAAAAAAAAAAAAAAAAAAAA=", "subType" : "00" } }, "keyId" : { "$numberLong" : "0" } } }, "operationTime" : { "$timestamp" : { "t" : 1682609211, "i" : 1 } } }

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

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

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

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

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

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

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

#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 = 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 */
}

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

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

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

// `keys` represents an ascending index on field `x`.
bson_t *keys = BCON_NEW ("x", BCON_INT32 (1));
mongoc_index_model_t *im = mongoc_index_model_new (keys, NULL /* opts */);
if (mongoc_collection_create_indexes_with_opts (


       coll, &im, 1, NULL /* opts */, NULL /* reply */, &error)) {


   printf ("Successfully created index\n");
} else {


   bson_destroy (keys);


   HANDLE_ERROR ("Failed to create index: %s", error.message);
}
bson_destroy (keys);

mongoc_cursor_t *cursor =


   mongoc_collection_find_indexes_with_opts (coll, NULL /* opts */);
printf ("Listing indexes:\n");
const bson_t *got;
while (mongoc_cursor_next (cursor, &got)) {


   char *got_str = bson_as_canonical_extended_json (got, NULL);


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


   bson_free (got_str);
}
if (mongoc_cursor_error (cursor, &error)) {


   mongoc_cursor_destroy (cursor);


   HANDLE_ERROR ("Failed to list indexes: %s", error.message);
}
mongoc_cursor_destroy (cursor);

bson_t *keys = BCON_NEW ("x", BCON_INT32 (1));
char *index_name = mongoc_collection_keys_to_index_string (keys);
if (mongoc_collection_drop_index_with_opts (


       coll, index_name, NULL /* opts */, &error)) {


   printf ("Successfully dropped index\n");
} else {


   bson_free (index_name);


   bson_destroy (keys);


   HANDLE_ERROR ("Failed to drop index: %s", error.message);
}
bson_free (index_name);
bson_destroy (keys);

bson_t cmd;
// Create command.
{


   char *cmd_str = bson_strdup_printf (


      BSON_STR ({


         "createSearchIndexes" : "%s",


         "indexes" : [ {


            "definition" : {"mappings" : {"dynamic" : false}},


            "name" : "test-index"


         } ]


      }),


      collname);


   ASSERT (bson_init_from_json (&cmd, cmd_str, -1, &error));


   bson_free (cmd_str);
}
if (!mongoc_collection_command_simple (


       coll, &cmd, NULL /* read_prefs */, NULL /* reply */, &error)) {


   bson_destroy (&cmd);


   HANDLE_ERROR ("Failed to run createSearchIndexes: %s", error.message);
}
printf ("Created index: \"test-index\"\n");
bson_destroy (&cmd);

const char *pipeline_str =


   BSON_STR ({"pipeline" : [ {"$listSearchIndexes" : {}} ]});
bson_t pipeline;
ASSERT (bson_init_from_json (&pipeline, pipeline_str, -1, &error));
mongoc_cursor_t *cursor =


   mongoc_collection_aggregate (coll,


                                MONGOC_QUERY_NONE,


                                &pipeline,


                                NULL /* opts */,


                                NULL /* read_prefs */);
printf ("Listing indexes:\n");
const bson_t *got;
while (mongoc_cursor_next (cursor, &got)) {


   char *got_str = bson_as_canonical_extended_json (got, NULL);


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


   bson_free (got_str);
}
if (mongoc_cursor_error (cursor, &error)) {


   bson_destroy (&pipeline);


   mongoc_cursor_destroy (cursor);


   HANDLE_ERROR ("Failed to run $listSearchIndexes: %s", error.message);
}
bson_destroy (&pipeline);
mongoc_cursor_destroy (cursor);

bson_t cmd;
// Create command.
{


   char *cmd_str = bson_strdup_printf (


      BSON_STR ({


         "updateSearchIndex" : "%s",


         "definition" : {"mappings" : {"dynamic" : true}},


         "name" : "test-index"


      }),


      collname);


   ASSERT (bson_init_from_json (&cmd, cmd_str, -1, &error));


   bson_free (cmd_str);
}
if (!mongoc_collection_command_simple (


       coll, &cmd, NULL /* read_prefs */, NULL /* reply */, &error)) {


   bson_destroy (&cmd);


   HANDLE_ERROR ("Failed to run updateSearchIndex: %s", error.message);
}
printf ("Updated index: \"test-index\"\n");
bson_destroy (&cmd);

bson_t cmd;
// Create command.
{


   char *cmd_str = bson_strdup_printf (


      BSON_STR ({"dropSearchIndex" : "%s", "name" : "test-index"}),


      collname);


   ASSERT (bson_init_from_json (&cmd, cmd_str, -1, &error));


   bson_free (cmd_str);
}
if (!mongoc_collection_command_simple (


       coll, &cmd, NULL /* read_prefs */, NULL /* reply */, &error)) {


   bson_destroy (&cmd);


   HANDLE_ERROR ("Failed to run dropSearchIndex: %s", error.message);
}
printf ("Dropped index: \"test-index\"\n");
bson_destroy (&cmd);

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) command script import /path/to/mongo-c-driver/lldb_bson.py

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

The MongoDB Manual for Client-Side Field Level 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;


   bson_t *index_opts = NULL;


   mongoc_index_model_t *index_model = 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");


   BSON_ASSERT (keyvault_client);


   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_opts = BCON_NEW ("unique",


                          BCON_BOOL (true),


                          "partialFilterExpression",


                          "{",


                          "keyAltNames",


                          "{",


                          "$exists",


                          BCON_BOOL (true),


                          "}",


                          "}");


   index_model = mongoc_index_model_new (index_keys, index_opts);


   ret = mongoc_collection_create_indexes_with_opts (keyvault_coll,


                                                     &index_model,


                                                     1,


                                                     NULL /* opts */,


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


   BSON_ASSERT (client);


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


   BSON_ASSERT (unencrypted_client);


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


   mongoc_index_model_destroy (index_model);


   bson_destroy (index_opts);


   bson_destroy (index_keys);


   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;


   bson_t *index_opts = NULL;


   mongoc_index_model_t *index_model = 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");


   BSON_ASSERT (keyvault_client);


   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_opts = BCON_NEW ("unique",


                          BCON_BOOL (true),


                          "partialFilterExpression",


                          "{",


                          "keyAltNames",


                          "{",


                          "$exists",


                          BCON_BOOL (true),


                          "}",


                          "}");


   index_model = mongoc_index_model_new (index_keys, index_opts);


   ret = mongoc_collection_create_indexes_with_opts (keyvault_coll,


                                                     &index_model,


                                                     1,


                                                     NULL /* opts */,


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


   BSON_ASSERT (client);


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


   BSON_ASSERT (unencrypted_client);


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


   mongoc_index_model_destroy (index_model);


   bson_destroy (index_opts);


   bson_destroy (index_keys);


   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;


   bson_t *index_opts = NULL;


   mongoc_index_model_t *index_model = 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_opts = BCON_NEW ("unique",


                          BCON_BOOL (true),


                          "partialFilterExpression",


                          "{",


                          "keyAltNames",


                          "{",


                          "$exists",


                          BCON_BOOL (true),


                          "}",


                          "}");


   index_model = mongoc_index_model_new (index_keys, index_opts);


   ret = mongoc_collection_create_indexes_with_opts (keyvault_coll,


                                                     &index_model,


                                                     1,


                                                     NULL /* opts */,


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


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


   BSON_ASSERT (bson_in_range_unsigned (uint32_t, len));


   to_encrypt.value.v_utf8.len = (uint32_t) len;


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


   mongoc_index_model_destroy (index_model);


   bson_destroy (index_opts);


   bson_destroy (index_keys);


   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;


   bson_t *index_opts = NULL;


   mongoc_index_model_t *index_model = 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_opts = BCON_NEW ("unique",


                          BCON_BOOL (true),


                          "partialFilterExpression",


                          "{",


                          "keyAltNames",


                          "{",


                          "$exists",


                          BCON_BOOL (true),


                          "}",


                          "}");


   index_model = mongoc_index_model_new (index_keys, index_opts);


   ret = mongoc_collection_create_indexes_with_opts (keyvault_coll,


                                                     &index_model,


                                                     1,


                                                     NULL /* opts */,


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


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


   BSON_ASSERT (bson_in_range_unsigned (uint32_t, len));


   to_encrypt.value.v_utf8.len = (uint32_t) len;


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


   mongoc_index_model_destroy (index_model);


   bson_destroy (index_opts);


   bson_destroy (index_keys);


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

The MongoDB Manual for Queryable Encryption

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

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

Handling Errors in libbson.

{ "errorLabels": [ "TransientTransactionError" ] }

MongoDB Server Error Codes

typedef struct _mongoc_auto_encryption_opts_t mongoc_auto_encryption_opts_t;

In-Use Encryption

typedef struct _mongoc_bulk_operation_t mongoc_bulk_operation_t;

Bulk Write Operations

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

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


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


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


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

In-Use Encryption for libmongoc

The MongoDB Manual for Client-Side Field Level Encryption

The MongoDB Manual for Queryable 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_encrypt_range_opts_t mongoc_client_encryption_encrypt_range_opts_t;

mongoc_client_encryption_encrypt()
mongoc_client_encryption_encrypt_opts_t

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