static void test_date_time (void) { int64_t out; bson_t *bcon = BCON_NEW ("foo", BCON_DATE_TIME (10000)); BSON_ASSERT (BCON_EXTRACT (bcon, "foo", BCONE_DATE_TIME (out))); BSON_ASSERT (out == 10000); bson_destroy (bcon); }
static void bulk5_success (mongoc_collection_t *collection) { mongoc_bulk_operation_t *bulk; bson_error_t error; bson_t *doc; bson_t reply; char *str; bool ret; bulk = mongoc_collection_create_bulk_operation (collection, true, NULL); /* Allow this document to bypass document validation. * NOTE: When authentication is enabled, the authenticated user must have * either the "dbadmin" or "restore" roles to bypass document validation */ mongoc_bulk_operation_set_bypass_document_validation (bulk, true); /* Two inserts */ doc = BCON_NEW ("_id", BCON_INT32 (31)); mongoc_bulk_operation_insert (bulk, doc); bson_destroy (doc); doc = BCON_NEW ("_id", BCON_INT32 (32)); mongoc_bulk_operation_insert (bulk, doc); bson_destroy (doc); ret = mongoc_bulk_operation_execute (bulk, &reply, &error); str = bson_as_json (&reply, NULL); printf ("%s\n", str); bson_free (str); if (!ret) { printf ("Error: %s\n", error.message); } bson_destroy (&reply); mongoc_bulk_operation_destroy (bulk); }
static void test_bool (void) { bool b; bson_t *bcon = BCON_NEW ("foo", BCON_BOOL (true)); BSON_ASSERT (BCON_EXTRACT (bcon, "foo", BCONE_BOOL (b))); BSON_ASSERT (b == true); bson_destroy (bcon); }
static void test_code (void) { const char *val; bson_t *bcon = BCON_NEW ("foo", BCON_CODE ("var a = {};")); BSON_ASSERT (BCON_EXTRACT (bcon, "foo", BCONE_CODE (val))); BSON_ASSERT (strcmp (val, "var a = {};") == 0); bson_destroy (bcon); }
static void test_int64 (void) { int64_t i64; bson_t *bcon = BCON_NEW ("foo", BCON_INT64 (10)); assert (BCON_EXTRACT (bcon, "foo", BCONE_INT64 (i64))); assert (i64 == 10); bson_destroy (bcon); }
static void test_double (void) { double val; bson_t *bcon = BCON_NEW ("foo", BCON_DOUBLE (1.1)); BSON_ASSERT (BCON_EXTRACT (bcon, "foo", BCONE_DOUBLE (val))); BSON_ASSERT (val == 1.1); bson_destroy (bcon); }
static void test_utf8 (void) { const char *val; bson_t *bcon = BCON_NEW ("hello", "world"); assert (BCON_EXTRACT (bcon, "hello", BCONE_UTF8 (val))); assert (strcmp (val, "world") == 0); bson_destroy (bcon); }
static void test_int32 (void) { int32_t i32; bson_t *bcon = BCON_NEW ("foo", BCON_INT32 (10)); assert (BCON_EXTRACT (bcon, "foo", BCONE_INT32 (i32))); assert (i32 == 10); bson_destroy (bcon); }
static void bulk6 (mongoc_collection_t *collection) { mongoc_write_concern_t *wc; mongoc_bulk_operation_t *bulk; bson_error_t error; bson_t *doc; bson_t *selector; bson_t reply; char *str; bool ret; wc = mongoc_write_concern_new (); mongoc_write_concern_set_w (wc, 0); bulk = mongoc_collection_create_bulk_operation (collection, true, wc); doc = BCON_NEW ("_id", BCON_INT32 (10)); mongoc_bulk_operation_insert (bulk, doc); bson_destroy (doc); selector = BCON_NEW ("_id", BCON_INT32 (11)); mongoc_bulk_operation_remove_one (bulk, selector); bson_destroy (selector); ret = mongoc_bulk_operation_execute (bulk, &reply, &error); str = bson_as_json (&reply, NULL); printf ("%s\n", str); bson_free (str); if (!ret) { printf ("Error: %s\n", error.message); } bson_destroy (&reply); mongoc_bulk_operation_destroy (bulk); mongoc_write_concern_destroy (wc); }
static void test_symbol (void) { const char *val; bson_t *bcon = BCON_NEW ("foo", BCON_SYMBOL ("symbol")); BSON_ASSERT (BCON_EXTRACT (bcon, "foo", BCONE_SYMBOL (val))); BSON_ASSERT (strcmp (val, "symbol") == 0); bson_destroy (bcon); }
static void test_bool (void) { bson_bool_t b; bson_t *bcon = BCON_NEW ("foo", BCON_BOOL (TRUE)); assert (BCON_EXTRACT (bcon, "foo", BCONE_BOOL (b))); assert (b == TRUE); bson_destroy (bcon); }
static void test_invalid_write_concern (void) { mongoc_write_command_t command; mongoc_write_result_t result; mongoc_collection_t *collection; mongoc_client_t *client; mongoc_write_concern_t *write_concern; bson_t **docs; bson_t reply = BSON_INITIALIZER; bson_error_t error; bool r; client = test_framework_client_new (NULL); assert(client); collection = get_test_collection(client, "test_invalid_write_concern"); assert(collection); write_concern = mongoc_write_concern_new(); assert(write_concern); mongoc_write_concern_set_w(write_concern, 0); mongoc_write_concern_set_journal(write_concern, true); assert(!_mongoc_write_concern_is_valid(write_concern)); docs = bson_malloc(sizeof(bson_t*)); docs[0] = BCON_NEW("_id", BCON_INT32(0)); _mongoc_write_command_init_insert(&command, (const bson_t * const *)docs, 1, true, true); _mongoc_write_result_init (&result); _mongoc_write_command_execute (&command, client, 0, collection->db, collection->collection, write_concern, 0, &result); r = _mongoc_write_result_complete (&result, &reply, &error); assert(!r); assert(error.domain = MONGOC_ERROR_COMMAND); assert(error.code = MONGOC_ERROR_COMMAND_INVALID_ARG); _mongoc_write_command_destroy (&command); _mongoc_write_result_destroy (&result); bson_destroy(docs[0]); bson_free(docs); mongoc_collection_destroy(collection); mongoc_client_destroy(client); mongoc_write_concern_destroy(write_concern); }
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); }
static void topology_closed (const mongoc_apm_topology_closed_t *event) { context_t *ctx; bson_oid_t topology_id; ctx = (context_t *) mongoc_apm_topology_closed_get_context (event); mongoc_apm_topology_closed_get_topology_id (event, &topology_id); ASSERT (bson_oid_equal (&topology_id, &ctx->topology_id)); context_append ( ctx, BCON_NEW ( "topology_closed_event", "{", "topologyId", BCON_UTF8 ("42"), "}")); }
static void test_mongoc_matcher_eq_int64 (void) { bson_t *spec; bson_t *doc; bson_error_t error; mongoc_matcher_t *matcher; bool r; spec = BCON_NEW ("hello", BCON_INT64 (1234)); matcher = mongoc_matcher_new (spec, &error); BSON_ASSERT (matcher); r = mongoc_matcher_match (matcher, spec); BSON_ASSERT (r); bson_destroy (spec); mongoc_matcher_destroy (matcher); spec = BCON_NEW ("hello", BCON_INT64 (1234)); doc = BCON_NEW ("hello", BCON_INT64 (1234)); matcher = mongoc_matcher_new (spec, &error); BSON_ASSERT (matcher); r = mongoc_matcher_match (matcher, doc); BSON_ASSERT (r); bson_destroy (spec); bson_destroy (doc); mongoc_matcher_destroy (matcher); spec = BCON_NEW ("hello", BCON_INT64 (1234)); doc = BCON_NEW ("hello", BCON_INT32 (4321)); matcher = mongoc_matcher_new (spec, &error); BSON_ASSERT (matcher); r = mongoc_matcher_match (matcher, doc); BSON_ASSERT (!r); bson_destroy (spec); bson_destroy (doc); mongoc_matcher_destroy (matcher); }
static void test_mongoc_matcher_eq_utf8 (void) { bson_t *doc; bson_t *spec; bson_error_t error; mongoc_matcher_t *matcher; bool r; spec = BCON_NEW("hello", "world"); matcher = mongoc_matcher_new (spec, &error); BSON_ASSERT (matcher); r = mongoc_matcher_match (matcher, spec); BSON_ASSERT (r); bson_destroy (spec); mongoc_matcher_destroy (matcher); spec = BCON_NEW ("hello", "world"); doc = BCON_NEW ("hello", BCON_NULL); matcher = mongoc_matcher_new (spec, &error); BSON_ASSERT (matcher); r = mongoc_matcher_match (matcher, doc); BSON_ASSERT (!r); bson_destroy (spec); bson_destroy (doc); mongoc_matcher_destroy (matcher); spec = BCON_NEW ("hello", "world"); doc = BCON_NEW ("hello", BCON_UNDEFINED); matcher = mongoc_matcher_new (spec, &error); BSON_ASSERT (matcher); r = mongoc_matcher_match (matcher, doc); BSON_ASSERT (!r); bson_destroy (spec); bson_destroy (doc); mongoc_matcher_destroy (matcher); }
static void server_heartbeat_failed (const mongoc_apm_server_heartbeat_failed_t *event) { context_t *ctx; const mongoc_host_list_t *host; ctx = (context_t *) mongoc_apm_server_heartbeat_failed_get_context (event); host = mongoc_apm_server_heartbeat_failed_get_host (event); context_append (ctx, BCON_NEW ("heartbeat_failed_event", "{", "host", BCON_UTF8 (host->host_and_port), "}")); }
int main (int argc, const char **argv) { bson_t *b; char *j; b = BCON_NEW ("hello", BCON_UTF8 ("bson!")); j = bson_as_canonical_extended_json (b, NULL); printf ("%s\n", j); bson_free (j); bson_destroy (b); return 0; }
static void test_inline_array (void) { int32_t a, b; bson_t *bcon = BCON_NEW ("foo", "[", BCON_INT32 (1), BCON_INT32 (2), "]"); assert ( BCON_EXTRACT (bcon, "foo", "[", BCONE_INT32 (a), BCONE_INT32 (b), "]")); assert (a == 1); assert (b == 2); bson_destroy (bcon); }
static void test_regex (void) { const char *regex; const char *flags; bson_t *bcon = BCON_NEW ("foo", BCON_REGEX ("^foo|bar$", "i")); assert (BCON_EXTRACT (bcon, "foo", BCONE_REGEX (regex, flags))); assert (strcmp (regex, "^foo|bar$") == 0); assert (strcmp (flags, "i") == 0); bson_destroy (bcon); }
static void test_timestamp (void) { int32_t timestamp; int32_t increment; bson_t *bcon = BCON_NEW ("foo", BCON_TIMESTAMP (100, 1000)); assert (BCON_EXTRACT (bcon, "foo", BCONE_TIMESTAMP (timestamp, increment))); assert (timestamp == 100); assert (increment == 1000); bson_destroy (bcon); }
static void bulk5_fail (mongoc_collection_t *collection) { mongoc_bulk_operation_t *bulk; bson_error_t error; bson_t *doc; bson_t reply; char *str; bool ret; bulk = mongoc_collection_create_bulk_operation (collection, true, NULL); /* Two inserts */ doc = BCON_NEW ("_id", BCON_INT32 (31)); mongoc_bulk_operation_insert (bulk, doc); bson_destroy (doc); doc = BCON_NEW ("_id", BCON_INT32 (32)); mongoc_bulk_operation_insert (bulk, doc); bson_destroy (doc); /* The above documents do not comply to the schema validation rules * we created previously, so this will result in an error */ ret = mongoc_bulk_operation_execute (bulk, &reply, &error); str = bson_as_json (&reply, NULL); printf ("%s\n", str); bson_free (str); if (!ret) { printf ("Error: %s\n", error.message); } bson_destroy (&reply); mongoc_bulk_operation_destroy (bulk); }
static void topology_opening (const mongoc_apm_topology_opening_t *event) { context_t *ctx; bson_oid_t zeroes; /* new event's topology id is NOT all zeroes */ bson_oid_init_from_string (&zeroes, "000000000000000000000000"); ASSERT (!bson_oid_equal (&event->topology_id, &zeroes)); ctx = (context_t *) mongoc_apm_topology_opening_get_context (event); mongoc_apm_topology_opening_get_topology_id (event, &ctx->topology_id); context_append (ctx, BCON_NEW ("topology_opening_event", "{", "topologyId", BCON_UTF8 ("42"), "}")); }
static void test_inline_doc (void) { int32_t a, b; bson_t *bcon = BCON_NEW ("foo", "{", "b", BCON_INT32 (2), "a", BCON_INT32 (1), "}"); BSON_ASSERT (BCON_EXTRACT ( bcon, "foo", "{", "a", BCONE_INT32 (a), "b", BCONE_INT32 (b), "}")); BSON_ASSERT (a == 1); BSON_ASSERT (b == 2); bson_destroy (bcon); }
SEXP R_mongo_collection_create_index(SEXP ptr_col, SEXP ptr_bson) { mongoc_collection_t *col = r2col(ptr_col); bson_t *keys = r2bson(ptr_bson); const char * collection_name = mongoc_collection_get_name(col); char * index_name = mongoc_collection_keys_to_index_string (keys); bson_error_t err; //From: https://s3.amazonaws.com/mciuploads/mongo-c-driver/docs/latest/create-indexes.html bson_t * command = BCON_NEW ("createIndexes", BCON_UTF8 (collection_name), "indexes", "[", "{", "key", BCON_DOCUMENT (keys), "name", BCON_UTF8 (index_name), "}", "]"); if(!mongoc_collection_write_command_with_opts(col, command, NULL, NULL, &err)) stop(err.message); return Rf_ScalarLogical(1); }
static void test_bcon_new (void) { bson_t expected; bson_t * bcon; bson_init (&expected); bson_append_utf8 (&expected, "hello", -1, "world", -1); bcon = BCON_NEW("hello", "world"); bson_eq_bson (bcon, &expected); bson_destroy (bcon); bson_destroy (&expected); }
static void test_oid (void) { bson_oid_t oid; const bson_oid_t *ooid; bson_oid_init (&oid, NULL); bson_t *bcon = BCON_NEW ("foo", BCON_OID (&oid)); assert (BCON_EXTRACT (bcon, "foo", BCONE_OID (ooid))); assert (bson_oid_equal (&oid, ooid)); bson_destroy (bcon); }
void fam_flags(mongoc_collection_t *collection) { mongoc_find_and_modify_opts_t *opts; bson_t reply; bson_error_t error; bson_t query = BSON_INITIALIZER; bson_t *update; bool success; /* Find Zlatan Ibrahimovic, the striker */ BSON_APPEND_UTF8 (&query, "firstname", "Zlatan"); BSON_APPEND_UTF8 (&query, "lastname", "Ibrahimovic"); BSON_APPEND_UTF8 (&query, "profession", "Football player"); BSON_APPEND_INT32 (&query, "age", 34); BSON_APPEND_INT32 (&query, "goals", (16+35+23+57+16+14+28+84)+(1+6+62)); /* Add his football position */ update = BCON_NEW ("$set", "{", "position", BCON_UTF8 ("striker"), "}"); opts = mongoc_find_and_modify_opts_new (); mongoc_find_and_modify_opts_set_update (opts, update); /* Create the document if it didn't exist, and return the updated document */ mongoc_find_and_modify_opts_set_flags (opts, MONGOC_FIND_AND_MODIFY_UPSERT|MONGOC_FIND_AND_MODIFY_RETURN_NEW); success = mongoc_collection_find_and_modify_with_opts (collection, &query, opts, &reply, &error); if (success) { char *str; str = bson_as_json (&reply, NULL); printf ("%s\n", str); bson_free (str); } else { fprintf(stderr, "Got error: \"%s\" on line %d\n", error.message, __LINE__); } bson_destroy (&reply); bson_destroy (update); bson_destroy (&query); mongoc_find_and_modify_opts_destroy (opts); }
static void test_decimal128 (void) { bson_decimal128_t val; bson_decimal128_t dec; bson_t *bcon; bson_decimal128_from_string("12", &dec); bcon = BCON_NEW ("foo", BCON_DECIMAL128 (&dec)); assert (BCON_EXTRACT (bcon, "foo", BCONE_DECIMAL128 (val))); assert (val.low == 0xCULL); assert (val.high == 0x3040000000000000ULL); bson_destroy (bcon); }
static void test_mongoc_matcher_in_basic (void) { mongoc_matcher_t *matcher; bson_error_t error; bool r; bson_t *spec; bson_t doc = BSON_INITIALIZER; spec = BCON_NEW ("key", "{", "$in", "[", BCON_INT32 (1), BCON_INT32 (2), BCON_INT32 (3), "]", "}"); matcher = mongoc_matcher_new (spec, &error); r = mongoc_matcher_match (matcher, &doc); ASSERT (!r); bson_reinit (&doc); bson_append_int32 (&doc, "key", 3, 1); r = mongoc_matcher_match (matcher, &doc); ASSERT (r); bson_reinit (&doc); bson_append_int32 (&doc, "key", 3, 2); r = mongoc_matcher_match (matcher, &doc); ASSERT (r); bson_reinit (&doc); bson_append_int32 (&doc, "key", 3, 3); r = mongoc_matcher_match (matcher, &doc); ASSERT (r); bson_reinit (&doc); bson_append_int32 (&doc, "key", 3, 4); r = mongoc_matcher_match (matcher, &doc); ASSERT (!r); bson_destroy (&doc); bson_destroy (spec); mongoc_matcher_destroy (matcher); }