int mongo_simple_str_command(mongo_connection * conn, const char * db, const char* cmdstr, const char* arg, bson * realout) { bson out; bson cmd; bson_buffer bb; int success = 0; bson_buffer_init(&bb); bson_append_string(&bb, cmdstr, arg); bson_from_buffer(&cmd, &bb); if( mongo_run_command(conn, db, &cmd, &out) == MONGO_OK ) { bson_iterator it; if(bson_find(&it, &out, "ok")) success = bson_iterator_bool(&it); } bson_destroy(&cmd); if (realout) *realout = out; else bson_destroy(&out); if(success) return MONGO_OK; else return MONGO_ERROR; }
/* Find out whether the current connected node is master, and * verify that the node's replica set name matched the provided name */ static int mongo_replset_check_host( mongo *conn ) { bson out; bson_iterator it; bson_bool_t ismaster = 0; const char *set_name; out.data = NULL; if ( mongo_simple_int_command( conn, "admin", "ismaster", 1, &out ) == MONGO_OK ) { if( bson_find( &it, &out, "ismaster" ) ) ismaster = bson_iterator_bool( &it ); if( bson_find( &it, &out, "setName" ) ) { set_name = bson_iterator_string( &it ); if( strcmp( set_name, conn->replset->name ) != 0 ) { bson_destroy( &out ); conn->err = MONGO_CONN_BAD_SET_NAME; return MONGO_ERROR; } } } bson_destroy( &out ); if( ismaster ) { conn->replset->primary_connected = 1; } else { mongo_close_socket( conn->sock ); } return MONGO_OK; }
bson_bool_t gridfile_get_boolean(gridfile* gfile, const char* name) { bson_iterator it; bson_find(&it, gfile->meta, name); return bson_iterator_bool( &it ); }
/* Find out whether the current connected node is master, and * verify that the node's replica set name matched the provided name */ static int mongo_replset_check_host( mongo_connection* conn ) { bson out; bson_iterator it; bson_bool_t ismaster = 0; const char* set_name; out.data = NULL; out.owned = 1; if (mongo_simple_int_command(conn, "admin", "ismaster", 1, &out)) { if( bson_find(&it, &out, "ismaster") ) ismaster = bson_iterator_bool( &it ); if( bson_find( &it, &out, "setName" ) ) { set_name = bson_iterator_string( &it ); if( strcmp( set_name, conn->replset->name ) != 0 ) { return mongo_conn_bad_set_name; } } } bson_destroy( &out ); if(ismaster) { conn->replset->primary_connected = 1; } else { mongo_close_socket( conn->sock ); } return 0; }
void bson_print_raw( const char * data , int depth ){ bson_iterator i; const char * key; int temp; char oidhex[25]; bson_iterator_init( &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" ); printf( "%s : %d \t " , key , t ); switch ( t ){ case bson_int: printf( "%d" , bson_iterator_int( &i ) ); break; case bson_double: printf( "%f" , bson_iterator_double( &i ) ); break; case bson_bool: printf( "%s" , bson_iterator_bool( &i ) ? "true" : "false" ); break; case bson_string: printf( "%s" , bson_iterator_string( &i ) ); break; case bson_null: printf( "null" ); break; case bson_oid: bson_oid_to_string(bson_iterator_oid(&i), oidhex); printf( "%s" , oidhex ); break; case bson_object: case bson_array: printf( "\n" ); bson_print_raw( bson_iterator_value( &i ) , depth + 1 ); break; default: fprintf( stderr , "can't print type : %d\n" , t ); } printf( "\n" ); } }
int mongo_simple_int_command( mongo *conn, const char *db, const char *cmdstr, int arg, bson *realout ) { bson out = {NULL, 0}; bson cmd; bson_bool_t success = 0; bson_init( &cmd ); bson_append_int( &cmd, cmdstr, arg ); bson_finish( &cmd ); if( mongo_run_command( conn, db, &cmd, &out ) == MONGO_OK ) { bson_iterator it; if( bson_find( &it, &out, "ok" ) ) success = bson_iterator_bool( &it ); } bson_destroy( &cmd ); if ( realout ) *realout = out; else bson_destroy( &out ); if( success ) return MONGO_OK; else { conn->err = MONGO_COMMAND_FAILED; return MONGO_ERROR; } }
MONGO_EXPORT int mongo_run_command( mongo *conn, const char *db, const bson *command, bson *out ) { bson response = {NULL, 0}; bson fields; int sl = strlen( db ); char *ns = bson_malloc( sl + 5 + 1 ); /* ".$cmd" + nul */ int res, success = 0; strcpy( ns, db ); strcpy( ns+sl, ".$cmd" ); res = mongo_find_one( conn, ns, command, bson_empty( &fields ), &response ); bson_free( ns ); if( res != MONGO_OK ) return MONGO_ERROR; else { bson_iterator it; if( bson_find( &it, &response, "ok" ) ) success = bson_iterator_bool( &it ); if( !success ) { conn->err = MONGO_COMMAND_FAILED; return MONGO_ERROR; } else { if( out ) *out = response; return MONGO_OK; } } }
uint8_t QueryOpEXISTS(BSONElem* val,BSONElem* qVal,int * err) { uint8_t eVal = bson_iterator_bool(qVal->itr); if (val->value) { return eVal ? eVal:0; } return eVal ? eVal:1; }
static void bson_decode_tree(lua_State* L, bson_iterator* b,int set_t){ const char *key; while(bson_iterator_next(b)) { bson_type t = bson_iterator_type(b); if(t == 0) { lua_pushnil(L); break; } key = bson_iterator_key(b); if(set_t) { lua_pushstring(L,key); } LOG_MSG("type %d,key %s",t,key); switch(t) { case BSON_DOUBLE: lua_pushnumber(L,bson_iterator_double(b)); break; case BSON_STRING: lua_pushstring(L,bson_iterator_string(b)); break; case BSON_BOOL: lua_pushboolean(L,bson_iterator_bool( b ) ? true : false ); break; case BSON_NULL: lua_pushnil(L); break; case BSON_INT: lua_pushinteger(L,bson_iterator_int(b)); break; case BSON_OBJECT: bson_iterator t; bson_iterator_subiterator(b,&t); bson_decode_tree(L,&t); lua_settable(L,-3); break; case BSON_ARRAY: lua_newtable(L); bson_iterator s; bson_iterator_subiterator(b,&s); bson_decode_tree(L,&s,1); break; default: break; } if(set_t) { lua_settable(L,-3); } } }
bson_bool_t mongo_cmd_authenticate( mongo *conn, const char *db, const char *user, const char *pass ) { bson from_db; bson cmd; bson out; const char *nonce; bson_bool_t success = 0; mongo_md5_state_t st; mongo_md5_byte_t digest[16]; char hex_digest[33]; if( mongo_simple_int_command( conn, db, "getnonce", 1, &from_db ) == MONGO_OK ) { bson_iterator it; bson_find( &it, &from_db, "nonce" ); nonce = bson_iterator_string( &it ); } else { return MONGO_ERROR; } mongo_pass_digest( user, pass, hex_digest ); mongo_md5_init( &st ); mongo_md5_append( &st, ( const mongo_md5_byte_t * )nonce, strlen( nonce ) ); mongo_md5_append( &st, ( const mongo_md5_byte_t * )user, strlen( user ) ); mongo_md5_append( &st, ( const mongo_md5_byte_t * )hex_digest, 32 ); mongo_md5_finish( &st, digest ); digest2hex( digest, hex_digest ); bson_init( &cmd ); bson_append_int( &cmd, "authenticate", 1 ); bson_append_string( &cmd, "user", user ); bson_append_string( &cmd, "nonce", nonce ); bson_append_string( &cmd, "key", hex_digest ); bson_finish( &cmd ); bson_destroy( &from_db ); /*bson_init( &from_db ); */ if( mongo_run_command( conn, db, &cmd, &out ) == MONGO_OK ) { bson_iterator it; if( bson_find( &it, &out, "ok" ) ) success = bson_iterator_bool( &it ); } bson_destroy( &from_db ); bson_destroy( &cmd ); if( success ) return MONGO_OK; else return MONGO_ERROR; }
MONGO_EXPORT bson_bool_t mongo_cmd_ismaster( mongo *conn, bson *realout ) { bson out = {NULL,0}; bson_bool_t ismaster = 0; if ( mongo_simple_int_command( conn, "admin", "ismaster", 1, &out ) == MONGO_OK ) { bson_iterator it; bson_find( &it, &out, "ismaster" ); ismaster = bson_iterator_bool( &it ); } if( realout ) *realout = out; /* transfer of ownership */ else bson_destroy( &out ); return ismaster; }
MONGO_EXPORT int32_t mongo_run_command(mongo *conn, const char* db, const bson *command, bson *out) { bson response[1]; bson_iterator it[1]; size_t sl = fibjs::qstrlen(db); char *ns = (char *) bson_malloc(sl + 5 + 1); int32_t res = 0; strcpy(ns, db); strcpy(ns + sl, ".$cmd"); res = mongo_find_one(conn, ns, command, bson_shared_empty(), response); bson_free(ns); if (res == MONGO_OK && (!bson_find(it, response, "ok") || !bson_iterator_bool(it))) { if (bson_find(it, response, "errmsg")) { int32_t result_len = bson_iterator_string_len(it); const char *result_string = bson_iterator_string(it); int32_t len = result_len < MONGO_ERR_LEN ? result_len : MONGO_ERR_LEN; memcpy(conn->lasterrstr, result_string, len); conn->lasterrcode = -1; } else conn->err = MONGO_COMMAND_FAILED; bson_destroy(response); res = MONGO_ERROR; } if (out) if (res == MONGO_OK) *out = *response; else bson_init_zero(out); else if (res == MONGO_OK) bson_destroy(response); return res; }
static bson_bool_t mongodb_cmd_ping(mongo_connection *conn, const char *db) { bson out; bson_bool_t res; bson_iterator it; memset(&out, 0, sizeof(bson)); res = mongo_simple_int_command(conn, db, "ping", 1, &out); if (res) { if (bson_find(&it, &out, "ok") == bson_eoo) { res = 0; } else { res = bson_iterator_bool(&it); } } bson_destroy(&out); return res; }
static int mongo_check_is_master( mongo *conn ) { bson out; bson_iterator it; bson_bool_t ismaster = 0; out.data = NULL; if ( mongo_simple_int_command( conn, "admin", "ismaster", 1, &out ) == MONGO_OK ) { if( bson_find( &it, &out, "ismaster" ) ) ismaster = bson_iterator_bool( &it ); } else { return MONGO_ERROR; } bson_destroy( &out ); if( ismaster ) return MONGO_OK; else { conn->err = MONGO_CONN_NOT_MASTER; return MONGO_ERROR; } }
void lua_push_bson_value(lua_State *L, bson_iterator *it) { bson_type bt = bson_iterator_type(it); switch (bt) { case BSON_OID: { char xoid[25]; bson_oid_to_string(bson_iterator_oid(it), xoid); lua_pushstring(L, xoid); break; } case BSON_STRING: case BSON_SYMBOL: lua_pushstring(L, bson_iterator_string(it)); break; case BSON_NULL: case BSON_UNDEFINED: lua_push_bsontype_table(L, bt); break; case BSON_INT: lua_pushinteger(L, bson_iterator_int(it)); break; case BSON_LONG: case BSON_DOUBLE: lua_pushnumber(L, (lua_Number) bson_iterator_double(it)); break; case BSON_BOOL: lua_pushboolean(L, bson_iterator_bool(it)); break; case BSON_OBJECT: case BSON_ARRAY: { bson_iterator nit; bson_iterator_subiterator(it, &nit); if (bt == BSON_OBJECT) { lua_push_bson_table(L, &nit); } else { lua_push_bson_array(L, &nit); } break; } case BSON_DATE: { lua_push_bsontype_table(L, bt); lua_pushnumber(L, bson_iterator_date(it)); lua_rawseti(L, -2, 1); break; } case BSON_BINDATA: { lua_push_bsontype_table(L, bt); lua_pushlstring(L, bson_iterator_bin_data(it), bson_iterator_bin_len(it)); break; } case BSON_REGEX: { const char *re = bson_iterator_regex(it); const char *ro = bson_iterator_regex_opts(it); lua_push_bsontype_table(L, bt); lua_pushstring(L, re); lua_rawseti(L, -2, 1); lua_pushstring(L, ro); lua_rawseti(L, -2, 2); break; } default: break; } }
void decodeValue(v8::Local<v8::Object> obj, bson_iterator *it) { bson_type type = bson_iterator_type(it); const char *key = bson_iterator_key(it); switch (type) { case BSON_NULL: obj->Set(v8::String::NewFromUtf8(isolate, key), v8::Null(isolate)); break; case BSON_STRING: obj->Set(v8::String::NewFromUtf8(isolate, key), v8::String::NewFromUtf8(isolate, bson_iterator_string(it))); break; case BSON_BOOL: obj->Set(v8::String::NewFromUtf8(isolate, key), bson_iterator_bool(it) ? v8::True(isolate) : v8::False(isolate)); break; case BSON_INT: obj->Set(v8::String::NewFromUtf8(isolate, key), v8::Number::New(isolate, bson_iterator_int(it))); break; case BSON_LONG: { int64_t num = bson_iterator_long(it); if (num >= -2147483648ll && num <= 2147483647ll) { obj->Set(v8::String::NewFromUtf8(isolate, key), v8::Number::New(isolate, (double) num)); } else { obj_ptr<Int64> int64 = new Int64(num); obj->Set(v8::String::NewFromUtf8(isolate, key), int64->wrap()); } break; } case BSON_DOUBLE: obj->Set(v8::String::NewFromUtf8(isolate, key), v8::Number::New(isolate, bson_iterator_double(it))); break; case BSON_DATE: obj->Set(v8::String::NewFromUtf8(isolate, key), v8::Date::New(isolate, (double) bson_iterator_date(it))); break; case BSON_BINDATA: { obj_ptr<Buffer_base> buf = new Buffer( std::string(bson_iterator_bin_data(it), bson_iterator_bin_len(it))); obj->Set(v8::String::NewFromUtf8(isolate, key), buf->wrap()); break; } case BSON_OID: { obj_ptr<MongoID> oid = new MongoID(bson_iterator_oid(it)); obj->Set(v8::String::NewFromUtf8(isolate, key), oid->wrap()); break; } case BSON_REGEX: { v8::RegExp::Flags flgs = v8::RegExp::kNone; const char *opts = bson_iterator_regex_opts(it); char ch; while ((ch = *opts++) != 0) if (ch == 'm') flgs = (v8::RegExp::Flags) (flgs | v8::RegExp::kMultiline); else if (ch == 'g') flgs = (v8::RegExp::Flags) (flgs | v8::RegExp::kGlobal); else if (ch == 'i') flgs = (v8::RegExp::Flags) (flgs | v8::RegExp::kIgnoreCase); obj->Set(v8::String::NewFromUtf8(isolate, key), v8::RegExp::New(v8::String::NewFromUtf8(isolate, bson_iterator_regex(it)), flgs)); break; } case BSON_OBJECT: case BSON_ARRAY: { bson_iterator it1; bson_iterator_subiterator(it, &it1); obj->Set(v8::String::NewFromUtf8(isolate, key), decodeObject(&it1, type == BSON_ARRAY)); break; } default: printf("unknown type: %d\n", type); break; } }
bool bson_values_are_equal( bson_type t, const bson_iterator *it1, const bson_iterator *it2 ) { assert( it1 ); assert( it2 ); bool match; switch( t ) { case BSON_ARRAY: { bson_iterator *sub_it1 = malloc( sizeof( bson_iterator ) ); bson_iterator *sub_it2 = malloc( sizeof( bson_iterator ) ); bson_iterator_subiterator( it1, sub_it1 ); bson_iterator_subiterator( it2, sub_it2 ); match = bson_cmp_array( sub_it1, sub_it2 ); free( sub_it1 ); free( sub_it2 ); break; } case BSON_OBJECT: { bson first_sub[1], second_sub[1]; bson_iterator_subobject( it1, first_sub ); bson_iterator_subobject( it2, second_sub ); match = bson_cmp( first_sub, second_sub ); break; } case BSON_DOUBLE: { double first = bson_iterator_double( it1 ); double second = bson_iterator_double( it2 ); match = (bool)(first == second); break; } case BSON_STRING: { const char* first = bson_iterator_value( it1 ); const char* second = bson_iterator_value( it2 ); match = (bool)(0 == strcmp( first, second )); break; } case BSON_BOOL: { bson_bool_t first = bson_iterator_bool( it1 ); bson_bool_t second = bson_iterator_bool( it2 ); match = (bool)(first == second); break; } case BSON_NULL: { match = true; break; } case BSON_INT: { int first = bson_iterator_int( it1 ); int second = bson_iterator_int( it2 ); match = (bool)(first == second); break; } case BSON_LONG: { int64_t first = bson_iterator_long( it1 ); int64_t second = bson_iterator_long( it2 ); match = (bool)(first == second); break; } default: break; } return match; }
int mongotcl_bsontoarray_raw (Tcl_Interp *interp, char *arrayName, char *typeArrayName, const char *data , int depth) { bson_iterator i; const char *key; bson_timestamp_t ts; char oidhex[25]; Tcl_Obj *obj; char *type; if (data == NULL) { return TCL_OK; } 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: { obj = Tcl_NewDoubleObj (bson_iterator_double (&i)); type = "double"; break; } case BSON_SYMBOL: { obj = Tcl_NewStringObj (bson_iterator_string (&i), -1); type = "symbol"; break; } case BSON_STRING: { obj = Tcl_NewStringObj (bson_iterator_string (&i), -1); type = "string"; break; } case BSON_OID: { bson_oid_to_string( bson_iterator_oid( &i ), oidhex ); obj = Tcl_NewStringObj (oidhex, -1); type = "oid"; break; } case BSON_BOOL: { obj = Tcl_NewBooleanObj (bson_iterator_bool (&i)); type = "bool"; break; } case BSON_DATE: { obj = Tcl_NewLongObj ((long) bson_iterator_date(&i)); type = "date"; break; } case BSON_BINDATA: { unsigned char *bindata = (unsigned char *)bson_iterator_bin_data (&i); int binlen = bson_iterator_bin_len (&i); obj = Tcl_NewByteArrayObj (bindata, binlen); type = "bin"; break; } case BSON_UNDEFINED: { obj = Tcl_NewObj (); type = "undefined"; break; } case BSON_NULL: { obj = Tcl_NewObj (); type = "null"; break; } case BSON_REGEX: { obj = Tcl_NewStringObj (bson_iterator_regex (&i), -1); type = "regex"; break; } case BSON_CODE: { obj = Tcl_NewStringObj (bson_iterator_code (&i), -1); type = "code"; 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: { obj = Tcl_NewIntObj (bson_iterator_int (&i)); type = "int"; break; } case BSON_LONG: { obj = Tcl_NewLongObj ((uint64_t)bson_iterator_long (&i)); type = "long"; break; } case BSON_TIMESTAMP: { char string[64]; ts = bson_iterator_timestamp (&i); snprintf(string, sizeof(string), "%d:%d", ts.i, ts.t); obj = Tcl_NewStringObj (bson_iterator_string (&i), -1); type = "timestamp"; break; } case BSON_ARRAY: { obj = Tcl_NewObj(); obj = mongotcl_bsontolist_raw (interp, obj, bson_iterator_value (&i), depth + 1); type = "array"; break; } case BSON_OBJECT: { Tcl_Obj *subList = Tcl_NewObj (); obj = mongotcl_bsontolist_raw (interp, subList, bson_iterator_value (&i), depth + 1); type = "object"; break; } default: { obj = Tcl_NewIntObj (t); type = "unknown"; break; } } if (Tcl_SetVar2Ex (interp, arrayName, key, obj, TCL_LEAVE_ERR_MSG) == NULL) { return TCL_ERROR; } if (typeArrayName != NULL) { if (Tcl_SetVar2Ex (interp, typeArrayName, key, Tcl_NewStringObj (type, -1), TCL_LEAVE_ERR_MSG) == NULL) { return TCL_ERROR; } } } return TCL_OK; }
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; }
void to_json(char *buf, const char * data, int depth){ int array_count = 0; int object_count = 0; bson_iterator i; const char * key; char oidhex[25]; bson_iterator_init( &i , data ); sprintf(buf+strlen(buf),"{"); while ( bson_iterator_next( &i ) ){ bson_type t = bson_iterator_type( &i ); if ( t == 0 ) break; key = bson_iterator_key( &i ); if(object_count > 0){sprintf(buf+strlen(buf),",");} else{object_count=1;} sprintf(buf+strlen(buf), "\"%s\":" , key ); switch ( t ){ case bson_int: sprintf(buf+strlen(buf), "%d" , bson_iterator_int( &i ) ); break; case bson_double: sprintf(buf+strlen(buf), "%f" , bson_iterator_double( &i ) ); break; case bson_bool: sprintf(buf+strlen(buf), "%s" , bson_iterator_bool( &i ) ? "true" : "false" ); break; case bson_string: sprintf(buf+strlen(buf), "\"%s\"" , bson_iterator_string( &i ) ); break; case bson_null: sprintf( buf+strlen(buf),"null" ); break; case bson_oid: bson_oid_to_string(bson_iterator_oid(&i), oidhex); sprintf(buf+strlen(buf), "%s" , oidhex ); break; case bson_object: to_json(buf, bson_iterator_value( &i ) , depth + 1 ); break; case bson_array: sprintf(buf+strlen(buf), "[" ); bson_iterator j; bson_iterator_init( &j , bson_iterator_value(&i) ); array_count =0; while( bson_iterator_next(&j)){ if(array_count > 0){sprintf(buf+strlen(buf),",");} else{array_count=1;} to_json(buf, bson_iterator_value( &j ) , depth + 1 ); } sprintf(buf+strlen(buf), "]" ); break; default: fprintf( stderr , "can't print type : %d\n" , t ); } } sprintf(buf+strlen(buf),"}"); }
EXPORT int mongo_bson_iterator_bool(struct bson_iterator_* i) { return (bson_iterator_bool((bson_iterator*) i) != 0); }
EXPORT mxArray* mongo_bson_array_value(struct bson_iterator_* i) { bson_type sub_type, common_type; struct Rcomplex z; bson_iterator sub[MAXDIM+1]; mwSize ndims = 0; mwSize count[MAXDIM+1]; mwSize dim[MAXDIM+1]; mwSize* mdim = dim + 1; mwSize sizes[MAXDIM+1]; mxArray* ret; mwSize depth, j, len, ofs; int isRow = 0; sub[0] = *(bson_iterator*)i; /* count number of dimensions. This is equal to the number of consecutive array markers in the BSON */ do { bson_iterator_subiterator(&sub[ndims], &sub[ndims+1]); if (++ndims > MAXDIM) { mexPrintf("Max dimensions (%d) exceeded. Use an iterator\n", MAXDIM); return 0; } sub_type = bson_iterator_next(&sub[ndims]); } while (sub_type == BSON_ARRAY); /* get the first data value's type */ switch (common_type = sub_type) { case BSON_INT: ; case BSON_LONG: ; case BSON_DOUBLE: ; /* case BSON_STRING: ; */ case BSON_BOOL: ; case BSON_DATE: break; case BSON_OBJECT: if (_iterator_getComplex(&sub[ndims], &z)) break; /* fall thru to default */ default: /* including empty array */ mexPrintf("Unable to convert array - invalid type (%d)", common_type); return 0; } /* initial lowest level count */ for (j = 0; j <= ndims; j++) count[j] = 1; while ((sub_type = bson_iterator_next(&sub[ndims])) != BSON_EOO) { if (sub_type != common_type) { mexPrintf("Unable to convert array - inconsistent types"); return 0; } if (sub_type == BSON_OBJECT && !_iterator_getComplex(&sub[ndims], &z)) { mexPrintf("Unable to convert array - invalid subobject"); return 0; } ++count[ndims]; } /* step through rest of array -- checking common type and dimensions */ memset(dim, 0, sizeof(dim)); depth = ndims; while (depth >= 1) { sub_type = bson_iterator_next(&sub[depth]); switch (sub_type) { case BSON_EOO: if (dim[depth] == 0) dim[depth] = count[depth]; else if (dim[depth] != count[depth]) { mexPrintf("Unable to convert array - inconsistent dimensions"); return 0; } depth--; break; case BSON_ARRAY: count[depth]++; bson_iterator_subiterator(&sub[depth], &sub[depth+1]); if (++depth > ndims) { mexPrintf("Unable to convert array - inconsistent dimensions"); return 0; } count[depth] = 0; break; case BSON_INT: ; case BSON_LONG: ; case BSON_DOUBLE: ; /* case BSON_STRING: ; */ case BSON_BOOL: ; case BSON_DATE: ; GotEl: { if (depth != ndims || sub_type != common_type) { mexPrintf("Unable to convert array - inconsistent dimensions or types"); return 0; } count[depth]++; break; } case BSON_OBJECT: if (_iterator_getComplex(&sub[depth], &z)) goto GotEl; /* fall thru to default */ default: mexPrintf("Unable to convert array - invalid type (%d)", sub_type); return 0; } } if (ndims > 1) { j = dim[ndims]; /* reverse row and column */ dim[ndims] = dim[ndims-1]; dim[ndims-1] = j; } /* calculate offset each dimension multiplies it's index by */ len = 1; for (depth = ndims; depth > 0; depth--) { sizes[depth] = len; len *= dim[depth]; } if (ndims > 1) { reverse(mdim, ndims); /* reverse dimensions for Matlab */ j = sizes[ndims]; sizes[ndims] = sizes[ndims-1]; sizes[ndims-1] = j; } else { isRow = 1; ndims = 2; mdim[1] = mdim[0]; mdim[0] = 1; } /* for (j = 1; j <= ndims; j++) mexPrintf("%d ", dim[j]); mexPrintf("\n"); for (j = 1; j <= ndims; j++) mexPrintf("%d ", sizes[j]); mexPrintf("\n"); */ switch (common_type) { case BSON_INT: ret = mxCreateNumericArray(ndims, mdim, mxINT32_CLASS, mxREAL); break; case BSON_LONG: ret = mxCreateNumericArray(ndims, mdim, mxINT64_CLASS, mxREAL); break; case BSON_DATE: case BSON_DOUBLE: ret = mxCreateNumericArray(ndims, mdim, mxDOUBLE_CLASS, mxREAL); break; /* case BSON_STRING: */ case BSON_BOOL: ret = mxCreateLogicalArray(ndims, mdim); break; case BSON_OBJECT: ret = mxCreateNumericArray(ndims, mdim, mxDOUBLE_CLASS, mxCOMPLEX); break; default: /* never reaches here */ ret = 0; } if (isRow) ndims--; /* step through array(s) again, pulling out values */ bson_iterator_subiterator(&sub[0], &sub[1]); depth = 1; count[depth] = 0; while (depth >= 1) { sub_type = bson_iterator_next(&sub[depth]); count[depth]++; if (sub_type == BSON_EOO) { depth--; } else if (sub_type == BSON_ARRAY) { bson_iterator_subiterator(&sub[depth], &sub[depth+1]); depth++; count[depth] = 0; } else { ofs = 0; for (j = 1; j <= ndims; j++) ofs += sizes[j] * (count[j] - 1); switch (sub_type) { case BSON_INT: ((int*)mxGetData(ret))[ofs] = bson_iterator_int(&sub[depth]); break; case BSON_DATE: mxGetPr(ret)[ofs] = 719529.0 + bson_iterator_date(&sub[depth]) / (1000.0 * 60 * 60 * 24); break; case BSON_DOUBLE: mxGetPr(ret)[ofs] = bson_iterator_double(&sub[depth]); break; case BSON_LONG: ((int64_t*)mxGetData(ret))[ofs] = bson_iterator_long(&sub[depth]); break; case BSON_STRING: break; case BSON_BOOL: ; ((mxLogical*)mxGetData(ret))[ofs] = bson_iterator_bool(&sub[depth]); break; case BSON_OBJECT: _iterator_getComplex(&sub[depth], &z); mxGetPr(ret)[ofs] = z.r; mxGetPi(ret)[ofs] = z.i; break; default: ; /* never reaches here */ } } } return ret; }
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; }
INLINE void bson_to_v P2(bson_iterator *, i, svalue_t *, v){ int temp; const char *cp; char oidhex[25]; bson scope; bson_type t; bson_timestamp_t ts; t = bson_iterator_type( i ); switch ( t ) { case BSON_DOUBLE: v->type = T_REAL; v->u.real = bson_iterator_double( i ); break; case BSON_STRING: cp = bson_iterator_string( i ); v->type = T_STRING; v->subtype = STRING_MALLOC; v->u.string = string_copy(cp,"bson_to_v:1"); break; case BSON_SYMBOL: v->type = T_STRING; v->subtype = STRING_MALLOC; v->u.string = string_copy("SYMBOL","bson_to_v:2"); break; case BSON_OID: bson_oid_to_string( bson_iterator_oid( i ), oidhex ); v->type = T_STRING; v->subtype = STRING_MALLOC; v->u.string = string_copy(oidhex,"bson_to_v:3"); break; case BSON_BOOL: v->type = T_NUMBER; v->u.number = ( long )bson_iterator_bool( i ); break; case BSON_DATE: v->type = T_NUMBER; v->u.number = ( long )bson_iterator_date( i ); break; case BSON_BINDATA: v->type = T_STRING; v->subtype = STRING_MALLOC; v->u.string = string_copy("BSON_BINDATA","bson_to_v:4"); break; case BSON_UNDEFINED: v->type = T_STRING; v->subtype = STRING_MALLOC; v->u.string = string_copy("BSON_UNDEFINED","bson_to_v:5"); break; case BSON_NULL: v->type = T_STRING; v->subtype = STRING_MALLOC; v->u.string = string_copy("BSON_NULL","bson_to_v:6"); break; case BSON_REGEX: v->type = T_STRING; v->subtype = STRING_MALLOC; v->u.string = string_copy("BSON_REGEX","bson_to_v:7"); break; case BSON_CODE: v->type = T_STRING; v->subtype = STRING_MALLOC; v->u.string = string_copy("BSON_CODE","bson_to_v:8"); break; case BSON_CODEWSCOPE: v->type = T_STRING; v->subtype = STRING_MALLOC; v->u.string = string_copy("BSON_CODEWSCOPE","bson_to_v:9"); break; case BSON_INT: v->type = T_NUMBER; v->u.number = ( long )bson_iterator_int( i ); break; case BSON_LONG: v->type = T_NUMBER; v->u.number = ( long )bson_iterator_long( i ); break; case BSON_TIMESTAMP: ts = bson_iterator_timestamp( i ); v->type = T_NUMBER; v->u.number = ( long )ts.t; break; case BSON_OBJECT: bson_to_mapping( bson_iterator_value( i ) , v); break; case BSON_ARRAY: bson_to_array( bson_iterator_value( i ) , v); break; default: v->type = T_STRING; v->subtype = STRING_MALLOC; v->u.string = string_copy("UNKOWN_TYPE","bson_to_v:10"); break; } }
void json_from_bson_bool(yajl_gen *g, bson_iterator *it) { bson_bool_t value = bson_iterator_bool( it ); yajl_gen_bool( *g, value ); }
static void bson_print_xstr(TCXSTR* xstr, 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++) { tcxstrprintf(xstr, "."); } tcxstrprintf(xstr, "%s(%d)=", key, t); switch (t) { case BSON_DOUBLE: tcxstrprintf(xstr, "%f", bson_iterator_double(&i)); break; case BSON_STRING: tcxstrprintf(xstr, "%s", bson_iterator_string(&i)); break; case BSON_SYMBOL: tcxstrprintf(xstr, "SYMBOL: %s", bson_iterator_string(&i)); break; case BSON_OID: bson_oid_to_string(bson_iterator_oid(&i), oidhex); tcxstrprintf(xstr, "%s", oidhex); break; case BSON_BOOL: tcxstrprintf(xstr, "%s", bson_iterator_bool(&i) ? "true" : "false"); break; case BSON_DATE: tcxstrprintf(xstr, "%lld", (uint64_t) bson_iterator_long(&i)); break; case BSON_BINDATA: tcxstrprintf(xstr, "BSON_BINDATA"); break; case BSON_UNDEFINED: tcxstrprintf(xstr, "BSON_UNDEFINED"); break; case BSON_NULL: tcxstrprintf(xstr, "BSON_NULL"); break; case BSON_REGEX: tcxstrprintf(xstr, "BSON_REGEX: %s", bson_iterator_regex(&i)); break; case BSON_CODE: tcxstrprintf(xstr, "BSON_CODE: %s", bson_iterator_code(&i)); break; case BSON_CODEWSCOPE: tcxstrprintf(xstr, "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); tcxstrprintf(xstr, "\n SCOPE: "); bson_print_xstr(xstr, scope.data, 0); /* bson_destroy( &scope ); */ /* review - causes free error */ break; case BSON_INT: tcxstrprintf(xstr, "%d", bson_iterator_int(&i)); break; case BSON_LONG: tcxstrprintf(xstr, "%lld", (uint64_t) bson_iterator_long(&i)); break; case BSON_TIMESTAMP: ts = bson_iterator_timestamp(&i); tcxstrprintf(xstr, "i: %d, t: %d", ts.i, ts.t); break; case BSON_OBJECT: case BSON_ARRAY: tcxstrprintf(xstr, "\n"); bson_print_xstr(xstr, bson_iterator_value(&i), depth + 1); break; default: fprintf(stderr, "can't print type : %d\n", t); } tcxstrprintf(xstr, "\n"); } }
static char * bson_to_json_recurse(StringInfo buf, const char *data, bool is_object) { bson_iterator i; const char *key; char oidhex[25]; char *str; bool first = true; bson_iterator_from_buffer(&i, data); while (bson_iterator_next(&i)) { bson_type t = bson_iterator_type(&i); if (t == 0) break; if (!first) appendStringInfoChar(buf, ','); first = false; if (is_object) { key = bson_iterator_key(&i); appendStringInfo(buf, "\"%s\"", key); appendStringInfoChar(buf, ':'); } switch (t) { case BSON_DOUBLE: appendStringInfo(buf, "%f", bson_iterator_double(&i)); break; case BSON_STRING: str = quote_string(bson_iterator_string(&i)); appendStringInfoString(buf, str); break; case BSON_OID: bson_oid_to_string(bson_iterator_oid(&i), oidhex); str = quote_string(oidhex); appendStringInfoString(buf, str); break; case BSON_BOOL: appendStringInfoString(buf, bson_iterator_bool(&i) ? "true" : "false"); break; case BSON_INT: appendStringInfo(buf, "%d", bson_iterator_int(&i)); break; case BSON_LONG: appendStringInfo(buf, "%lld", (uint64_t) bson_iterator_long(&i)); break; case BSON_NULL: appendStringInfoString(buf, "null"); break; case BSON_OBJECT: appendStringInfoChar(buf, '{'); bson_to_json_recurse(buf, bson_iterator_value(&i), true); appendStringInfoChar(buf, '}'); break; case BSON_ARRAY: appendStringInfoChar(buf, '['); bson_to_json_recurse(buf, bson_iterator_value(&i), false); appendStringInfoChar(buf, ']'); break; case BSON_DATE: case BSON_TIMESTAMP: case BSON_SYMBOL: case BSON_BINDATA: case BSON_UNDEFINED: case BSON_REGEX: case BSON_CODE: case BSON_CODEWSCOPE: ereport(ERROR, (errmsg("unsupported bson type: %d", t))); break; default: elog(ERROR, "unknown bson type: %d", t); break; } } return buf->data; }
int main(int argc, char *argv[]) { bson_buffer bb; bson b; bson_iterator it, it2, it3; bson_oid_t oid; bson_buffer_init(&bb); bson_append_double(&bb, "d", 3.14); bson_append_string(&bb, "s", "hello"); { 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", 0x0102030405060708ULL); bson_append_null(&bb, "n"); bson_append_regex(&bb, "r", "^asdf", "imx"); /* no dbref test (deprecated) */ bson_append_code(&bb, "c", "function(){}"); bson_append_symbol(&bb, "symbol", "SYMBOL"); { 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); } /* no timestamp test (internal) */ bson_append_long(&bb, "l", 0x1122334455667788ULL); bson_from_buffer(&b, &bb); 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_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) == 0x0102030405060708ULL); 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_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_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_long); ASSERT(bson_iterator_type(&it) == bson_long); ASSERT(!strcmp(bson_iterator_key(&it), "l")); ASSERT(bson_iterator_long(&it) == 0x1122334455667788ULL); 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; }
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" ); } }
char* Namespace::bson_to_json(char* val, const char *data, int depth, bool isObject, int bsonSize, int &jsonSize, int &cursor) { char *object; int bufSize; char keybuf[512]; char buf[512]; int c = 0; bson_iterator i; const char *key; int temp; bson_timestamp_t ts; char oidhex[25]; bson scope; bson_iterator_from_buffer(&i, data); //bson_iterator_init(&i, data); if (isObject) { memcpy(&val[cursor], "{", 1); cursor += 1; } else { memcpy(&val[cursor], "[", 1); cursor += 1; } while (bson_iterator_next(&i) && i.progress < bsonSize) { if (c > 0) { memcpy(&val[cursor], ",", 1); cursor += 1; } c++; bson_type t = bson_iterator_type(&i); if (t == 0) { break; } key = bson_iterator_key(&i); if (key[0] != '\0') { sprintf(keybuf, "\"%s\":", key); key = &keybuf[0]; } switch (t) { case BSON_DOUBLE: sprintf(buf, "%s%f", key, bson_iterator_double(&i)); bufSize = strlen(buf); memcpy(&val[cursor], buf, bufSize); cursor += bufSize; break; case BSON_STRING: sprintf(buf, "%s\"%s\"", key, bson_iterator_string(&i)); bufSize = strlen(buf); memcpy(&val[cursor], buf, bufSize); cursor += bufSize; break; case BSON_OID: bson_oid_to_string(bson_iterator_oid(&i), oidhex); sprintf(buf, "%s\"%s\"", key, oidhex); bufSize = strlen(buf); memcpy(&val[cursor], buf, bufSize); cursor += bufSize; break; case BSON_BOOL: sprintf(buf, "%s%s", key, bson_iterator_bool(&i) ? "true" : "false"); bufSize = strlen(buf); memcpy(&val[cursor], buf, bufSize); cursor += bufSize; break; case BSON_NULL: sprintf(buf, "%snull", key); bufSize = strlen(buf); memcpy(&val[cursor], buf, bufSize); cursor += bufSize; break; case BSON_INT: sprintf(buf, "%s%d", key, bson_iterator_int(&i)); bufSize = strlen(buf); memcpy(&val[cursor], buf, bufSize); cursor += bufSize; break; case BSON_OBJECT: sprintf(buf, "%s\0", key); memcpy(&val[cursor], buf, strlen(buf)); cursor += strlen(buf); object = bson_to_json(val, bson_iterator_value(&i), depth + 1, true, bsonSize - cursor, jsonSize, cursor); break; case BSON_ARRAY: sprintf(buf, "%s", key); bufSize = strlen(buf); memcpy(&val[cursor], buf, bufSize); cursor += bufSize; object = bson_to_json(val, bson_iterator_value(&i), depth + 1, false, bsonSize - cursor, jsonSize, cursor); break; default: LOGE("can't print type"); FORCE_LOG_INT("type: ", t); memcpy(&val[cursor], "}", 1); cursor += 1; jsonSize = cursor; return val; } } if (isObject) { memcpy(&val[cursor], "}", 1); cursor += 1; memcpy(&val[cursor], "\0", 1); } else { memcpy(&val[cursor], "]", 1); cursor += 1; } jsonSize = cursor; return val; }