int main(int argc, char* argv[]) { int f; struct bson_info* bson; int ret; fprintf_blue(stdout, "BSON Printer -- By: Wolfgang Richter " "<*****@*****.**>\n"); if (argc < 2) { fprintf_light_red(stderr, "Usage: %s <BSON file>\n", argv[0]); return EXIT_FAILURE; } fprintf_cyan(stdout, "Analyzing BSON File: %s\n", argv[1]); f = open(argv[1], O_RDONLY); if (f < 0) { fprintf_light_red(stderr, "Error opening BSON file.\n"); return EXIT_FAILURE; } bson = bson_init(); while ((ret = bson_readf(bson, f)) == 1) bson_print(stdout, bson); bson_cleanup(bson); check_syscall(close(f)); return EXIT_SUCCESS; }
void test_index_helper( mongo *conn ) { int ret; bson b, out; bson_iterator it; bson_init( &b ); bson_append_int( &b, "foo", -1 ); bson_finish( &b ); mongo_create_index( conn, "test.bar", &b, NULL, MONGO_INDEX_SPARSE | MONGO_INDEX_UNIQUE, &out ); bson_destroy( &b ); bson_destroy( &out ); bson_init( &b ); bson_append_start_object( &b, "key" ); bson_append_int( &b, "foo", -1 ); bson_append_finish_object( &b ); bson_finish( &b ); ret = mongo_find_one( conn, "test.system.indexes", &b, NULL, &out ); ASSERT( ret == MONGO_OK ); bson_print( &out ); bson_iterator_init( &it, &out ); ASSERT( bson_find( &it, &out, "unique" ) ); ASSERT( bson_find( &it, &out, "sparse" ) ); bson_destroy( &b ); bson_destroy( &out ); }
static void tutorial_empty_query( mongo *conn) { mongo_cursor cursor[1]; mongo_cursor_init( cursor, conn, "tutorial.persons" ); while( mongo_cursor_next( cursor ) == MONGO_OK ) bson_print( &cursor->current ); mongo_cursor_destroy( cursor ); }
TEST(cursor,sdbNext) { INT32 rc = SDB_OK ; rc = initEnv( HOST, SERVER, USER, PASSWD ) ; ASSERT_EQ( SDB_OK, rc ) ; sdbConnectionHandle connection = 0 ; sdbCollectionHandle collection = 0 ; sdbCursorHandle cursor = 0 ; INT32 NUM = 10 ; SINT64 count = 0 ; bson obj ; rc = sdbConnect ( HOST, SERVER, USER, PASSWD, &connection ) ; ASSERT_EQ( SDB_OK, rc ) ; rc = getCollection ( connection, COLLECTION_FULL_NAME, &collection ) ; ASSERT_EQ( SDB_OK, rc ) ; insertRecords( collection, NUM ) ; rc = sdbQuery ( collection, NULL, NULL, NULL, NULL, 0, -1, &cursor ) ; ASSERT_EQ( SDB_OK, rc ) ; bson_init(&obj); rc = sdbCurrent( cursor, &obj ) ; printf( "Current record is:\n" ) ; bson_print( &obj ) ; printf("\n") ; bson_destroy( &obj ) ; bson_init(&obj); rc = sdbNext( cursor, &obj ) ; ASSERT_EQ( SDB_OK, rc ) ; printf( "Next record is:\n" ) ; bson_print( &obj ) ; printf("\n") ; bson_destroy(&obj); rc = sdbGetCount( collection, NULL, &count ) ; CHECK_MSG("%s%d\n","rc = ",rc) ; CHECK_MSG("%s%d%s%lld\n", "NUM = ", NUM, " count = ", count) ; ASSERT_EQ ( NUM, count ) ; sdbDisconnect ( connection ) ; sdbReleaseCursor ( cursor ) ; sdbReleaseCollection ( collection ) ; sdbReleaseConnection ( connection ) ; }
void MongodbObject::Print() { if(objectData->object->finished) { bson_print(objectData->object); } else { Logger::Warning("[MongodbObject::Print] Object not finished"); } }
int main() { /* * We assume objects in the form of {_id:<any_id>, list:[{a:<int>,b:<int>}, ...]} */ mongo conn[1]; mongo_init(conn); if(MONGO_OK != mongo_client(conn, "127.0.0.1", 27017)) return 1; bson b[1], b_result[1]; /*create the aggregation command in bson*/ bson_init(b); bson_append_string(b, "aggregate", "agg"); bson_append_start_array(b, "pipeline"); bson_append_start_object(b,"0"); bson_append_string(b, "$unwind", "$list"); bson_append_finish_object(b); bson_append_start_object(b,"1"); bson_append_start_object(b,"$group"); bson_append_string(b,"_id", "$list"); bson_append_start_object(b, "distinct_count"); bson_append_int(b, "$sum", 1); bson_append_finish_object(b); bson_append_finish_object(b); bson_append_finish_object(b); bson_append_finish_array(b); bson_finish(b); /*So you can see your command*/ bson_print(b); /*run the command*/ mongo_run_command(conn, "test", b, b_result); /*command results*/ bson_print(b_result); bson_destroy(b_result); bson_destroy(b); mongo_destroy(conn); return 0; }
TEST(cursor,sdbCursor_get_over_then_close) { INT32 rc = SDB_OK ; rc = initEnv( HOST, SERVER, USER, PASSWD ) ; ASSERT_EQ( SDB_OK, rc ) ; sdbConnectionHandle connection = 0 ; sdbCollectionHandle collection = 0 ; sdbCursorHandle cursor = 0 ; INT32 NUM = 1 ; bson obj ; bson obj1 ; bson obj2 ; rc = sdbConnect ( HOST, SERVER, USER, PASSWD, &connection ) ; ASSERT_EQ( SDB_OK, rc ) ; rc = getCollection ( connection, COLLECTION_FULL_NAME, &collection ) ; ASSERT_EQ( SDB_OK, rc ) ; insertRecords ( collection, NUM ) ; rc = sdbQuery( collection, NULL, NULL, NULL, NULL, 0, -1, &cursor ) ; ASSERT_EQ( SDB_OK, rc ) ; bson_init(&obj); bson_init(&obj1); bson_init(&obj2); rc = sdbNext ( cursor, &obj ) ; CHECK_MSG("%s%d\n","rc = ",rc) ; ASSERT_EQ( SDB_OK, rc ) ; printf( "SdbNext record is:\n" ) ; bson_print( &obj ) ; printf("\n") ; rc = sdbNext ( cursor, &obj1 ) ; CHECK_MSG("%s%d\n","rc = ",rc) ; ASSERT_EQ( SDB_DMS_EOC, rc ) ; rc = sdbNext ( cursor, &obj1 ) ; CHECK_MSG("%s%d\n","rc = ",rc) ; ASSERT_EQ( SDB_DMS_CONTEXT_IS_CLOSE, rc ) ; bson_destroy( &obj ) ; bson_destroy( &obj1 ) ; bson_destroy( &obj2 ) ; rc = sdbCloseCursor( cursor ) ; CHECK_MSG("%s%d\n","rc = ",rc) ; ASSERT_EQ( SDB_OK, rc ) ; sdbDisconnect ( connection ) ; sdbReleaseCursor ( cursor ) ; sdbReleaseCollection ( collection ) ; sdbReleaseConnection ( connection ) ; }
void test_bson_from_bcon(const bcon *bc, bcon_error_t bc_err, int bv_err ) { bcon_error_t ret; bson b[1]; if ( verbose ) { putchar('\t'); bcon_print(bc); putchar('\n'); } ret = bson_from_bcon( b, bc ); if (ret != bc_err) { printf("test_bson_from_bcon ret:%d(%s) != bc_err:%d(%s)\n", ret, bcon_errstr[ret], bc_err, bcon_errstr[bc_err]); } assert( ret == bc_err ); assert( b->err == bv_err ); if ( verbose ) bson_print(b); bson_destroy( b ); }
void test_example_hello_world() { bcon_error_t ret; bson b[1]; /* JSON {"hello": "world"} */ bcon hello[] = {"hello", "world", BEND}; test_bson_from_bcon( hello, BCON_OK, BSON_VALID ); if ( verbose ) printf("\t--------\n"); bson_init( b ); bson_append_string( b, "hello", "world" ); ret = bson_finish( b ); if ( verbose ) bson_print( b ); bson_destroy( b ); }
TEST(cursor,sdbCloseCursor) { INT32 rc = SDB_OK ; rc = initEnv( HOST, SERVER, USER, PASSWD ) ; ASSERT_EQ( SDB_OK, rc ) ; sdbConnectionHandle connection = 0 ; sdbCollectionHandle collection = 0 ; sdbCursorHandle cursor = 0 ; INT32 NUM = 10 ; bson obj ; bson obj1 ; rc = sdbConnect ( HOST, SERVER, USER, PASSWD, &connection ) ; ASSERT_EQ( SDB_OK, rc ) ; rc = getCollection ( connection, COLLECTION_FULL_NAME, &collection ) ; ASSERT_EQ( SDB_OK, rc ) ; insertRecords ( collection, NUM ) ; rc = sdbQuery( collection, NULL, NULL, NULL, NULL, 0, -1, &cursor ) ; bson_init(&obj); rc = sdbCurrent( cursor, &obj ) ; ASSERT_EQ( SDB_OK, rc ) ; printf( "Current record is:\n" ) ; bson_print( &obj ) ; printf("\n") ; bson_destroy( &obj ) ; rc = sdbCloseCursor( cursor ) ; ASSERT_EQ( SDB_OK, rc ) ; bson_init( &obj1 ) ; rc = sdbCurrent( cursor, &obj1 ) ; ASSERT_EQ( rc, SDB_DMS_CONTEXT_IS_CLOSE ) ; sdbDisconnect ( connection ) ; sdbReleaseCursor ( cursor ) ; sdbReleaseCollection ( collection ) ; sdbReleaseConnection ( connection ) ; }
void test_example_awesome() { bcon_error_t ret; bson b[1]; /* JSON {"BSON": ["awesome", 5.05, 1986]} */ bcon awesome[] = { "BSON", "[", "awesome", BF(5.05), BI(1986), "]", BEND }; test_bson_from_bcon( awesome, BCON_OK, BSON_VALID ); if (verbose ) printf("\t--------\n"); bson_init( b ); bson_append_start_array( b, "BSON" ); bson_append_string( b, "0", "awesome" ); bson_append_double( b, "1", 5.05 ); bson_append_int( b, "2", 1986 ); bson_append_finish_array( b ); ret = bson_finish( b ); if ( verbose ) bson_print( b ); bson_destroy( b ); }
static int Encode(lua_State *L){ bson* b = bson_encode(L); if(b == NULL){ LOG_ERROR("null"); return -1; } bson_print(b); bson* bson_field = (bson*) lua_newuserdata(L,sizeof(bson)); if(bson_field == NULL) { LOG_ERROR("null"); return -1; } int ret = bson_copy(bson_field,b); if(ret != 0) { LOG_ERROR("copy fail"); } //bson_print(bson_field); luaL_getmetatable(L,"bson"); lua_setmetatable(L,-2); bson_destroy(b); return 1; }
static int __check_auth_reply(void) { int res; modem_ret_t ret; ssize_t len; uint8_t *data; bson b; ret = modem_get_packet(TCS_SERVICE_PROF, &data, &len); if (ret != MODEM_RET_OK) { printf("Error getting server packet=%d\n", ret); return -1; } printf("Decoding BSON data of size=%ld\n", len); bson_init_unfinished_data(&b, (char *)data + 2, len - 2, 0); bson_print(&b); bson_destroy(&b); free(data); return 0; }
void MongodbClient::DumpDB() { Logger::Debug("***** MONGO DUMP *******"); bson query; bson_empty(&query); mongo_cursor *cursor = mongo_find(clientData->connection, namespaceName.c_str(), &query, NULL, 0, 0, 0); int32 count = 0; while( mongo_cursor_next( cursor ) == MONGO_OK ) { const bson *currentObject = mongo_cursor_bson(cursor); Logger::Debug(Format("BSON[%d]:", count)); bson_print(currentObject); ++count; } mongo_cursor_destroy(cursor); Logger::Debug("Count: %d", count); Logger::Debug("************************"); }
int test_bson_generic( void ) { bson_iterator it, it2, it3; bson_oid_t oid; bson_timestamp_t ts; bson_timestamp_t ts_result; bson b[1]; bson copy[1]; bson scope[1]; ts.i = 1; ts.t = 2; bson_init( b ); bson_append_double( b, "d", 3.14 ); bson_append_string( b, "s", "hello" ); bson_append_string_n( b, "s_n", "goodbye cruel world", 7 ); { bson_append_start_object( b, "o" ); bson_append_start_array( b, "a" ); bson_append_binary( b, "0", 8, "w\0rld", 5 ); bson_append_finish_object( b ); bson_append_finish_object( b ); } bson_append_undefined( b, "u" ); bson_oid_from_string( &oid, "010203040506070809101112" ); ASSERT( !memcmp( oid.bytes, "\x001\x002\x003\x004\x005\x006\x007\x008\x009\x010\x011\x012", 12 ) ); bson_append_oid( b, "oid", &oid ); bson_append_bool( b, "b", 1 ); bson_append_date( b, "date", 0x0102030405060708 ); bson_append_null( b, "n" ); bson_append_regex( b, "r", "^asdf", "imx" ); /* no dbref test (deprecated) */ bson_append_code( b, "c", "function(){}" ); bson_append_code_n( b, "c_n", "function(){}garbage", 12 ); bson_append_symbol( b, "symbol", "symbol" ); bson_append_symbol_n( b, "symbol_n", "symbol and garbage", 6 ); { bson_init( scope ); bson_append_int( scope, "i", 123 ); bson_finish( scope ); bson_append_code_w_scope( b, "cws", "function(){return i}", scope ); bson_destroy( scope ); } bson_append_timestamp( b, "timestamp", &ts ); bson_append_long( b, "l", 0x1122334455667788 ); /* Ensure that we can't copy a non-finished object. */ ASSERT( bson_copy( copy, b ) == BSON_ERROR ); bson_finish( b ); ASSERT( b->err == BSON_VALID ); /* Test append after finish. */ ASSERT( bson_append_string( b, "foo", "bar" ) == BSON_ERROR ); ASSERT( b->err & BSON_ALREADY_FINISHED ); ASSERT( bson_copy( copy, b ) == BSON_OK ); ASSERT( 1 == copy->finished ); ASSERT( 0 == copy->err ); bson_destroy( copy ); bson_print( b ); bson_iterator_init( &it, b ); ASSERT( bson_iterator_more( &it ) ); ASSERT( bson_iterator_next( &it ) == BSON_DOUBLE ); ASSERT( bson_iterator_type( &it ) == BSON_DOUBLE ); ASSERT( !strcmp( bson_iterator_key( &it ), "d" ) ); ASSERT( bson_iterator_double( &it ) == 3.14 ); ASSERT( bson_iterator_more( &it ) ); ASSERT( bson_iterator_next( &it ) == BSON_STRING ); ASSERT( bson_iterator_type( &it ) == BSON_STRING ); ASSERT( !strcmp( bson_iterator_key( &it ), "s" ) ); ASSERT( !strcmp( bson_iterator_string( &it ), "hello" ) ); ASSERT( strcmp( bson_iterator_string( &it ), "" ) ); ASSERT( bson_iterator_more( &it ) ); ASSERT( bson_iterator_next( &it ) == BSON_STRING ); ASSERT( bson_iterator_type( &it ) == BSON_STRING ); ASSERT( !strcmp( bson_iterator_key( &it ), "s_n" ) ); ASSERT( !strcmp( bson_iterator_string( &it ), "goodbye" ) ); ASSERT( bson_iterator_more( &it ) ); ASSERT( bson_iterator_next( &it ) == BSON_OBJECT ); ASSERT( bson_iterator_type( &it ) == BSON_OBJECT ); ASSERT( !strcmp( bson_iterator_key( &it ), "o" ) ); bson_iterator_subiterator( &it, &it2 ); ASSERT( bson_iterator_more( &it2 ) ); ASSERT( bson_iterator_next( &it2 ) == BSON_ARRAY ); ASSERT( bson_iterator_type( &it2 ) == BSON_ARRAY ); ASSERT( !strcmp( bson_iterator_key( &it2 ), "a" ) ); bson_iterator_subiterator( &it2, &it3 ); ASSERT( bson_iterator_more( &it3 ) ); ASSERT( bson_iterator_next( &it3 ) == BSON_BINDATA ); ASSERT( bson_iterator_type( &it3 ) == BSON_BINDATA ); ASSERT( !strcmp( bson_iterator_key( &it3 ), "0" ) ); ASSERT( bson_iterator_bin_type( &it3 ) == 8 ); ASSERT( bson_iterator_bin_len( &it3 ) == 5 ); ASSERT( !memcmp( bson_iterator_bin_data( &it3 ), "w\0rld", 5 ) ); ASSERT( bson_iterator_more( &it3 ) ); ASSERT( bson_iterator_next( &it3 ) == BSON_EOO ); ASSERT( bson_iterator_type( &it3 ) == BSON_EOO ); ASSERT( !bson_iterator_more( &it3 ) ); ASSERT( bson_iterator_more( &it2 ) ); ASSERT( bson_iterator_next( &it2 ) == BSON_EOO ); ASSERT( bson_iterator_type( &it2 ) == BSON_EOO ); ASSERT( !bson_iterator_more( &it2 ) ); ASSERT( bson_iterator_more( &it ) ); ASSERT( bson_iterator_next( &it ) == BSON_UNDEFINED ); ASSERT( bson_iterator_type( &it ) == BSON_UNDEFINED ); ASSERT( !strcmp( bson_iterator_key( &it ), "u" ) ); ASSERT( bson_iterator_more( &it ) ); ASSERT( bson_iterator_next( &it ) == BSON_OID ); ASSERT( bson_iterator_type( &it ) == BSON_OID ); ASSERT( !strcmp( bson_iterator_key( &it ), "oid" ) ); ASSERT( !memcmp( bson_iterator_oid( &it )->bytes, "\x001\x002\x003\x004\x005\x006\x007\x008\x009\x010\x011\x012", 12 ) ); ASSERT( bson_iterator_oid( &it )->ints[0] == oid.ints[0] ); ASSERT( bson_iterator_oid( &it )->ints[1] == oid.ints[1] ); ASSERT( bson_iterator_oid( &it )->ints[2] == oid.ints[2] ); ASSERT( bson_iterator_more( &it ) ); ASSERT( bson_iterator_next( &it ) == BSON_BOOL ); ASSERT( bson_iterator_type( &it ) == BSON_BOOL ); ASSERT( !strcmp( bson_iterator_key( &it ), "b" ) ); ASSERT( bson_iterator_bool( &it ) == 1 ); ASSERT( bson_iterator_more( &it ) ); ASSERT( bson_iterator_next( &it ) == BSON_DATE ); ASSERT( bson_iterator_type( &it ) == BSON_DATE ); ASSERT( !strcmp( bson_iterator_key( &it ), "date" ) ); ASSERT( bson_iterator_date( &it ) == 0x0102030405060708 ); ASSERT( bson_iterator_more( &it ) ); ASSERT( bson_iterator_next( &it ) == BSON_NULL ); ASSERT( bson_iterator_type( &it ) == BSON_NULL ); ASSERT( !strcmp( bson_iterator_key( &it ), "n" ) ); ASSERT( bson_iterator_more( &it ) ); ASSERT( bson_iterator_next( &it ) == BSON_REGEX ); ASSERT( bson_iterator_type( &it ) == BSON_REGEX ); ASSERT( !strcmp( bson_iterator_key( &it ), "r" ) ); ASSERT( !strcmp( bson_iterator_regex( &it ), "^asdf" ) ); ASSERT( !strcmp( bson_iterator_regex_opts( &it ), "imx" ) ); ASSERT( bson_iterator_more( &it ) ); ASSERT( bson_iterator_next( &it ) == BSON_CODE ); ASSERT( bson_iterator_type( &it ) == BSON_CODE ); ASSERT( !strcmp( bson_iterator_code(&it), "function(){}") ); ASSERT( !strcmp( bson_iterator_key( &it ), "c" ) ); ASSERT( !strcmp( bson_iterator_string( &it ), "" ) ); ASSERT( bson_iterator_more( &it ) ); ASSERT( bson_iterator_next( &it ) == BSON_CODE ); ASSERT( bson_iterator_type( &it ) == BSON_CODE ); ASSERT( !strcmp( bson_iterator_key( &it ), "c_n" ) ); ASSERT( !strcmp( bson_iterator_string( &it ), "" ) ); ASSERT( !strcmp( bson_iterator_code( &it ), "function(){}" ) ); ASSERT( bson_iterator_more( &it ) ); ASSERT( bson_iterator_next( &it ) == BSON_SYMBOL ); ASSERT( bson_iterator_type( &it ) == BSON_SYMBOL ); ASSERT( !strcmp( bson_iterator_key( &it ), "symbol" ) ); ASSERT( !strcmp( bson_iterator_string( &it ), "symbol" ) ); ASSERT( bson_iterator_more( &it ) ); ASSERT( bson_iterator_next( &it ) == BSON_SYMBOL ); ASSERT( bson_iterator_type( &it ) == BSON_SYMBOL ); ASSERT( !strcmp( bson_iterator_key( &it ), "symbol_n" ) ); ASSERT( !strcmp( bson_iterator_string( &it ), "symbol" ) ); ASSERT( bson_iterator_more( &it ) ); ASSERT( bson_iterator_next( &it ) == BSON_CODEWSCOPE ); ASSERT( bson_iterator_type( &it ) == BSON_CODEWSCOPE ); ASSERT( !strcmp( bson_iterator_key( &it ), "cws" ) ); ASSERT( !strcmp( bson_iterator_code( &it ), "function(){return i}" ) ); { bson scope; bson_iterator_code_scope( &it, &scope ); bson_iterator_init( &it2, &scope ); ASSERT( bson_iterator_more( &it2 ) ); ASSERT( bson_iterator_next( &it2 ) == BSON_INT ); ASSERT( bson_iterator_type( &it2 ) == BSON_INT ); ASSERT( !strcmp( bson_iterator_key( &it2 ), "i" ) ); ASSERT( bson_iterator_int( &it2 ) == 123 ); ASSERT( bson_iterator_more( &it2 ) ); ASSERT( bson_iterator_next( &it2 ) == BSON_EOO ); ASSERT( bson_iterator_type( &it2 ) == BSON_EOO ); ASSERT( !bson_iterator_more( &it2 ) ); } ASSERT( bson_iterator_more( &it ) ); ASSERT( bson_iterator_next( &it ) == BSON_TIMESTAMP ); ASSERT( bson_iterator_type( &it ) == BSON_TIMESTAMP ); ASSERT( !strcmp( bson_iterator_key( &it ), "timestamp" ) ); ts_result = bson_iterator_timestamp( &it ); ASSERT( ts_result.i == 1 ); ASSERT( ts_result.t == 2 ); ASSERT( bson_iterator_more( &it ) ); ASSERT( bson_iterator_next( &it ) == BSON_LONG ); ASSERT( bson_iterator_type( &it ) == BSON_LONG ); ASSERT( !strcmp( bson_iterator_key( &it ), "l" ) ); ASSERT( bson_iterator_long( &it ) == 0x1122334455667788 ); ASSERT( bson_iterator_more( &it ) ); ASSERT( bson_iterator_next( &it ) == BSON_EOO ); ASSERT( bson_iterator_type( &it ) == BSON_EOO ); ASSERT( !bson_iterator_more( &it ) ); bson_destroy( b ); { bson bsrc[1]; bson_init( bsrc ); bson_append_double( bsrc, "d", 3.14 ); bson_finish( bsrc ); ASSERT( bsrc->err == BSON_VALID ); bson_init( b ); bson_append_double( b, "", 3.14 ); /* test empty name (in general) */ bson_iterator_init( &it, bsrc ); ASSERT( bson_iterator_more( &it ) ); ASSERT( bson_iterator_next( &it ) == BSON_DOUBLE ); ASSERT( bson_iterator_type( &it ) == BSON_DOUBLE ); bson_append_element( b, "d", &it ); bson_append_element( b, 0, &it ); /* test null */ bson_append_element( b, "", &it ); /* test empty name */ bson_finish( b ); ASSERT( b->err == BSON_VALID ); /* bson_print( b ); */ bson_iterator_init( &it, b ); ASSERT( bson_iterator_more( &it ) ); ASSERT( bson_iterator_next( &it ) == BSON_DOUBLE ); ASSERT( !strcmp( bson_iterator_key( &it ), "" ) ); ASSERT( bson_iterator_double( &it ) == 3.14 ); ASSERT( bson_iterator_more( &it ) ); ASSERT( bson_iterator_next( &it ) == BSON_DOUBLE ); ASSERT( !strcmp( bson_iterator_key( &it ), "d" ) ); ASSERT( bson_iterator_double( &it ) == 3.14 ); ASSERT( bson_iterator_more( &it ) ); ASSERT( bson_iterator_next( &it ) == BSON_DOUBLE ); ASSERT( !strcmp( bson_iterator_key( &it ), "d" ) ); ASSERT( bson_iterator_double( &it ) == 3.14 ); ASSERT( bson_iterator_more( &it ) ); ASSERT( bson_iterator_next( &it ) == BSON_DOUBLE ); ASSERT( !strcmp( bson_iterator_key( &it ), "" ) ); ASSERT( bson_iterator_double( &it ) == 3.14 ); ASSERT( bson_iterator_more( &it ) ); ASSERT( bson_iterator_next( &it ) == BSON_EOO ); ASSERT( !bson_iterator_more( &it ) ); bson_destroy( bsrc ); bson_destroy( b ); } return 0; }
Tcl_Obj * mongotcl_bsontolist_raw (Tcl_Interp *interp, Tcl_Obj *listObj, const char *data , int depth) { bson_iterator i; const char *key; bson_timestamp_t ts; char oidhex[25]; bson scope; if (data == NULL) { return listObj; } bson_iterator_from_buffer(&i, data); while (bson_iterator_next (&i)) { bson_type t = bson_iterator_type (&i); if (t == 0) { break; } key = bson_iterator_key (&i); switch (t) { case BSON_DOUBLE: { append_list_type_object (interp, listObj, "double", key, Tcl_NewDoubleObj (bson_iterator_double (&i))); break; } case BSON_STRING: { append_list_type_object (interp, listObj, "string", key, Tcl_NewStringObj (bson_iterator_string (&i), -1)); break; } case BSON_SYMBOL: { append_list_type_object (interp, listObj, "symbol", key, Tcl_NewStringObj (bson_iterator_string (&i), -1)); break; } case BSON_OID: { bson_oid_to_string( bson_iterator_oid( &i ), oidhex ); append_list_type_object (interp, listObj, "oid", key, Tcl_NewStringObj (oidhex, -1)); break; } case BSON_BOOL: { append_list_type_object (interp, listObj, "bool", key, Tcl_NewBooleanObj (bson_iterator_bool (&i))); break; } case BSON_DATE: { append_list_type_object (interp, listObj, "date", key, Tcl_NewLongObj ((long) bson_iterator_date(&i))); break; } case BSON_BINDATA: { unsigned char *bindata = (unsigned char *)bson_iterator_bin_data (&i); int binlen = bson_iterator_bin_len (&i); append_list_type_object (interp, listObj, "bin", key, Tcl_NewByteArrayObj (bindata, binlen)); break; } case BSON_UNDEFINED: { append_list_type_object (interp, listObj, "undefined", key, Tcl_NewObj ()); break; } case BSON_NULL: { append_list_type_object (interp, listObj, "null", key, Tcl_NewObj ()); break; } case BSON_REGEX: { append_list_type_object (interp, listObj, "regex", key, Tcl_NewStringObj (bson_iterator_regex (&i), -1)); break; } case BSON_CODE: { append_list_type_object (interp, listObj, "code", key, Tcl_NewStringObj (bson_iterator_code (&i), -1)); break; } case BSON_CODEWSCOPE: { bson_printf( "BSON_CODE_W_SCOPE: %s", bson_iterator_code( &i ) ); /* bson_init( &scope ); */ /* review - stepped on by bson_iterator_code_scope? */ bson_iterator_code_scope( &i, &scope ); bson_printf( "\n\t SCOPE: " ); bson_print( &scope ); /* bson_destroy( &scope ); */ /* review - causes free error */ break; } case BSON_INT: { append_list_type_object (interp, listObj, "int", key, Tcl_NewIntObj (bson_iterator_int (&i))); break; } case BSON_LONG: { append_list_type_object (interp, listObj, "long", key, Tcl_NewLongObj ((uint64_t)bson_iterator_long (&i))); break; } case BSON_TIMESTAMP: { char string[64]; ts = bson_iterator_timestamp (&i); snprintf(string, sizeof(string), "%d:%d", ts.i, ts.t); append_list_type_object (interp, listObj, "timestamp", key, Tcl_NewStringObj (bson_iterator_string (&i), -1)); break; } case BSON_ARRAY: { Tcl_Obj *subList = Tcl_NewObj (); subList = mongotcl_bsontolist_raw (interp, subList, bson_iterator_value (&i), depth + 1); append_list_type_object (interp, listObj, "array", key, subList); break; } case BSON_OBJECT: { Tcl_Obj *subList = Tcl_NewObj (); subList = mongotcl_bsontolist_raw (interp, subList, bson_iterator_value (&i), depth + 1); append_list_type_object (interp, listObj, "object", key, subList); break; } default: { append_list_type_object (interp, listObj, "unknown", key, Tcl_NewIntObj (t)); break; } } } return listObj; }
INT32 main ( INT32 argc, CHAR **argv ) { // initialize local variables CHAR *pHostName = NULL ; CHAR *pServiceName = NULL ; CHAR *pUsr = NULL ; CHAR *pPasswd = NULL ; // define a connetion handle; use to connect to database sdbConnectionHandle connection = 0 ; // define a collection space handle sdbCSHandle collectionspace = 0 ; // define a collection handle sdbCollectionHandle collection = 0 ; // define a cursor handle for query sdbCursorHandle cursor = 0 ; sdbCursorHandle cursor1 = 0 ; // define local variables // initialize them before use INT32 rc = SDB_OK ; bson obj ; bson rule ; bson record ; bson updatecondition ; bson tmp ; bson_iterator it ; // verify syntax if ( 5 != argc ) { displaySyntax ( (CHAR*)argv[0] ) ; exit ( 0 ) ; } // read argument pHostName = (CHAR*)argv[1] ; pServiceName = (CHAR*)argv[2] ; pUsr = (CHAR*)argv[3] ; pPasswd = (CHAR*)argv[4] ; // connect to database rc = sdbConnect ( pHostName, pServiceName, pUsr, pPasswd, &connection ) ; if( rc!=SDB_OK ) { printf("Failed to connet to database, rc = %d" OSS_NEWLINE, rc ) ; goto error ; } // create collection space rc = sdbCreateCollectionSpace ( connection, COLLECTION_SPACE_NAME, SDB_PAGESIZE_4K, &collectionspace ) ; if( rc!=SDB_OK ) { printf("Failed to create collection space, rc = %d" OSS_NEWLINE, rc ) ; goto error ; } // create collection in a specified colletion space. rc = sdbCreateCollection ( collectionspace, COLLECTION_NAME, &collection ) ; if( rc!=SDB_OK ) { printf("Failed to create collection, rc = %d" OSS_NEWLINE, rc ) ; goto error ; } // prepare record bson_init( &record ) ; bson_append_int( &record, "age", 10 ) ; rc = bson_finish( &record ) ; CHECK_RC ( rc, "Failed to build bson" ) ; // insert record into database rc = sdbInsert( collection, &record ) ; if( rc!=SDB_OK ) { printf("Failed to insert, rc = %d" OSS_NEWLINE, rc ) ; goto error ; } bson_destroy( &record ) ; // query all the record in this collection rc = sdbQuery(collection, NULL, NULL, NULL, NULL, 0, -1, &cursor ) ; if( rc!=SDB_OK ) { printf("Failed to query, rc = %d" OSS_NEWLINE, rc ) ; goto error ; } // get the record from cursor bson_init(&obj) ; bson_init(&tmp) ; rc=sdbNext( cursor, &obj ) ; if ( rc!= SDB_OK ) { printf("Failed to get next, rc = %d" OSS_NEWLINE, rc ) ; goto error ; } rc = bson_copy( &tmp, &obj ) ; CHECK_RC ( rc, "Failed to copy bson" ) ; printf("Before update, the record is:\n") ; bson_print( &tmp ) ; // set the update condition using "_id" bson_find( &it, &obj, "_id" ) ; bson_init( &updatecondition ) ; bson_append_element( &updatecondition, NULL, &it ) ; rc = bson_finish( &updatecondition ) ; CHECK_RC ( rc, "Failed to build bson" ) ; // set the update rule bson_init( &rule ) ; bson_append_start_object ( &rule, "$set" ) ; bson_append_int ( &rule, "age", 99 ) ; bson_append_finish_object ( &rule ) ; rc = bson_finish ( &rule ) ; CHECK_RC ( rc, "Failed to build bson" ) ; // update rc = sdbUpdate(collection, &rule, &updatecondition, NULL ) ; if ( rc!=SDB_OK ) { printf("Failed to update, rc = %d" OSS_NEWLINE, rc ) ; goto error ; } bson_destroy(&obj) ; bson_destroy(&rule) ; bson_destroy(&updatecondition) ; // query all the record in this collection again rc = sdbQuery(collection, NULL, NULL, NULL, NULL, 0, -1, &cursor1 ) ; if( rc!=SDB_OK ) { printf("Failed to query, rc = %d" OSS_NEWLINE, rc ) ; goto error ; } // get record from cursor1 bson_init(&obj) ; rc=sdbNext( cursor1, &obj ) ; if ( rc!= SDB_OK ) { printf("Failed to get next, rc = %d" OSS_NEWLINE, rc ) ; goto error ; } printf("after update, the record is:\n") ; bson_print( &obj ) ; bson_destroy(&obj) ; done: // drop collection space rc = sdbDropCollectionSpace( connection, COLLECTION_SPACE_NAME ) ; if ( rc != SDB_OK ) { printf("Failed to drop collection space, rc = %d" OSS_NEWLINE, rc ) ; } // disconnect the connection sdbDisconnect ( connection ) ; // release the local variables sdbReleaseCursor ( cursor ) ; sdbReleaseCursor ( cursor1 ) ; sdbReleaseCollection ( collection ) ; sdbReleaseCS ( collectionspace ) ; sdbReleaseConnection ( connection ) ; return 0; error: goto done ; }
int main(int argc, char **argv) { bson b[1]; bson query[1]; mongo conn[1]; mongo_cursor cursor[1]; int result; if(mongo_client(conn, "127.0.0.1", 27017) != MONGO_OK) { switch(conn->err) { case MONGO_CONN_SUCCESS: fprintf(stderr, "OK: Connected to MongoDB!\n"); break; case MONGO_CONN_NO_SOCKET: fprintf(stderr, "FAIL: Cloud not create a socket!\n"); break; case MONGO_CONN_FAIL: fprintf(stderr, "FAIL: Could not connect to mongod!."); break; default: fprintf(stderr, "MongoDB connection error number: %d.\n", conn->err); } } bson_init(query); bson_append_string(query, "city_name", "南京"); bson_finish(query); mongo_cursor_init(cursor, conn, "bangboox.city_shop"); mongo_cursor_set_query(cursor, query); while(mongo_cursor_next(cursor) == MONGO_OK) { bson_print((bson *)mongo_cursor_bson(cursor)); } bson_init(b); bson_append_new_oid(b, "_id"); bson_append_new_oid(b, "record_id"); bson_append_start_array(b, "items"); bson_append_start_object(b, "0"); bson_append_string(b, "name", "roy.lieu"); bson_append_int(b, "age", 30); bson_append_finish_object(b); bson_append_start_object(b, "1"); bson_append_string(b, "name", "jimmy.chen"); bson_append_int(b, "age", 35); bson_append_finish_object(b); bson_append_finish_object(b); bson_append_start_object(b, "address"); bson_append_string(b, "stree", "Jufeng RD."); bson_append_int(b, "zip", 232044); bson_append_finish_object(b); bson_finish(b); //printf("\n\n"); //bson_print(b); if(mongo_insert(conn, "test.record", b, NULL) != MONGO_OK) { fprintf(stderr, "FAIL: Failed to insert document whth err: %d\n", conn->err); } return 0; }
static void on_data(uvmongo_t * m, bson * res, void * privdata) { bson_print(res); }
INT32 main ( INT32 argc, CHAR **argv ) { // initialize local variables CHAR *pHostName = NULL ; CHAR *pServiceName = NULL ; CHAR *pUsr = NULL ; CHAR *pPasswd = NULL ; // define a connetion handle; use to connect to database sdbConnectionHandle connection = 0 ; // define a collection space handle sdbCSHandle collectionspace = 0 ; // define a collection handle sdbCollectionHandle collection = 0 ; // define a cursor handle for query sdbCursorHandle cursor = 0 ; // define local variables // initialize them before use bson obj ; bson rule ; bson condition ; INT32 rc = SDB_OK ; // read argument pHostName = (CHAR*)argv[1] ; pServiceName = (CHAR*)argv[2] ; pUsr = (CHAR*)argv[3] ; pPasswd = (CHAR*)argv[4] ; // verify syntax if ( 5 != argc ) { displaySyntax ( (CHAR*)argv[0] ) ; exit ( 0 ) ; } // connect to database rc = sdbConnect ( pHostName, pServiceName, pUsr, pPasswd, &connection ) ; if( rc!=SDB_OK ) { printf("Failed to connet to database, rc = %d" OSS_NEWLINE, rc ) ; goto error ; } // create collection space rc = sdbCreateCollectionSpace ( connection, COLLECTION_SPACE_NAME, SDB_PAGESIZE_4K, &collectionspace ) ; if( rc!=SDB_OK ) { printf("Failed to create collection space, rc = %d" OSS_NEWLINE, rc ) ; goto error ; } // create collection in a specified colletion space. rc = sdbCreateCollection ( collectionspace, COLLECTION_NAME, &collection ) ; if( rc!=SDB_OK ) { printf("Failed to create collection, rc = %d" OSS_NEWLINE, rc ) ; goto error ; } // insert records to the collection bson_init( &obj ) ; // insert a English record createEnglishRecord ( &obj ) ; rc = sdbInsert ( collection, &obj ) ; if ( rc ) { printf ( "Failed to insert record, rc = %d" OSS_NEWLINE, rc ) ; } bson_destroy ( &obj ) ; // query the records // the result is in the cursor handle rc = sdbQuery(collection, NULL, NULL, NULL, NULL, 0, -1, &cursor ) ; if( rc!=SDB_OK ) { printf("Failed to query, rc = %d" OSS_NEWLINE, rc ) ; goto error ; } // update the record // let's set the rule and query condition first // here,we make the condition to be NULL // so all the records will be update bson_init( &rule ) ; bson_append_start_object ( &rule, "$set" ) ; bson_append_start_object ( &rule, "dev_id" ) ; bson_append_binary ( &rule, "id_rand", BSON_BIN_BINARY, "a", 1 ) ; bson_append_start_object ( &rule, "id_s" ) ; bson_append_int ( &rule, "year", 2005 ) ; bson_append_int ( &rule, "mon", 11 ) ; bson_append_int ( &rule, "day", 10 ) ; bson_append_int ( &rule, "num", 1024 ) ; bson_append_finish_object ( &rule ) ; //bson_append_binary ( &rule, "id_rand", BSON_BIN_BINARY, "a", 1 ) ; bson_append_finish_object ( &rule ) ; bson_append_finish_object ( &rule ) ; rc = bson_finish ( &rule ) ; CHECK_RC ( rc, "Failed to build bson" ) ; printf("The update rule is:") ; bson_print( &rule ) ; bson_init ( &condition ) ; bson_append_start_object ( &condition, "dev_id.id_s" ) ; bson_append_int ( &condition, "year", 2007 ) ; bson_append_int ( &condition, "mon", 11 ) ; bson_append_int ( &condition, "day", 10 ) ; bson_append_int ( &condition, "num", 1024 ) ; bson_append_finish_object ( &condition ) ; rc = bson_finish ( &condition ) ; CHECK_RC ( rc, "Failed to build bson" ) ; rc = sdbUpsert( collection, &rule, &condition, NULL ) ; if( rc!=SDB_OK ) { printf("Failed to update the record, rc = %d" OSS_NEWLINE, rc ) ; goto error ; } bson_destroy(&rule); printf("Success to update!" OSS_NEWLINE ) ; done: // drop collection space rc = sdbDropCollectionSpace( connection, COLLECTION_SPACE_NAME ) ; if ( rc != SDB_OK ) { printf("Failed to drop the specified collection,\ rc = %d" OSS_NEWLINE, rc ) ; }
INT32 main ( INT32 argc, CHAR **argv ) { // initialize local variables CHAR *pHostName = NULL ; CHAR *pServiceName = NULL ; CHAR *pUsr = NULL ; CHAR *pPasswd = NULL ; // define a connetion handle; use to connect to database sdbConnectionHandle connection = 0 ; // define a collection space handle sdbCSHandle collectionspace = 0 ; // define a collection handle sdbCollectionHandle collection = 0 ; // define a cursor handle for query sdbCursorHandle cursor = 0 ; // define local variables // initialize them before use bson obj ; bson rule ; INT32 rc = SDB_OK ; // read argument pHostName = (CHAR*)argv[1] ; pServiceName = (CHAR*)argv[2] ; pUsr = (CHAR*)argv[3] ; pPasswd = (CHAR*)argv[4] ; // verify syntax if ( 5 != argc ) { displaySyntax ( (CHAR*)argv[0] ) ; exit ( 0 ) ; } // connect to database rc = sdbConnect ( pHostName, pServiceName, pUsr, pPasswd, &connection ) ; CHECK_RC ( rc, "Failed to connet to database" ) ; // create collection space rc = sdbCreateCollectionSpace ( connection, COLLECTION_SPACE_NAME, SDB_PAGESIZE_4K, &collectionspace ) ; CHECK_RC ( rc, "Failed to create collection space" ) ; // create collection in a specified colletion space. rc = sdbCreateCollection ( collectionspace, COLLECTION_NAME, &collection ) ; CHECK_RC ( rc, "Failed to create collection" ) ; // insert records to the collection bson_init ( &obj ) ; // build a English record createEnglishRecord ( &obj ) ; // insert rc = sdbInsert ( collection, &obj ) ; CHECK_RC ( rc, "Failed to insert record" ) ; // query the records // the result is in the cursor handle rc = sdbQuery(collection, NULL, NULL, NULL, NULL, 0, -1, &cursor ) ; CHECK_RC ( rc, "Failed to query" ) ; // update the record // let's set the rule and query condition first // here,we make the condition to be NULL // so all the records will be update bson_init ( &rule ) ; bson_append_start_object ( &rule, "$set" ) ; bson_append_int ( &rule, "age", 19 ) ; bson_append_finish_object ( &rule ) ; bson_finish ( &rule ) ; CHECK_RC ( rc, "Failed to build bson" ) ; printf ( "The update rule is:" ) ; bson_print( &rule ) ; // update rc = sdbUpdate ( collection, &rule, NULL, NULL ) ; CHECK_RC ( rc, "Failed to update the record" ) ; // free memory after finish using bson bson_destroy ( &rule ) ; printf ( "Success to update!" OSS_NEWLINE ) ; // drop the specified collection rc = sdbDropCollection ( collectionspace,COLLECTION_NAME ) ; CHECK_RC ( rc, "Failed to drop the specified collection" ) ; // drop the specified collection space rc = sdbDropCollectionSpace ( connection,COLLECTION_SPACE_NAME ) ; CHECK_RC ( rc, "Failed to drop the specified collection" ) ; done: // disconnect the connection sdbDisconnect ( connection ) ; // release the local variables sdbReleaseCursor ( cursor ) ; sdbReleaseCollection ( collection ) ; sdbReleaseCS ( collectionspace ) ; sdbReleaseConnection ( connection ) ; return 0; error: goto done ; }
INT32 main ( INT32 argc, CHAR **argv ) { // initialize local variables CHAR *pHostName = NULL ; CHAR *pServiceName = NULL ; CHAR *pUsr = NULL ; CHAR *pPasswd = NULL ; // define a connetion handle; use to connect to database sdbConnectionHandle connection = 0 ; // define a collection space handle sdbCSHandle collectionspace = 0 ; // define a collection handle sdbCollectionHandle collection = 0 ; // define a cursor handle for query sdbCursorHandle cursor = 0 ; // define local variables // initialize them before use INT32 rc = SDB_OK ; INT32 count = 0 ; bson obj ; bson rule ; bson objList [ NUM_RECORD ] ; // verify syntax if ( 5 != argc ) { displaySyntax ( (CHAR*)argv[0] ) ; exit ( 0 ) ; } // read argument pHostName = (CHAR*)argv[1] ; pServiceName = (CHAR*)argv[2] ; pUsr = (CHAR*)argv[3] ; pPasswd = (CHAR*)argv[4] ; // connect to database rc = sdbConnect ( pHostName, pServiceName, pUsr, pPasswd, &connection ) ; CHECK_RC ( rc, "Failed to connet to database" ) ; // create collection space rc = sdbCreateCollectionSpace ( connection, COLLECTION_SPACE_NAME, SDB_PAGESIZE_4K, &collectionspace ) ; CHECK_RC ( rc, "Failed to create collection space" ) ; // create collection in a specified colletion space. // Here,we build it up in the new collection. rc = sdbCreateCollection ( collectionspace, COLLECTION_NAME, &collection ) ; CHECK_RC ( rc, "Failed to create collection" ) ; // create record list using objList createRecordList ( &objList[0], NUM_RECORD ) ; // insert obj and free memory that allocated by createRecordList for ( count = 0; count < NUM_RECORD; count++ ) { // all the contents of inserted record are the same except _id rc = sdbInsert ( collection, &objList[count] ) ; if ( rc ) { printf ( "Failed to insert record, rc = %d" OSS_NEWLINE, rc ) ; } bson_destroy ( &objList[count] ) ; } // query all the record in this collection // and return the result by the cursor handle rc = sdbQuery(collection, NULL, NULL, NULL, NULL, 0, -1, &cursor ) ; CHECK_RC ( rc, "Failed to query" ) ; // get all the qureied records bson_init(&obj); while( !( rc=sdbNext( cursor, &obj ) ) ) { bson_print( &obj ) ; bson_destroy(&obj) ; bson_init(&obj); } bson_destroy(&obj) ; if( rc==SDB_DMS_EOC ) { printf("All the record had been list." OSS_NEWLINE ) ; } else if( rc!=SDB_OK ) { CHECK_RC ( rc, "Failed to get the record" ) ; } // drop the specified collection rc = sdbDropCollection( collectionspace,COLLECTION_NAME ) ; CHECK_RC ( rc, "Failed to drop the specified collection" ) ; // drop the specified collection space rc = sdbDropCollectionSpace( connection,COLLECTION_SPACE_NAME ) ; CHECK_RC ( rc, "Failed to drop the specified collection space" ) ; done: // disconnect the connection sdbDisconnect ( connection ) ; // release the local variables sdbReleaseCursor ( cursor ) ; sdbReleaseCollection ( collection ) ; sdbReleaseCS ( collectionspace ) ; sdbReleaseConnection ( connection ) ; return 0; error: goto done ; }
int main(){ bson_buffer bb; bson b; bson_iterator it, it2, it3; bson_oid_t oid; bson_timestamp_t ts; bson_timestamp_t ts_result; ts.i = 1; ts.t = 2; bson_buffer_init(&bb); bson_append_double(&bb, "d", 3.14); bson_append_string(&bb, "s", "hello"); bson_append_string_n(&bb, "s_n", "goodbye cruel world", 7); { bson_buffer *obj = bson_append_start_object(&bb, "o"); bson_buffer *arr = bson_append_start_array(obj, "a"); bson_append_binary(arr, "0", 8, "w\0rld", 5); bson_append_finish_object(arr); bson_append_finish_object(obj); } bson_append_undefined(&bb, "u"); bson_oid_from_string(&oid, "010203040506070809101112"); ASSERT(!memcmp(oid.bytes, "\x001\x002\x003\x004\x005\x006\x007\x008\x009\x010\x011\x012", 12)); bson_append_oid(&bb, "oid", &oid); bson_append_bool(&bb, "b", 1); bson_append_date(&bb, "date", 0x0102030405060708); bson_append_null(&bb, "n"); bson_append_regex(&bb, "r", "^asdf", "imx"); /* no dbref test (deprecated) */ bson_append_code(&bb, "c", "function(){}"); bson_append_code_n(&bb, "c_n", "function(){}garbage", 12); bson_append_symbol(&bb, "symbol", "SYMBOL"); bson_append_symbol_n(&bb, "symbol_n", "SYMBOL and garbage", 6); { bson_buffer scope_buf; bson scope; bson_buffer_init(&scope_buf); bson_append_int(&scope_buf, "i", 123); bson_from_buffer(&scope, &scope_buf); bson_append_code_w_scope(&bb, "cws", "function(){return i}", &scope); bson_destroy(&scope); } bson_append_timestamp(&bb, "timestamp", &ts); bson_append_long(&bb, "l", 0x1122334455667788); bson_from_buffer(&b, &bb); bson_print(&b); bson_iterator_init(&it, b.data); ASSERT(bson_iterator_more(&it)); ASSERT(bson_iterator_next(&it) == bson_double); ASSERT(bson_iterator_type(&it) == bson_double); ASSERT(!strcmp(bson_iterator_key(&it), "d")); ASSERT(bson_iterator_double(&it) == 3.14); ASSERT(bson_iterator_more(&it)); ASSERT(bson_iterator_next(&it) == bson_string); ASSERT(bson_iterator_type(&it) == bson_string); ASSERT(!strcmp(bson_iterator_key(&it), "s")); ASSERT(!strcmp(bson_iterator_string(&it), "hello")); ASSERT(bson_iterator_more(&it)); ASSERT(bson_iterator_next(&it) == bson_string); ASSERT(bson_iterator_type(&it) == bson_string); ASSERT(!strcmp(bson_iterator_key(&it), "s_n")); ASSERT(!strcmp(bson_iterator_string(&it), "goodbye")); ASSERT(bson_iterator_more(&it)); ASSERT(bson_iterator_next(&it) == bson_object); ASSERT(bson_iterator_type(&it) == bson_object); ASSERT(!strcmp(bson_iterator_key(&it), "o")); bson_iterator_subiterator(&it, &it2); ASSERT(bson_iterator_more(&it2)); ASSERT(bson_iterator_next(&it2) == bson_array); ASSERT(bson_iterator_type(&it2) == bson_array); ASSERT(!strcmp(bson_iterator_key(&it2), "a")); bson_iterator_subiterator(&it2, &it3); ASSERT(bson_iterator_more(&it3)); ASSERT(bson_iterator_next(&it3) == bson_bindata); ASSERT(bson_iterator_type(&it3) == bson_bindata); ASSERT(!strcmp(bson_iterator_key(&it3), "0")); ASSERT(bson_iterator_bin_type(&it3) == 8); ASSERT(bson_iterator_bin_len(&it3) == 5); ASSERT(!memcmp(bson_iterator_bin_data(&it3), "w\0rld", 5)); ASSERT(bson_iterator_more(&it3)); ASSERT(bson_iterator_next(&it3) == bson_eoo); ASSERT(bson_iterator_type(&it3) == bson_eoo); ASSERT(!bson_iterator_more(&it3)); ASSERT(bson_iterator_more(&it2)); ASSERT(bson_iterator_next(&it2) == bson_eoo); ASSERT(bson_iterator_type(&it2) == bson_eoo); ASSERT(!bson_iterator_more(&it2)); ASSERT(bson_iterator_more(&it)); ASSERT(bson_iterator_next(&it) == bson_undefined); ASSERT(bson_iterator_type(&it) == bson_undefined); ASSERT(!strcmp(bson_iterator_key(&it), "u")); ASSERT(bson_iterator_more(&it)); ASSERT(bson_iterator_next(&it) == bson_oid); ASSERT(bson_iterator_type(&it) == bson_oid); ASSERT(!strcmp(bson_iterator_key(&it), "oid")); ASSERT(!memcmp(bson_iterator_oid(&it)->bytes, "\x001\x002\x003\x004\x005\x006\x007\x008\x009\x010\x011\x012", 12)); ASSERT(bson_iterator_oid(&it)->ints[0] == oid.ints[0]); ASSERT(bson_iterator_oid(&it)->ints[1] == oid.ints[1]); ASSERT(bson_iterator_oid(&it)->ints[2] == oid.ints[2]); ASSERT(bson_iterator_more(&it)); ASSERT(bson_iterator_next(&it) == bson_bool); ASSERT(bson_iterator_type(&it) == bson_bool); ASSERT(!strcmp(bson_iterator_key(&it), "b")); ASSERT(bson_iterator_bool(&it) == 1); ASSERT(bson_iterator_more(&it)); ASSERT(bson_iterator_next(&it) == bson_date); ASSERT(bson_iterator_type(&it) == bson_date); ASSERT(!strcmp(bson_iterator_key(&it), "date")); ASSERT(bson_iterator_date(&it) == 0x0102030405060708); ASSERT(bson_iterator_more(&it)); ASSERT(bson_iterator_next(&it) == bson_null); ASSERT(bson_iterator_type(&it) == bson_null); ASSERT(!strcmp(bson_iterator_key(&it), "n")); ASSERT(bson_iterator_more(&it)); ASSERT(bson_iterator_next(&it) == bson_regex); ASSERT(bson_iterator_type(&it) == bson_regex); ASSERT(!strcmp(bson_iterator_key(&it), "r")); ASSERT(!strcmp(bson_iterator_regex(&it), "^asdf")); ASSERT(!strcmp(bson_iterator_regex_opts(&it), "imx")); ASSERT(bson_iterator_more(&it)); ASSERT(bson_iterator_next(&it) == bson_code); ASSERT(bson_iterator_type(&it) == bson_code); ASSERT(!strcmp(bson_iterator_key(&it), "c")); ASSERT(!strcmp(bson_iterator_string(&it), "function(){}")); ASSERT(!strcmp(bson_iterator_code(&it), "function(){}")); ASSERT(bson_iterator_more(&it)); ASSERT(bson_iterator_next(&it) == bson_code); ASSERT(bson_iterator_type(&it) == bson_code); ASSERT(!strcmp(bson_iterator_key(&it), "c_n")); ASSERT(!strcmp(bson_iterator_string(&it), "function(){}")); ASSERT(!strcmp(bson_iterator_code(&it), "function(){}")); ASSERT(bson_iterator_more(&it)); ASSERT(bson_iterator_next(&it) == bson_symbol); ASSERT(bson_iterator_type(&it) == bson_symbol); ASSERT(!strcmp(bson_iterator_key(&it), "symbol")); ASSERT(!strcmp(bson_iterator_string(&it), "SYMBOL")); ASSERT(bson_iterator_more(&it)); ASSERT(bson_iterator_next(&it) == bson_symbol); ASSERT(bson_iterator_type(&it) == bson_symbol); ASSERT(!strcmp(bson_iterator_key(&it), "symbol_n")); ASSERT(!strcmp(bson_iterator_string(&it), "SYMBOL")); ASSERT(bson_iterator_more(&it)); ASSERT(bson_iterator_next(&it) == bson_codewscope); ASSERT(bson_iterator_type(&it) == bson_codewscope); ASSERT(!strcmp(bson_iterator_key(&it), "cws")); ASSERT(!strcmp(bson_iterator_code(&it), "function(){return i}")); { bson scope; bson_iterator_code_scope(&it, &scope); bson_iterator_init(&it2, scope.data); ASSERT(bson_iterator_more(&it2)); ASSERT(bson_iterator_next(&it2) == bson_int); ASSERT(bson_iterator_type(&it2) == bson_int); ASSERT(!strcmp(bson_iterator_key(&it2), "i")); ASSERT(bson_iterator_int(&it2) == 123); ASSERT(bson_iterator_more(&it2)); ASSERT(bson_iterator_next(&it2) == bson_eoo); ASSERT(bson_iterator_type(&it2) == bson_eoo); ASSERT(!bson_iterator_more(&it2)); } ASSERT(bson_iterator_more(&it)); ASSERT(bson_iterator_next(&it) == bson_timestamp); ASSERT(bson_iterator_type(&it) == bson_timestamp); ASSERT(!strcmp(bson_iterator_key(&it), "timestamp")); ts_result = bson_iterator_timestamp(&it); ASSERT( ts_result.i == 1 ); ASSERT( ts_result.t == 2); ASSERT(bson_iterator_more(&it)); ASSERT(bson_iterator_next(&it) == bson_long); ASSERT(bson_iterator_type(&it) == bson_long); ASSERT(!strcmp(bson_iterator_key(&it), "l")); ASSERT(bson_iterator_long(&it) == 0x1122334455667788); ASSERT(bson_iterator_more(&it)); ASSERT(bson_iterator_next(&it) == bson_eoo); ASSERT(bson_iterator_type(&it) == bson_eoo); ASSERT(!bson_iterator_more(&it)); return 0; }
int main() { bson b, sub, out; bson_iterator it; mongo conn; mongo_cursor cursor; int result; /* Create a rich document like this one: * * { _id: ObjectId("4d95ea712b752328eb2fc2cc"), * user_id: ObjectId("4d95ea712b752328eb2fc2cd"), * * items: [ * { sku: "col-123", * name: "John Coltrane: Impressions", * price: 1099, * }, * * { sku: "young-456", * name: "Larry Young: Unity", * price: 1199 * } * ], * * address: { * street: "59 18th St.", * zip: 10010 * }, * * total: 2298 * } */ bson_init( &b ); bson_append_new_oid( &b, "_id" ); bson_append_new_oid( &b, "user_id" ); bson_append_start_array( &b, "items" ); bson_append_start_object( &b, "0" ); bson_append_string( &b, "name", "John Coltrane: Impressions" ); bson_append_int( &b, "price", 1099 ); bson_append_finish_object( &b ); bson_append_start_object( &b, "1" ); bson_append_string( &b, "name", "Larry Young: Unity" ); bson_append_int( &b, "price", 1199 ); bson_append_finish_object( &b ); bson_append_finish_object( &b ); bson_append_start_object( &b, "address" ); bson_append_string( &b, "street", "59 18th St." ); bson_append_int( &b, "zip", 10010 ); bson_append_finish_object( &b ); bson_append_int( &b, "total", 2298 ); /* Finish the BSON obj. */ bson_finish( &b ); printf("Here's the whole BSON object:\n"); bson_print( &b ); /* Advance to the 'items' array */ bson_find( &it, &b, "items" ); /* Get the subobject representing items */ bson_iterator_subobject_init( &it, &sub, 0 ); /* Now iterate that object */ printf("And here's the inner sub-object by itself.\n"); bson_print( &sub ); bson_destroy( &sub ); /* Now make a connection to MongoDB. */ if( mongo_client( &conn, "127.0.0.1", 27017 ) != MONGO_OK ) { switch( conn.err ) { case MONGO_CONN_SUCCESS: break; case MONGO_CONN_NO_SOCKET: printf( "FAIL: Could not create a socket!\n" ); break; case MONGO_CONN_FAIL: printf( "FAIL: Could not connect to mongod. Make sure it's listening at 127.0.0.1:27017.\n" ); break; default: printf( "MongoDB connection error number %d.\n", conn.err ); break; } exit( 1 ); } /* Insert the sample BSON document. */ if( mongo_insert( &conn, "test.records", &b, NULL ) != MONGO_OK ) { printf( "FAIL: Failed to insert document with error %d\n", conn.err ); exit( 1 ); } /* Query for the sample document. */ mongo_cursor_init( &cursor, &conn, "test.records" ); mongo_cursor_set_query( &cursor, bson_shared_empty() ); if( mongo_cursor_next( &cursor ) != MONGO_OK ) { printf( "FAIL: Failed to find inserted document." ); exit( 1 ); } printf( "Found saved BSON object:\n" ); bson_print( (bson *)mongo_cursor_bson( &cursor ) ); mongo_cmd_drop_collection( &conn, "test", "records", NULL ); mongo_cursor_destroy( &cursor ); bson_destroy( &b ); mongo_destroy( &conn ); return 0; }
int bson_print(FILE* stream, struct bson_info* bson) { struct bson_info* embedded; struct bson_kv v1; struct bson_kv v2; time_t utctime; fprintf(stream, "{\n"); while (bson_deserialize(bson, &v1, &v2) == 1) { fprintf(stream, "\t'%s' : ", v1.key); switch (v1.type) { case BSON_DOUBLE: fprintf(stream, "[BSON_DOUBLE] %f\n", *((double *) v1.data)); break; case BSON_STRING: fprintf(stream, "[BSON_STRING, %"PRIu32"] '", v1.size); fwrite((uint8_t *) v1.data, v1.size, 1, stream); fprintf(stream, "'\n"); break; case BSON_EMBEDDED_DOCUMENT: fprintf(stream, "[BSON_EMBEDDED_DOCUMENT] \n"); break; case BSON_ARRAY: fprintf(stream, "[BSON_ARRAY] "); embedded = bson_init(); embedded->buffer = malloc(v2.size); memcpy(embedded->buffer, v2.data, v2.size); bson_make_readable(embedded); bson_print(stream, embedded); bson_cleanup(embedded); break; case BSON_BINARY: fprintf(stream, "[BSON_BINARY, %"PRIu32"] ", v1.size); hexdump((uint8_t *) v1.data, v1.size); break; case BSON_UNDEFINED: fprintf(stream, "[BSON_UNDEFINED] \n"); break; case BSON_OBJECTID: fprintf(stream, "[BSON_OBJECTID] \n"); break; case BSON_BOOLEAN: fprintf(stream, "[BSON_BOOLEAN] "); if (*((uint8_t *) v1.data)) fprintf(stream, "true\n"); else fprintf(stream, "false\n"); break; case BSON_UTC_DATETIME: fprintf(stream, "[BSON_UTC_DATETIME] "); utctime = *((int64_t *) v1.data) / 1000; fprintf(stream, "%s\n", asctime(gmtime(&utctime))); break; case BSON_NULL: fprintf(stream, "[BSON_NULL] \n"); break; case BSON_REGEX: fprintf(stream, "[BSON_REGEX] \n"); break; case BSON_DBPOINTER: fprintf(stream, "[BSON_DBPOINTER] \n"); break; case BSON_JS: fprintf(stream, "[BSON_JS] \n"); break; case BSON_SYMBOL: fprintf(stream, "[BSON_SYMBOL] \n"); break; case BSON_JS_CODE: fprintf(stream, "[BSON_JS_CODE] \n"); break; case BSON_INT32: fprintf(stream, "[BSON_INT32] %"PRId32"\n", *((int32_t *) v1.data)); break; case BSON_TIMESTAMP: fprintf(stream, "[BSON_TIMESTAMP] \n"); break; case BSON_INT64: fprintf(stream, "[BSON_INT64] %"PRId64"\n", *((int64_t *) v1.data)); break; case BSON_MIN: fprintf(stream, "[BSON_MIN] \n"); break; case BSON_MAX: fprintf(stream, "[BSON_MAX] \n"); break; default: fprintf(stream, "\t'%s' : print not implemented\n", v1.key); break; }; } fprintf (stream, "}\n"); return EXIT_SUCCESS; }
void bson_print_raw( const char *data , int depth ) { bson_iterator i; const char *key; int temp; bson_timestamp_t ts; char oidhex[25]; bson scope; bson_iterator_from_buffer( &i, data ); while ( bson_iterator_next( &i ) ) { bson_type t = bson_iterator_type( &i ); if ( t == 0 ) break; key = bson_iterator_key( &i ); for ( temp=0; temp<=depth; temp++ ) printf( "\t" ); bson_printf( "%s : %d \t " , key , t ); switch ( t ) { case BSON_DOUBLE: printf( "%f" , bson_iterator_double( &i ) ); break; case BSON_STRING: printf( "%s" , bson_iterator_string( &i ) ); break; case BSON_SYMBOL: printf( "SYMBOL: %s" , bson_iterator_string( &i ) ); break; case BSON_OID: bson_oid_to_string( bson_iterator_oid( &i ), oidhex ); printf( "%s" , oidhex ); break; case BSON_BOOL: printf( "%s" , bson_iterator_bool( &i ) ? "true" : "false" ); break; case BSON_DATE: printf( "%ld" , ( long int )bson_iterator_date( &i ) ); break; case BSON_BINDATA: printf( "BSON_BINDATA" ); break; case BSON_UNDEFINED: printf( "BSON_UNDEFINED" ); break; case BSON_NULL: printf( "BSON_NULL" ); break; case BSON_REGEX: printf( "BSON_REGEX: %s", bson_iterator_regex( &i ) ); break; case BSON_CODE: printf( "BSON_CODE: %s", bson_iterator_code( &i ) ); break; case BSON_CODEWSCOPE: printf( "BSON_CODE_W_SCOPE: %s", bson_iterator_code( &i ) ); bson_init( &scope ); bson_iterator_code_scope( &i, &scope ); printf( "\n\t SCOPE: " ); bson_print( &scope ); break; case BSON_INT: printf( "%d" , bson_iterator_int( &i ) ); break; case BSON_LONG: printf( "%lld" , ( long long int )bson_iterator_long( &i ) ); break; case BSON_TIMESTAMP: ts = bson_iterator_timestamp( &i ); printf( "i: %d, t: %d", ts.i, ts.t ); break; case BSON_OBJECT: case BSON_ARRAY: printf( "\n" ); bson_print_raw( bson_iterator_value( &i ) , depth + 1 ); break; default: bson_errprintf( "can't print type : %d\n" , t ); } printf( "\n" ); } }
int main(int argc, char **argv) { bson b, sub; bson_iterator it; /* Create a rich document like this one: * * { _id: ObjectId("4d95ea712b752328eb2fc2cc"), * user_id: ObjectId("4d95ea712b752328eb2fc2cd"), * * items: [ * { sku: "col-123", * name: "John Coltrane: Impressions", * price: 1099, * }, * * { sku: "young-456", * name: "Larry Young: Unity", * price: 1199 * } * ], * * address: { * street: "59 18th St.", * zip: 10010 * }, * * total: 2298 * } */ bson_init( &b ); bson_append_new_oid( &b, "_id" ); bson_append_new_oid( &b, "user_id" ); bson_append_start_array( &b, "items" ); bson_append_start_object( &b, "0" ); bson_append_string( &b, "name", "John Coltrane: Impressions" ); bson_append_int( &b, "price", 1099 ); bson_append_finish_object( &b ); bson_append_start_object( &b, "1" ); bson_append_string( &b, "name", "Larry Young: Unity" ); bson_append_int( &b, "price", 1199 ); bson_append_finish_object( &b ); bson_append_finish_object( &b ); bson_append_start_object( &b, "address" ); bson_append_string( &b, "street", "59 18th St." ); bson_append_int( &b, "zip", 10010 ); bson_append_finish_object( &b ); bson_append_int( &b, "total", 2298 ); bson_finish( &b ); /* Advance to the 'items' array */ bson_find( &it, &b, "items" ); /* Get the subobject representing items */ bson_iterator_subobject_init( &it, &sub, 0 ); /* Now iterate that object */ bson_print( &sub ); bson_destroy( &b ); return 0; }