static void
log_query (const bson_t *doc,
const bson_t *query)
{
char *str1;
char *str2;
str1 = bson_as_json (doc, NULL);
str2 = bson_as_json (query, NULL);
printf ("Matching %s against %s\n", str2, str1);
bson_free (str1);
bson_free (str2);
}
int mongo_get_documents(mongoc_client_t *client, char *database, char *collection_name, bson_t *query,
query_result **result) {
mongoc_collection_t *collection;
mongoc_cursor_t *cursor;
const bson_t *doc;
char *str;
int index = 0;
collection = mongoc_client_get_collection(client, database, collection_name);
cursor = mongoc_collection_find(collection, MONGOC_QUERY_NONE, 0, 0, 0, query, NULL, NULL);
query_result *current = *result;
while (mongoc_cursor_next(cursor, &doc)) {
str = bson_as_json(doc, NULL);
if (index == 0) {
(*result)->document = malloc(strlen(str) + 1);
strcpy((*result)->document, str);
(*result)->next = NULL;
}
else {
current->next = malloc(sizeof(query_result));
current->next->document = malloc(strlen(str) + 1);
strcpy(current->next->document, str);
current->next->next = NULL;
current = current->next;
}
index++;
bson_free(str);
}
mongoc_cursor_destroy(cursor);
mongoc_collection_destroy(collection);
return 0;
}
int main(void)
{
const uint8_t *json = (uint8_t*)"{ \"message\" : \"Hello World!\" }";
bson_error_t error;
bson_t *doc;
char *str;
size_t len;
if (!(doc = bson_new_from_json(json, -1, &error)))
{
fprintf(stderr, "Cannot initialize BSON structure from JSON example.\n");
fprintf(stderr, "BSON error message: %s\n", error.message);
return 1;
}
printf("Has key \"message\" (expect \"yes\") : %s\n", yesno(bson_has_field(doc, "message")));
printf("Has key \"triceratops\" (expect\"no\") : %s\n", yesno(bson_has_field(doc, "triceratops")));
str = bson_as_json(doc, &len);
printf("Original JSON document : %s\n", json);
printf("BSON-to-JSON conversion : %s\n", str);
bson_free(str);
bson_destroy(doc);
return 0;
}
int
main (int argc,
char *argv[])
{
size_t index;
aggregation_state_t *state = aggregate_start(NULL, NULL);
aggregate_match(state, "{}");
printf("Match:\n");
for(index = 0; index < (*state).docs_len; index++) {
char *str;
str = bson_as_json (&(*state).docs[index], NULL);
printf("%s\n", str);
}
printf("Group:\n");
printf("{\"_id\" : \"$state\", \"data\" : {\"views\" : 0, \"total_population\" : {\"$sum\" : \"$population\"} } }\n");
aggregate_group(state, "{\"_id\" : \"$state\", \"data\" : {\"views\" : 0, \"total_population\" : {\"$sum\" : \"$population\"} } }");
aggregation_result_t *result = aggregate_end(state);
printf("Result:\n");
for(index = 0; index < (*result).docs_len; index++) {
printf("%s\n", (*result).docs[index]);
}
}
static void
test_bson_corrupt_binary (void)
{
uint8_t *buf;
bson_t b;
size_t buflen = 1024;
char *str;
int fd;
ssize_t r;
buf = bson_malloc0(buflen);
fd = bson_open(BINARY_DIR"/test57.bson", O_RDONLY);
BSON_ASSERT(-1 != fd);
r = bson_read(fd, buf, buflen);
BSON_ASSERT(r == 26);
r = bson_init_static(&b, buf, (uint32_t)r);
BSON_ASSERT(r);
str = bson_as_json(&b, NULL);
BSON_ASSERT(!str);
bson_destroy(&b);
bson_free(buf);
}
static void
run_command (void)
{
mongoc_client_t *client;
mongoc_collection_t *collection;
bson_error_t error;
bson_t *command;
bson_t reply;
char *str;
client = mongoc_client_new ("mongodb://*****:*****@192.168.0.112:27017/");
collection = mongoc_client_get_collection (client, "test", "test");
command = BCON_NEW ("collStats", BCON_UTF8 ("test"));
if (mongoc_collection_command_simple (collection, command, NULL, &reply, &error)) {
str = bson_as_json (&reply, NULL);
printf ("%s\n", str);
bson_free (str);
} else {
fprintf (stderr, "Failed to run command: %s\n", error.message);
}
bson_destroy (command);
bson_destroy (&reply);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
}
static PyObject *
cbson_as_json (PyObject *self,
PyObject *args)
{
const bson_uint8_t *buffer;
bson_uint32_t buffer_length;
bson_reader_t reader;
const bson_t *b;
PyObject *ret = NULL;
size_t len = 0;
char *str;
if (!PyArg_ParseTuple(args, "s#", &buffer, &buffer_length)) {
return NULL;
}
bson_reader_init_from_data(&reader, buffer, buffer_length);
b = bson_reader_read(&reader, NULL);
bson_reader_destroy(&reader);
if (b) {
str = bson_as_json(b, &len);
ret = PyUnicode_DecodeUTF8(str, len, "strict");
bson_free(str);
} else {
PyErr_SetString(PyExc_ValueError, "Failed to parse BSON document.");
}
return ret;
}
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:3001/");
collection = mongoc_client_get_collection (client, "meteor", "sensors");
query = bson_new ();
cursor = mongoc_collection_find (collection, MONGOC_QUERY_NONE, 0, 0, 0, query, NULL, NULL);
while (mongoc_cursor_next (cursor, &doc)) {
str = bson_as_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);
return 0;
}
SEXP R_mongo_cursor_next_json (SEXP ptr, SEXP n){
mongoc_cursor_t *c = r2cursor(ptr);
int len = asInteger(n);
SEXP out = PROTECT(allocVector(STRSXP, len));
const bson_t *b = NULL;
int total = 0;
bson_error_t err;
while(total < len){
if(!mongoc_cursor_next(c, &b)){
if(mongoc_cursor_error (c, &err))
stop(err.message);
else
//cursor exchausted: done
break;
} else {
size_t jsonlength;
const char *str = bson_as_json ((bson_t*) b, &jsonlength);
SET_STRING_ELT(out, total, mkCharLenCE(str, jsonlength, CE_UTF8));
if(str) bson_free(str);
total++;
}
}
if(total < len){
SEXP out2 = PROTECT(allocVector(STRSXP, total));
for(int i = 0; i < total; i++){
SET_STRING_ELT(out2, i, STRING_ELT(out, i));
}
UNPROTECT(2);
return out2;
}
UNPROTECT(1);
return out;
}
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://*****:*****@192.168.0.112:27017/");
collection = mongoc_client_get_collection (client, "clown", "testCollection");
query = bson_new ();
cursor = mongoc_collection_find (collection, MONGOC_QUERY_NONE, 0, 0, 0, query, NULL, NULL);
while (mongoc_cursor_next (cursor, &doc)) {
str = bson_as_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);
return 0;
}
static void
bulk1 (mongoc_collection_t *collection)
{
mongoc_bulk_operation_t *bulk;
bson_error_t error;
bson_t *doc;
bson_t reply;
char *str;
bool ret;
int i;
bulk = mongoc_collection_create_bulk_operation (collection, true, NULL);
for (i = 0; i < 10000; i++) {
doc = BCON_NEW ("i", BCON_INT32 (i));
mongoc_bulk_operation_insert (bulk, doc);
bson_destroy (doc);
}
ret = mongoc_bulk_operation_execute (bulk, &reply, &error);
str = bson_as_json (&reply, NULL);
printf ("%s\n", str);
bson_free (str);
if (!ret) {
fprintf (stderr, "Error: %s\n", error.message);
}
bson_destroy (&reply);
mongoc_bulk_operation_destroy (bulk);
}
static void
test_bson_as_json_stack_overflow (void)
{
uint8_t *buf;
bson_t b;
size_t buflen = 1024 * 1024 * 17;
char *str;
int fd;
ssize_t r;
buf = bson_malloc0(buflen);
fd = bson_open(BINARY_DIR"/stackoverflow.bson", O_RDONLY);
BSON_ASSERT(-1 != fd);
r = bson_read(fd, buf, buflen);
BSON_ASSERT(r == 16777220);
r = bson_init_static(&b, buf, 16777220);
BSON_ASSERT(r);
str = bson_as_json(&b, NULL);
BSON_ASSERT(str);
r = !!strstr(str, "...");
BSON_ASSERT(str);
bson_free(str);
bson_destroy(&b);
bson_free(buf);
}
static void
print_pipeline (mongoc_collection_t *collection)
{
mongoc_cursor_t *cursor;
bson_error_t error;
const bson_t *doc;
bson_t *pipeline;
char *str;
pipeline = BCON_NEW ("pipeline", "[",
"{", "$group", "{", "_id", "$state", "total_pop", "{", "$sum", "$pop", "}", "}", "}",
"{", "$match", "{", "total_pop", "{", "$gte", BCON_INT32 (10000000), "}", "}", "}",
"]");
cursor = mongoc_collection_aggregate (collection, MONGOC_QUERY_NONE, pipeline, NULL, NULL);
while (mongoc_cursor_next (cursor, &doc)) {
str = bson_as_json (doc, NULL);
printf ("%s\n", str);
bson_free (str);
}
if (mongoc_cursor_error (cursor, &error)) {
fprintf (stderr, "Cursor Failure: %s\n", error.message);
}
mongoc_cursor_destroy (cursor);
bson_destroy (pipeline);
}
int
main (int argc,
char *argv[])
{
mongoc_matcher_t *matcher;
bson_reader_t *reader;
const bson_t *bson;
bson_t *spec;
char *str;
reader = bson_reader_new_from_handle ((void *)&MONGOC_STDIN_FILENO, &_read_cb, &_destroy_cb);
spec = BCON_NEW ("hello", "world");
matcher = mongoc_matcher_new (spec, NULL);
while ((bson = bson_reader_read (reader, NULL))) {
if (mongoc_matcher_match (matcher, bson)) {
str = bson_as_json (bson, NULL);
printf ("%s\n", str);
bson_free (str);
}
}
bson_reader_destroy (reader);
bson_destroy (spec);
return 0;
}
static void
print_doc (const bson_t *b)
{
char *str;
str = bson_as_json(b, NULL);
MONGOC_DEBUG("%s", str);
bson_free(str);
}
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/");
collection = mongoc_client_get_collection(client, "stockopedia",
"instruments");
query = bson_new();
bson_t *fields = bson_new();
BSON_APPEND_INT32(fields, "RIC", 1);
cursor = mongoc_collection_find(collection, MONGOC_QUERY_NONE, 0, 0, 0,
query, fields, NULL);
bson_iter_t iter;
const bson_value_t *value;
while (mongoc_cursor_next(cursor, &doc)) {
str = bson_as_json(doc, NULL);
printf("%s\n", str);
if (bson_iter_init(&iter, doc)) {
while (bson_iter_next(&iter)) {
printf("Found a field named: %s\n", bson_iter_key(&iter));
value = bson_iter_value(&iter);
if (value->value_type == BSON_TYPE_UTF8) {
printf("It's a UTF8 : '%s'\n", value->value.v_utf8.str);
}
}
}
//printf("Found element key : '%s'\n", bson_iter_key(&iter));
// if (bson_iter_init(&iter, doc)) {
//
// }
bson_free(str);
}
//Now fetch quotes for each RIC
bson_destroy(query);
mongoc_cursor_destroy(cursor);
mongoc_collection_destroy(collection);
mongoc_client_destroy(client);
return 0;
}
static void
print_bson (const bson_t *b)
{
char *str;
str = bson_as_json(b, NULL);
fprintf(stdout, "%s\n", str);
bson_free(str);
}
void
bson_printf (const char *format,
const bson_t *bson)
{
const char *str;
str = bson_as_json (bson, NULL);
printf (format, str);
bson_free ((void*)str);
}
int
main (int argc,
char *argv[])
{
mongoc_collection_t *collection;
mongoc_client_t *client;
bson_error_t error;
bson_t *query;
bson_t *update;
bson_t reply;
char *str;
mongoc_init ();
client = mongoc_client_new ("mongodb://127.0.0.1:27017/");
collection = mongoc_client_get_collection (client, "test", "test");
/*
* Build our query, {"cmpxchg": 1}
*/
query = BCON_NEW ("cmpxchg", BCON_INT32 (1));
/*
* Build our update. {"$set": {"cmpxchg": 2}}
*/
update = BCON_NEW ("$set", "{", "cmpxchg", BCON_INT32 (2), "}");
/*
* Submit the findAndModify.
*/
if (!mongoc_collection_find_and_modify (collection, query, NULL, update, NULL, false, false, true, &reply, &error)) {
fprintf (stderr, "find_and_modify() failure: %s\n", error.message);
return 1;
}
/*
* Print the result as JSON.
*/
str = bson_as_json (&reply, NULL);
printf ("%s\n", str);
bson_free (str);
/*
* Cleanup.
*/
bson_destroy (query);
bson_destroy (update);
bson_destroy (&reply);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
mongoc_cleanup ();
return 0;
}
void
ha_replica_set_wait_for_healthy (ha_replica_set_t *replica_set)
{
bson_iter_t iter;
bson_iter_t ar;
bson_iter_t member;
const char *stateStr;
bson_t status;
again:
sleep(1);
if (!ha_replica_set_get_status(replica_set, &status)) {
MONGOC_INFO("Failed to get replicaSet status. "
"Sleeping 1 second.");
goto again;
}
#if 0
{
char *str;
str = bson_as_json(&status, NULL);
printf("%s\n", str);
bson_free(str);
}
#endif
if (!bson_iter_init_find(&iter, &status, "members") ||
!BSON_ITER_HOLDS_ARRAY(&iter) ||
!bson_iter_recurse(&iter, &ar)) {
bson_destroy(&status);
MONGOC_INFO("ReplicaSet has not yet come online. "
"Sleeping 1 second.");
goto again;
}
while (bson_iter_next(&ar)) {
if (BSON_ITER_HOLDS_DOCUMENT(&ar) &&
bson_iter_recurse(&ar, &member) &&
bson_iter_find(&member, "stateStr") &&
(stateStr = bson_iter_utf8(&member, NULL))) {
if (!!strcmp(stateStr, "PRIMARY") &&
!!strcmp(stateStr, "SECONDARY") &&
!!strcmp(stateStr, "ARBITER")) {
bson_destroy(&status);
MONGOC_INFO("Found unhealthy node. Sleeping 1 second.");
goto again;
}
}
}
bson_destroy(&status);
}
int
main (int argc,
char *argv[])
{
bson_t * query;
/*
time_t oid_thinks_time; //what time does the OID think it is
bson_oid_t oid;
bson_oid_t *oid_pointer = &oid;
bson_oid_init (&oid, NULL); // get a standard ObjectId
oid_thinks_time = bson_oid_get_time_t (&oid); //It was just made
printf ("The OID was generated at %u\n", (unsigned) oid_thinks_time); //prove it
time_t ts = time(NULL); //make a new time
struct tm * timeinfo = localtime(&ts);
timeinfo->tm_year = 2014-1900; //-1900 because time.h
timeinfo->tm_mon = 12 - 1; // time.h off by one (starts at 0)
timeinfo->tm_mday = 25;
ts = mktime(timeinfo); // create the time
u_int32_t ts_uint = (uint32_t)ts;
ts_uint = BSON_UINT32_TO_BE (ts_uint); //BSON wants big endian time
memcpy (&oid_pointer->bytes[0], &ts_uint, sizeof (ts_uint)); //overwrite the first 4 bytes with user selected time
oid_thinks_time = bson_oid_get_time_t (&oid);
printf ("The OID was fixed to time %u\n", (unsigned) oid_thinks_time);//prove it
*/
query = BCON_NEW ("ping", BCON_INT32 (1));
query = BCON_NEW("$and","[",
"{", "a", BCON_INT32(1), "}",
"{", "yyyyyyy", "{", "$ne", BCON_UTF8("xxxxxxxxxx"), "}", "}","]");
bson_t *doc;
query = BCON_NEW (
"$and", "[", "{", "_id", BCON_INT32(1), "}",
"{", "yyyyyy", "{", "$ne", BCON_UTF8 ("xxxxxxx"), "}", "}","]"
);
query = BCON_NEW("$and","[",
"{", "timestamp", "{", "$eq", BCON_INT64(1111111111112), "}", "}",
"{", "timestamp", "{", "$gte", BCON_INT64(1111111111111), "}", "}",
"{", "timestamp", "{", "$lt", BCON_INT64(1111111111110), "}", "}","]");
//prove it looks right
size_t s;
char * as_json;
as_json = bson_as_json(query, &s);
printf("%s\n", as_json);
return 0;
}
char *be_mongo_getuser(void *handle, const char *username)
{
struct mongo_backend *conf = (struct mongo_backend *)handle;
mongoc_collection_t *collection;
mongoc_cursor_t *cursor;
bson_error_t error;
const bson_t *doc;
const char *collection_name = "passport";
bson_t query;
char *str = NULL;
char *result = malloc(33);
memset(result, 0, 33);
bson_init (&query);
bson_append_utf8 (&query, "username", -1, username, -1);
collection = mongoc_client_get_collection (conf->client, "cas", collection_name);
cursor = mongoc_collection_find (collection,
MONGOC_QUERY_NONE,
0,
0,
0,
&query,
NULL, /* Fields, NULL for all. */
NULL); /* Read Prefs, NULL for default */
bson_iter_t iter;
while (!mongoc_cursor_error (cursor, &error) &&
mongoc_cursor_more (cursor)) {
if (mongoc_cursor_next (cursor, &doc)) {
bson_iter_init(&iter, doc);
bson_iter_find(&iter, "pwd");
//fprintf (stdout, "%s\n", bson_iter_utf8(&iter, NULL));
str = bson_as_json (doc, NULL);
//fprintf (stdout, "%s\n", str);
bson_free (str);
char *src = (char *)bson_iter_utf8(&iter, NULL);
memcpy(result, src, strlen(src));
}
}
if (mongoc_cursor_error (cursor, &error)) {
fprintf (stderr, "Cursor Failure: %s\n", error.message);
return result;
}
bson_destroy (&query);
mongoc_cursor_destroy (cursor);
mongoc_collection_destroy (collection);
return result;
}
static void
test_bson_as_json (void)
{
bson_oid_t oid;
bson_decimal128_t decimal128;
bson_t *b;
bson_t *b2;
char *str;
size_t len;
int i;
decimal128.high = 0x3040000000000000ULL;
decimal128.low = 0x000000000000000B;
bson_oid_init_from_string(&oid, "123412341234abcdabcdabcd");
b = bson_new();
assert(bson_append_utf8(b, "utf8", -1, "bar", -1));
assert(bson_append_int32(b, "int32", -1, 1234));
assert(bson_append_int64(b, "int64", -1, 4321));
assert(bson_append_double(b, "double", -1, 123.4));
assert(bson_append_undefined(b, "undefined", -1));
assert(bson_append_null(b, "null", -1));
assert(bson_append_oid(b, "oid", -1, &oid));
assert(bson_append_bool(b, "true", -1, true));
assert(bson_append_bool(b, "false", -1, false));
assert(bson_append_time_t(b, "date", -1, time(NULL)));
assert(bson_append_timestamp(b, "timestamp", -1, (uint32_t)time(NULL), 1234));
assert(bson_append_regex(b, "regex", -1, "^abcd", "xi"));
assert(bson_append_dbpointer(b, "dbpointer", -1, "mycollection", &oid));
assert(bson_append_minkey(b, "minkey", -1));
assert(bson_append_maxkey(b, "maxkey", -1));
assert(bson_append_symbol(b, "symbol", -1, "var a = {};", -1));
assert(bson_append_decimal128(b, "decimal128", -1, &decimal128));
b2 = bson_new();
assert(bson_append_int32(b2, "0", -1, 60));
assert(bson_append_document(b, "document", -1, b2));
assert(bson_append_array(b, "array", -1, b2));
{
const uint8_t binary[] = { 0, 1, 2, 3, 4 };
assert(bson_append_binary(b, "binary", -1, BSON_SUBTYPE_BINARY,
binary, sizeof binary));
}
for (i = 0; i < 1000; i++) {
str = bson_as_json(b, &len);
bson_free(str);
}
bson_destroy(b);
bson_destroy(b2);
}
static void
ha_config_add_shard (ha_node_t *node,
ha_replica_set_t *replica_set)
{
mongoc_collection_t *collection;
mongoc_client_t *client;
bson_string_t *shardstr;
bson_error_t error;
bson_bool_t r;
bson_t reply;
bson_t cmd = BSON_INITIALIZER;
char *uristr;
uristr = bson_strdup_printf ("mongodb://127.0.0.1:%hu/", node->port);
client = mongoc_client_new (uristr);
collection = mongoc_client_get_collection (client, "admin", "fake");
shardstr = bson_string_new (NULL);
bson_string_append_printf (shardstr, "%s/127.0.0.1:%hu",
replica_set->name,
replica_set->nodes->port);
bson_append_utf8 (&cmd, "addShard", -1, shardstr->str, shardstr->len);
bson_string_free (shardstr, TRUE);
again:
sleep (1);
r = mongoc_collection_command_simple (collection, &cmd, NULL, &reply, &error);
if (!r) {
fprintf (stderr, "%s\n", error.message);
goto again;
}
#if 1
{
char *str;
str = bson_as_json (&reply, NULL);
printf ("%s\n", str);
bson_free (str);
}
#endif
bson_destroy (&reply);
bson_destroy (&cmd);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
bson_free (uristr);
}
int
main (int argc,
char *argv[])
{
const bson_t *b;
extent_t extent;
record_t record;
char *str;
db_t db;
ns_t ns;
if (argc != 3) {
fprintf(stderr, "usage: mdbdump DBPATH DBNAME\n");
return ARGC_FAILURE;
}
errno = 0;
if (!!db_init(&db, argv[1], argv[2])) {
perror("Failed to load database");
return DB_FAILURE;
}
errno = 0;
if (!!db_namespaces(&db, &ns)) {
perror("Failed to load namespaces");
return NS_FAILURE;
}
do {
//fprintf(stdout, "\nNamespace \"%s\"\n\n", ns_name(&ns));
if (!!ns_extents(&ns, &extent)) {
perror("Failed to load extent");
return EXTENT_FAILURE;
}
do {
if (!extent_records(&extent, &record)) {
do {
b = record_bson(&record);
if ((str = bson_as_json(b, NULL))) {
puts(str);
}
bson_free(str);
} while (!record_next(&record));
}
} while (!extent_next(&extent));
} while (ns_next(&ns));
db_destroy(&db);
return 0;
}
void
command_succeeded (const mongoc_apm_command_succeeded_t *event)
{
char *s;
s = bson_as_json (mongoc_apm_command_succeeded_get_reply (event), NULL);
printf ("Command %s succeeded:\n%s\n\n",
mongoc_apm_command_succeeded_get_command_name (event),
s);
((stats_t *) mongoc_apm_command_succeeded_get_context (event))->succeeded++;
bson_free (s);
}
static void
test_bson_as_json_utf8 (void)
{
size_t len;
bson_t *b;
char *str;
b = bson_new();
assert(bson_append_utf8(b, "€€€€€", -1, "€€€€€", -1));
str = bson_as_json(b, &len);
assert(!strcmp(str, "{ \"€€€€€\" : \"€€€€€\" }"));
bson_free(str);
bson_destroy(b);
}
static void
bulk3 (mongoc_collection_t *collection)
{
mongoc_bulk_operation_t *bulk;
bson_error_t error;
bson_t *query;
bson_t *doc;
bson_t reply;
char *str;
bool ret;
/* false indicates unordered */
bulk = mongoc_collection_create_bulk_operation (collection, false, NULL);
/* Add a document */
doc = BCON_NEW ("_id", BCON_INT32 (1));
mongoc_bulk_operation_insert (bulk, doc);
bson_destroy (doc);
/* remove {_id: 2} */
query = BCON_NEW ("_id", BCON_INT32 (2));
mongoc_bulk_operation_remove_one (bulk, query);
bson_destroy (query);
/* insert {_id: 3} */
doc = BCON_NEW ("_id", BCON_INT32 (3));
mongoc_bulk_operation_insert (bulk, doc);
bson_destroy (doc);
/* replace {_id:4} {'i': 1} */
query = BCON_NEW ("_id", BCON_INT32 (4));
doc = BCON_NEW ("i", BCON_INT32 (1));
mongoc_bulk_operation_replace_one (bulk, query, doc, false);
bson_destroy (query);
bson_destroy (doc);
ret = mongoc_bulk_operation_execute (bulk, &reply, &error);
str = bson_as_json (&reply, NULL);
printf ("%s\n", str);
bson_free (str);
if (!ret) {
printf ("Error: %s\n", error.message);
}
bson_destroy (&reply);
mongoc_bulk_operation_destroy (bulk);
}
static void
test_bson_as_json_int64 (void)
{
size_t len;
bson_t *b;
char *str;
b = bson_new();
assert(bson_append_int64(b, "foo", -1, 341234123412341234ULL));
str = bson_as_json(b, &len);
assert(len == 30);
assert(!strcmp("{ \"foo\" : 341234123412341234 }", str));
bson_free(str);
bson_destroy(b);
}
static void
test_bson_as_json_string (void)
{
size_t len;
bson_t *b;
char *str;
b = bson_new();
assert(bson_append_utf8(b, "foo", -1, "bar", -1));
str = bson_as_json(b, &len);
assert(len == 17);
assert(!strcmp("{ \"foo\" : \"bar\" }", str));
bson_free(str);
bson_destroy(b);
}
