const char *gridfile_get_contenttype(gridfile* gfile) { bson_iterator it; if (bson_find(&it, gfile->meta, "contentType")) return bson_iterator_string( &it ); else return NULL; }
UInfo* MongoLink::query(int uid) { UInfo* uinfo = NULL; bson query[1]; mongo_cursor cursor[1]; bson_init( query ); bson_append_int( query, "uid", uid ); bson_finish( query ); mongo_cursor_init( cursor, &m_mongo, m_strDBName.c_str() ); mongo_cursor_set_query( cursor, query ); if( mongo_cursor_next( cursor ) == MONGO_OK ) { bson_iterator iterator[1]; uinfo = new UInfo(); //uinfo->linkid = 0; if ( bson_find( iterator, mongo_cursor_bson( cursor ), "uid" ) != BSON_EOO ) { uinfo->uid= bson_iterator_int( iterator ); } if ( bson_find( iterator, mongo_cursor_bson( cursor ), "router" ) != BSON_EOO ) { uinfo->router= bson_iterator_string( iterator ); } if ( bson_find( iterator, mongo_cursor_bson( cursor ), "dispatcher" ) != BSON_EOO ) { uinfo->dispatcher= bson_iterator_string( iterator ); } if ( bson_find( iterator, mongo_cursor_bson( cursor ), "proxy" ) != BSON_EOO ) { uinfo->proxy= bson_iterator_string( iterator ); } } else { LOG(TAG_ROUTER, "query uid failed, uid=%d.", uid); } exit: bson_destroy( query ); mongo_cursor_destroy( cursor ); return uinfo; }
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); } } }
mongo_cursor* gridfile_get_chunks(gridfile* gfile, int start, int size) { bson_iterator it; bson_oid_t id; bson_buffer gte_buf; bson gte_bson; bson_buffer query_buf; bson query_bson; bson_buffer orderby_buf; bson orderby_bson; bson_buffer command_buf; bson command_bson; bson_type type; char *id_str; int id_int; type = bson_find(&it, gfile->meta, "_id"); if( type == bson_oid ) { id = *bson_iterator_oid(&it); bson_buffer_init(&query_buf); bson_append_oid(&query_buf, "files_id", &id); } else if (type == bson_string) { id_str = bson_iterator_string(&it); bson_buffer_init(&query_buf); bson_append_string(&query_buf, "files_id", id_str); } else if (type == bson_string) { id_int = bson_iterator_int(&it); bson_buffer_init(&query_buf); bson_append_int(&query_buf, "files_id", id_int); } else return NULL; if (size == 1) { bson_append_int(&query_buf, "n", start); } else { bson_buffer_init(>e_buf); bson_append_int(>e_buf, "$gte", start); bson_from_buffer(>e_bson, >e_buf); bson_append_bson(&query_buf, "n", >e_bson); } bson_from_buffer(&query_bson, &query_buf); bson_buffer_init(&orderby_buf); bson_append_int(&orderby_buf, "n", 1); bson_from_buffer(&orderby_bson, &orderby_buf); bson_buffer_init(&command_buf); bson_append_bson(&command_buf, "query", &query_bson); bson_append_bson(&command_buf, "orderby", &orderby_bson); bson_from_buffer(&command_bson, &command_buf); return mongo_find(gfile->gfs->client, gfile->gfs->chunks_ns, &command_bson, NULL, size, 0, 0); }
//------------------------------------------------------------------------------ int main( int argc, char * argv[] ){ mongo conn; if( mongo_client( &conn , TEST_SERVER, TEST_PORT ) != MONGO_OK ) { std::cout << "failed to connect\n"; return EXIT_FAILURE; } mongo_cursor cursor; mongo_cursor_init( &cursor, &conn, "test.test" ); char hex_oid[25]; while( mongo_cursor_next( &cursor ) == MONGO_OK ) { std::cout << "row:\n"; bson_iterator it; bson_iterator_init( &it, mongo_cursor_bson( &cursor ) ); while( bson_iterator_next( &it ) ) { std::cout << " " << bson_iterator_key( &it ) << " = "; switch( bson_iterator_type( &it ) ) { case BSON_DOUBLE: std::cout << "(double) " << bson_iterator_double( &it ) << std::endl; break; case BSON_INT: std::cout << "(int) " << bson_iterator_int( &it ) << std::endl; break; case BSON_STRING: std::cout << "(string) \"" << bson_iterator_string( &it ) << "\"\n"; break; case BSON_OID: bson_oid_to_string( bson_iterator_oid( &it ), hex_oid ); std::cout << "(oid) \"" << hex_oid << "\"\n"; break; case BSON_OBJECT: std::cout << "(subobject) {...}\n"; break; case BSON_ARRAY: std::cout << "(array) [...]\n"; break; case BSON_TIMESTAMP: std::cout << "(timestamp) [...]\n"; break; default: std::cout << "(type " << bson_iterator_type( &it ) << std::endl; break; } } std::cout << std::endl; } mongo_disconnect( &conn ); return EXIT_SUCCESS; }
void MongodbObject::EnableForEdit() { bson *newObject = new bson(); bson_init(newObject); bson_iterator it; bson_iterator_init(&it, objectData->object); while (bson_iterator_next(&it)) { const char * key = bson_iterator_key(&it); bson_type type = bson_iterator_type(&it); switch (type) { case BSON_STRING: bson_append_string(newObject, key, bson_iterator_string(&it)); break; case BSON_INT: bson_append_int(newObject, key, bson_iterator_int(&it)); break; case BSON_LONG: bson_append_long(newObject, key, bson_iterator_long(&it)); break; case BSON_DOUBLE: bson_append_double(newObject, key, bson_iterator_double(&it)); break; case BSON_OBJECT: bson sub; bson_iterator_subobject(&it, &sub); bson_append_bson(newObject, key, &sub); break; case BSON_OID: bson_append_oid(newObject, key, bson_iterator_oid(&it)); break; default: break; } } bson_destroy(objectData->object); SafeDelete(objectData->object); objectData->object = newObject; }
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; }
SEXP mongo_get_database_collections(SEXP mongo_conn, SEXP db) { mongo* conn = _checkMongo(mongo_conn); const char* _db = CHAR(STRING_ELT(db, 0)); int len = strlen(_db); char ns[512]; strcpy(ns, _db); strcpy(ns+len, ".system.namespaces"); bson empty; bson_empty(&empty); mongo_cursor* cursor = mongo_find(conn, ns, NULL, &empty, 0, 0, 0); int count = 0; while (cursor && mongo_cursor_next(cursor) == MONGO_OK) { bson_iterator iter; if (bson_find(&iter, &cursor->current, "name")) { const char* name = bson_iterator_string(&iter); if (strstr(name, ".system.") || strchr(name, '$')) continue; ++count; } } mongo_cursor_destroy(cursor); cursor = mongo_find(conn, ns, &empty, &empty, 0, 0, 0); SEXP ret; PROTECT(ret = allocVector(STRSXP, count)); int i = 0; while (cursor && mongo_cursor_next(cursor) == MONGO_OK) { bson_iterator iter; if (bson_find(&iter, &cursor->current, "name")) { const char* name = bson_iterator_string(&iter); if (strstr(name, ".system.") || strchr(name, '$')) continue; SET_STRING_ELT(ret, i++, mkChar(name)); } } mongo_cursor_destroy(cursor); UNPROTECT(1); return ret; }
void InitWith(bson *obj) { bson_iterator it; bson_iterator_init(&it, obj); while (bson_iterator_next(&it)) { const char * key = bson_iterator_key(&it); bson_type type = bson_iterator_type(&it); switch (type) { case BSON_STRING: bson_append_string(object, key, bson_iterator_string(&it)); break; case BSON_INT: bson_append_int(object, key, bson_iterator_int(&it)); break; case BSON_LONG: bson_append_long(object, key, bson_iterator_long(&it)); break; case BSON_DOUBLE: bson_append_double(object, key, bson_iterator_double(&it)); break; case BSON_OBJECT: { bson sub; bson_iterator_subobject(&it, &sub); bson_append_bson(object, key, &sub); break; } case BSON_OID: bson_append_oid(object, key, bson_iterator_oid(&it)); break; default: DVASSERT(false); Logger::Error("[MongodbObjectInternalData::InitWith] Not implemented type: %d", type); break; } } }
static apr_status_t fetch_mongodb_value(const char *host, int port, const char *userfield, const char *passwordfield, const char *collection, const char *user, char **value, apr_pool_t *pool) { mongo_connection conn; /* ptr */ mongo_connection_options *opts; mongo_conn_return mongo_status; bson query[1]; bson *out; bson_buffer query_buf[1]; bson_bool_t found; mongo_cursor *cursor; *value = NULL; //conn = apr_palloc( pool, sizeof(mongo_connection)); opts = apr_palloc( pool, sizeof(mongo_connection_options)); strcpy( opts->host, host); opts->port = port; mongo_status = mongo_connect( pool, &conn, opts ); if ( mongo_status != mongo_conn_success) { char buf[120]; ap_log_perror(APLOG_MARK, APLOG_ERR, 0, pool,"couldn't connect to mongoDB - (%s)", mongo_strerror( mongo_status, buf,sizeof(buf) )); return APR_EGENERAL; } bson_buffer_init( pool, query_buf ); bson_append_string( query_buf, userfield, user); bson_from_buffer( query, query_buf ); out = apr_palloc(pool, sizeof(bson)); found = mongo_find_one( &conn, collection, query, NULL, out ); bson_destroy( query ); if ( found ) { bson_iterator it; if (bson_find( &it, out, passwordfield )) { // bson_iterator iCookies; // bson_iterator_init( &iCookies , bson_iterator_value(&it)); *value = apr_pstrdup( pool,bson_iterator_string(&it)); } } mongo_destroy( &conn ); return APR_SUCCESS; }
String MongodbObject::GetString(const String &fieldname) { String retValue = String(""); bson_iterator it; bson_iterator_init(&it, objectData->object); bson_iterator foundIt; bool found = objectData->FindField(&it, &foundIt, fieldname, true); if(found) { retValue = bson_iterator_string(&foundIt); } return retValue; }
static void mongo_replset_check_seed( mongo_connection* conn ) { bson out; bson hosts; const char* data; bson_iterator it; bson_iterator it_sub; const char* host_string; mongo_host_port *host_port = NULL; out.data = NULL; out.owned = 1; hosts.data = NULL; hosts.owned = 1; if( mongo_simple_int_command(conn, "admin", "ismaster", 1, &out) == MONGO_OK ) { if( bson_find( &it, &out, "hosts" ) ) { data = bson_iterator_value( &it ); bson_iterator_init( &it_sub, data ); /* Iterate over host list, adding each host to the * connection's host list. */ while( bson_iterator_next( &it_sub ) ) { host_string = bson_iterator_string( &it_sub ); host_port = bson_malloc( sizeof( mongo_host_port ) ); mongo_parse_host( host_string, host_port ); if( host_port ) { mongo_replset_add_node( &conn->replset->hosts, host_port->host, host_port->port ); free( host_port ); host_port = NULL; } } } } bson_destroy( &out ); bson_destroy( &hosts ); mongo_close_socket( conn->sock ); conn->sock = 0; conn->connected = 0; }
static int gridfs_insert_file2( gridfs *gfs, const char *name, const bson_oid_t id, gridfs_offset length, const char *contenttype, gridfile* gfile ) { bson command; bson ret; bson res; bson_iterator it; int result; int64_t d; /* Check run md5 */ bson_init( &command ); bson_append_oid( &command, "filemd5", &id ); bson_append_string( &command, "root", gfs->prefix ); bson_finish( &command ); result = mongo_run_command( gfs->client, gfs->dbname, &command, &res ); bson_destroy( &command ); if (result != MONGO_OK) return result; /* Create and insert BSON for file metadata */ bson_init( &ret ); bson_append_oid( &ret, "_id", &id ); if ( name != NULL && *name != '\0' ) { bson_append_string( &ret, "filename", name ); } bson_append_long( &ret, "length", length ); bson_append_int( &ret, "chunkSize", DEFAULT_CHUNK_SIZE ); d = ( bson_date_t )1000*time( NULL ); bson_append_date( &ret, "uploadDate", d); bson_find( &it, &res, "md5" ); bson_append_string( &ret, "md5", bson_iterator_string( &it ) ); bson_destroy( &res ); if ( contenttype != NULL && *contenttype != '\0' ) { bson_append_string( &ret, "contentType", contenttype ); } bson_append_bson(&ret, "metadata", gfile->meta); bson_finish( &ret ); result = mongo_insert( gfs->client, gfs->files_ns, &ret ); bson_destroy( &ret ); return result; }
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; }
char *mongodb_retrieve_key(bot_t * bot, char *db, char *key, char *which) { char *str = NULL; bson b; mongo_cursor cursor; if (!db || !key || !which) { return NULL; } debug(bot, "mongodb_retrieve_key: Entered :db=%s. key=%s, which=%s\n", db, key, which); bson_init(&b); bson_append_string(&b, "key", key); bson_finish(&b); mongo_cursor_init(&cursor, &gi->mongo_conn, db); mongo_cursor_set_query(&cursor, &b); if (mongo_cursor_next(&cursor) == MONGO_OK) { bson_iterator i; debug(bot, "mongodb_retrieve_key: Found!\n"); if (bson_find(&i, mongo_cursor_bson(&cursor), which)) { str = (char *)bson_iterator_string(&i); str = strdup(str); } bson_destroy(&b); mongo_cursor_destroy(&cursor); return str; } debug(bot, "mongodb_retrieve_key: Key not found\n"); bson_destroy(&b); mongo_cursor_destroy(&cursor); return NULL; }
static void tutorial_simple_query( mongo *conn ) { bson query[1]; mongo_cursor cursor[1]; bson_init( query ); bson_append_int( query, "age", 24 ); bson_finish( query ); mongo_cursor_init( cursor, conn, "tutorial.persons" ); mongo_cursor_set_query( cursor, query ); while( mongo_cursor_next( cursor ) == MONGO_OK ) { bson_iterator iterator[1]; if ( bson_find( iterator, mongo_cursor_bson( cursor ), "name" )) { printf( "name: %s\n", bson_iterator_string( iterator ) ); } } bson_destroy( query ); mongo_cursor_destroy( cursor ); }
static bson gridfs_insert_file( gridfs* gfs, const char* name, const bson_oid_t id, gridfs_offset length, const char* contenttype) { bson command; bson res; bson ret; bson_buffer buf; bson_iterator it; /* Check run md5 */ bson_buffer_init(&buf); bson_append_oid(&buf, "filemd5", &id); bson_append_string(&buf, "root", gfs->prefix); bson_from_buffer(&command, &buf); assert(mongo_run_command(gfs->client, gfs->dbname, &command, &res)); bson_destroy(&command); /* Create and insert BSON for file metadata */ bson_buffer_init(&buf); bson_append_oid(&buf, "_id", &id); if (name != NULL && *name != '\0') { bson_append_string(&buf, "filename", name); } bson_append_int(&buf, "length", length); bson_append_int(&buf, "chunkSize", DEFAULT_CHUNK_SIZE); bson_append_date(&buf, "uploadDate", (bson_date_t)1000*time(NULL)); bson_find(&it, &res, "md5"); bson_append_string(&buf, "md5", bson_iterator_string(&it)); bson_destroy(&res); if (contenttype != NULL && *contenttype != '\0') { bson_append_string(&buf, "contentType", contenttype); } bson_from_buffer(&ret, &buf); mongo_insert(gfs->client, gfs->files_ns, &ret); return ret; }
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_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_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: fprintf( stderr , "can't print type : %d\n" , t ); } printf( "\n" ); } }
clsSiteData::clsSiteData(int id, const bson *info) { m_ID = id; bson_iterator it[1]; bson_iterator_init(it, info); while (bson_iterator_next(it)) { if (strcmp("Name", bson_iterator_key(it)) == 0) m_Name = bson_iterator_string(it); //else if(strcmp("AREA", bson_iterator_key(it)) == 0) // m_Area = (float)bson_iterator_double(it); else if (strcmp("LocalX", bson_iterator_key(it)) == 0) m_XPR = (float) bson_iterator_double(it); else if (strcmp("LocalY", bson_iterator_key(it)) == 0) m_YPR = (float) bson_iterator_double(it); else if (strcmp("Lat", bson_iterator_key(it)) == 0) m_Latitude = (float) bson_iterator_double(it); else if (strcmp("Long", bson_iterator_key(it)) == 0) m_Longitude = (float) bson_iterator_double(it); else if (strcmp("Elevation", bson_iterator_key(it)) == 0) m_Elevation = (float) bson_iterator_double(it); } }
static int mongo_cmd_get_error_helper( mongo *conn, const char *db, bson *realout, const char *cmdtype ) { bson out = {NULL,0}; bson_bool_t haserror = 0; /* Reset last error codes. */ conn->lasterrcode = 0; bson_free( conn->lasterrstr ); conn->lasterrstr = NULL; /* If there's an error, store its code and string in the connection object. */ if( mongo_simple_int_command( conn, db, cmdtype, 1, &out ) == MONGO_OK ) { bson_iterator it; haserror = ( bson_find( &it, &out, "err" ) != BSON_NULL ); if( haserror ) { conn->lasterrstr = ( char * )bson_malloc( bson_iterator_string_len( &it ) ); if( conn->lasterrstr ) { strcpy( conn->lasterrstr, bson_iterator_string( &it ) ); } if( bson_find( &it, &out, "code" ) != BSON_NULL ) conn->lasterrcode = bson_iterator_int( &it ); } } if( realout ) *realout = out; /* transfer of ownership */ else bson_destroy( &out ); if( haserror ) return MONGO_ERROR; else return MONGO_OK; }
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" ); } }
void testCheckDuplicates(void) { bson bs, bs2; bson_iterator it; bson_type bt; bson_init(&bs); bson_append_string(&bs, "a", "a"); bson_append_int(&bs, "b", 2); bson_append_null(&bs, "c"); bson_append_start_object(&bs, "d"); bson_append_string(&bs, "a", "a"); bson_append_int(&bs, "e", 0); bson_append_int(&bs, "d", 1); bson_append_finish_object(&bs); bson_finish(&bs); CU_ASSERT_FALSE_FATAL(bs.err); CU_ASSERT_FALSE(bson_check_duplicate_keys(&bs)); bson_destroy(&bs); bson_init(&bs); bson_append_string(&bs, "a", "a"); bson_append_int(&bs, "b", 2); bson_append_null(&bs, "c"); bson_append_start_object(&bs, "d"); bson_append_string(&bs, "a", "a"); bson_append_int(&bs, "e", 0); bson_append_int(&bs, "e", 1); bson_append_finish_object(&bs); bson_finish(&bs); CU_ASSERT_FALSE_FATAL(bs.err); CU_ASSERT_TRUE(bson_check_duplicate_keys(&bs)); bson_init(&bs2); bson_fix_duplicate_keys(&bs, &bs2); bson_finish(&bs2); CU_ASSERT_FALSE(bson_check_duplicate_keys(&bs2)); BSON_ITERATOR_INIT(&it, &bs2); bt = bson_find_fieldpath_value("d.e", &it); CU_ASSERT_TRUE(BSON_IS_NUM_TYPE(bt)); CU_ASSERT_EQUAL(bson_iterator_int(&it), 1); bson_destroy(&bs2); bson_init(&bs); bson_append_string(&bs, "a", "a"); bson_append_int(&bs, "b", 2); bson_append_null(&bs, "c"); bson_append_start_object(&bs, "d"); bson_append_string(&bs, "a", "a"); bson_append_int(&bs, "e", 0); bson_append_int(&bs, "d", 1); bson_append_finish_object(&bs); bson_append_start_array(&bs, "f"); bson_append_start_object(&bs, "0"); bson_append_string(&bs, "a", "a"); bson_append_string(&bs, "b", "b"); bson_append_int(&bs, "c", 1); bson_append_finish_object(&bs); bson_append_start_object(&bs, "1"); bson_append_string(&bs, "a", "a"); bson_append_string(&bs, "b", "b"); bson_append_int(&bs, "c", 1); bson_append_finish_object(&bs); bson_append_finish_array(&bs); bson_finish(&bs); CU_ASSERT_FALSE_FATAL(bs.err); CU_ASSERT_FALSE(bson_check_duplicate_keys(&bs)); bson_init(&bs); bson_append_string(&bs, "a", "a"); bson_append_int(&bs, "b", 2); bson_append_null(&bs, "c"); bson_append_start_object(&bs, "d"); bson_append_string(&bs, "a", "a"); bson_append_int(&bs, "e", 0); bson_append_int(&bs, "d", 1); bson_append_start_object(&bs, "q"); bson_append_int(&bs, "w", 0); bson_append_finish_object(&bs); bson_append_finish_object(&bs); bson_append_start_array(&bs, "f"); bson_append_start_object(&bs, "0"); bson_append_string(&bs, "a", "a"); bson_append_string(&bs, "b", "b"); bson_append_int(&bs, "a", 1); bson_append_finish_object(&bs); bson_append_start_object(&bs, "1"); bson_append_string(&bs, "a", "a"); bson_append_string(&bs, "b", "b"); bson_append_int(&bs, "c", 1); bson_append_finish_object(&bs); bson_append_finish_array(&bs); bson_append_start_object(&bs, "a"); bson_append_finish_object(&bs); bson_append_start_object(&bs, "d"); bson_append_start_object(&bs, "q"); bson_append_int(&bs, "e", 1); bson_append_finish_object(&bs); bson_append_finish_object(&bs); bson_finish(&bs); CU_ASSERT_FALSE_FATAL(bs.err); CU_ASSERT_TRUE(bson_check_duplicate_keys(&bs)); bson_init(&bs2); bson_fix_duplicate_keys(&bs, &bs2); bson_finish(&bs2); CU_ASSERT_FALSE(bson_check_duplicate_keys(&bs2)); BSON_ITERATOR_INIT(&it, &bs2); bt = bson_find_fieldpath_value("f.0.a", &it); CU_ASSERT_TRUE(BSON_IS_NUM_TYPE(bt)); CU_ASSERT_EQUAL(bson_iterator_int(&it), 1); BSON_ITERATOR_INIT(&it, &bs2); bt = bson_find_fieldpath_value("f.1.a", &it); CU_ASSERT_TRUE(BSON_IS_STRING_TYPE(bt)); CU_ASSERT_FALSE(strcmp(bson_iterator_string(&it), "a")); BSON_ITERATOR_INIT(&it, &bs2); bt = bson_find_fieldpath_value("a", &it); CU_ASSERT_EQUAL(bt, BSON_OBJECT); BSON_ITERATOR_INIT(&it, &bs2); bt = bson_find_fieldpath_value("d.q.w", &it); CU_ASSERT_TRUE(BSON_IS_NUM_TYPE(bt)); CU_ASSERT_EQUAL(bson_iterator_int(&it), 0); BSON_ITERATOR_INIT(&it, &bs2); bt = bson_find_fieldpath_value("d.q.e", &it); CU_ASSERT_TRUE(BSON_IS_NUM_TYPE(bt)); CU_ASSERT_EQUAL(bson_iterator_int(&it), 1); }
static int mongo_cursor_op_query( mongo_cursor *cursor ) { int res; bson empty; char *data; mongo_message *mm; bson temp; bson_iterator it; /* Clear any errors. */ bson_free( cursor->conn->lasterrstr ); cursor->conn->lasterrstr = NULL; cursor->conn->lasterrcode = 0; cursor->conn->err = 0; cursor->err = 0; /* Set up default values for query and fields, if necessary. */ if( ! cursor->query ) cursor->query = bson_empty( &empty ); else if( mongo_cursor_bson_valid( cursor, cursor->query ) != MONGO_OK ) return MONGO_ERROR; if( ! cursor->fields ) cursor->fields = bson_empty( &empty ); else if( mongo_cursor_bson_valid( cursor, cursor->fields ) != MONGO_OK ) return MONGO_ERROR; mm = mongo_message_create( 16 + /* header */ 4 + /* options */ strlen( cursor->ns ) + 1 + /* ns */ 4 + 4 + /* skip,return */ bson_size( cursor->query ) + bson_size( cursor->fields ) , 0 , 0 , MONGO_OP_QUERY ); data = &mm->data; data = mongo_data_append32( data , &cursor->options ); data = mongo_data_append( data , cursor->ns , strlen( cursor->ns ) + 1 ); data = mongo_data_append32( data , &cursor->skip ); data = mongo_data_append32( data , &cursor->limit ); data = mongo_data_append( data , cursor->query->data , bson_size( cursor->query ) ); if ( cursor->fields ) data = mongo_data_append( data , cursor->fields->data , bson_size( cursor->fields ) ); bson_fatal_msg( ( data == ( ( char * )mm ) + mm->head.len ), "query building fail!" ); res = mongo_message_send( cursor->conn , mm ); if( res != MONGO_OK ) { return MONGO_ERROR; } res = mongo_read_response( cursor->conn, ( mongo_reply ** )&( cursor->reply ) ); if( res != MONGO_OK ) { return MONGO_ERROR; } if( cursor->reply->fields.num == 1 ) { bson_init_data( &temp, &cursor->reply->objs ); if( bson_find( &it, &temp, "$err" ) ) { cursor->conn->lasterrstr = (char *)bson_malloc( bson_iterator_string_len( &it ) ); strcpy( cursor->conn->lasterrstr, bson_iterator_string( &it ) ); bson_find( &it, &temp, "code" ); cursor->conn->lasterrcode = bson_iterator_int( &it ); cursor->err = MONGO_CURSOR_QUERY_FAIL; return MONGO_ERROR; } } cursor->seen += cursor->reply->fields.num; cursor->flags |= MONGO_CURSOR_QUERY_SENT; return MONGO_OK; }
uint8_t XTDBUpdate(XTDBHandle* handle,bson* query,bson* newVal,uint8_t upsert) { XTDBCursor* cur ; BinaryStr key,value,newValueStr; uint8_t updated = False,ret=True; int nUpdated = 0; bson_oid_t oid; bson withOid; int isMod; XTDBUpdateStatus status; status.upserted = False; _S_FN(update); handle->lastOp = XTDB_OP_UPDATE; if (!(cur = XTDBFind(handle,query))) { return False; } BsonToBStr(newVal,&newValueStr); if ((handle->error = ObjModValidateValBson(newVal,&isMod))) { return False; } while (XTDBCursorNextBStr(cur,&key,&value)) { handle->gen++; //updated = True; // retain the oid with new object if (!isMod) { memcpy(oid.bytes,key.data,sizeof(oid.bytes)); if(!XTDBBsonAppendOid(handle,newVal,&withOid,&oid)) { return False; } } else { bson obj; bson error; bson outObj; BStrToBson(&value,&obj); handle->error = ObjModifyBson(&obj,newVal,&withOid,&error); if (handle->error) { bson_iterator itr; bson_iterator_init(&itr,&error); bson_find(&itr,&error,"error"); strncpy(handle->errorString,bson_iterator_string(&itr),sizeof(handle->errorString)); bson_destroy(&error); return False; } } BsonToBStr(&withOid,&newValueStr); // Remove entry from index and re-insert if (!XTDBUpdateIndex(handle,&key,&newValueStr,&value)) { XTDBCursorFree(cur); BinaryStrFree(&key); BinaryStrFree(&value); bson_destroy(&withOid); return False; } //XTDBInsertToIndex(handle,&key,&newValueStr); //XTDBRemoveFromIndex(handle,&key,&value); if (!DBSet(handle->mainDB,&key,&newValueStr,False)) { XTDBCursorFree(cur); BinaryStrFree(&key); BinaryStrFree(&value); bson_destroy(&withOid); handle->error = DBGetLastError(handle->mainDB); return False; } BinaryStrFree(&key); BinaryStrFree(&value); bson_destroy(&withOid); nUpdated++; } if (cur->error != XTDB_OK) { handle->error = cur->error; return False; } if ( !nUpdated && upsert) { ret = XTDBInsert(handle,newVal); memcpy(&status.newOid,&handle->status.insertStatus.newOid,sizeof(status.newOid)); status.upserted = True; nUpdated = 1; } status.nUpdated = nUpdated; handle->lastOp = XTDB_OP_UPDATE; handle->status.updateStatus = status; XTDBCursorFree(cur); _E_FN(update); return ret; }
const char *gridfile_get_md5( gridfile *gfile ) { bson_iterator it; bson_find( &it, gfile->meta, "md5" ); return bson_iterator_string( &it ); }
void testBSONExportImport2(void) { EJDB *jb = ejdbnew(); CU_ASSERT_TRUE_FATAL(ejdbopen(jb, "dbt4_export", JBOWRITER | JBOCREAT | JBOTRUNC)); EJCOLL *coll = ejdbcreatecoll(jb, "col1", NULL); if (!coll) { eprint(jb, __LINE__, "testBSONExportImport2"); } CU_ASSERT_TRUE(coll != NULL); bson_oid_t oid; const char *log = NULL; bson bv1; bson_init(&bv1); bson_append_int(&bv1, "a", 1); bson_append_string(&bv1, "c", "d"); bson_finish(&bv1); ejdbsavebson(coll, &bv1, &oid); bson_destroy(&bv1); EJCOLLOPTS copts = {0}; copts.large = true; copts.records = 200000; coll = ejdbcreatecoll(jb, "col2", &copts); if (!coll) { eprint(jb, __LINE__, "testBSONExportImport2"); } CU_ASSERT_TRUE(coll != NULL); CU_ASSERT_TRUE(ejdbsetindex(coll, "f", JBIDXSTR | JBIDXNUM)); bson_init(&bv1); bson_append_int(&bv1, "e", 1); bson_append_string(&bv1, "f", "g"); bson_finish(&bv1); ejdbsavebson(coll, &bv1, &oid); bson_destroy(&bv1); bson_init(&bv1); bson_append_int(&bv1, "e", 2); bson_append_string(&bv1, "f", "g2"); bson_finish(&bv1); ejdbsavebson(coll, &bv1, &oid); bson_destroy(&bv1); bson cmd; bson_init(&cmd); bson_append_start_object(&cmd, "export"); bson_append_string(&cmd, "path", "testBSONExportImport2"); bson_append_start_array(&cmd, "cnames"); bson_append_string(&cmd, "0", "col1"); bson_append_string(&cmd, "1", "col2"); bson_append_finish_array(&cmd); bson_append_finish_object(&cmd); bson_finish(&cmd); bson *bret = ejdbcommand(jb, &cmd); CU_ASSERT_PTR_NOT_NULL_FATAL(bret); bson_destroy(&cmd); bson_iterator it; bson_iterator_init(&it, bret); CU_ASSERT_TRUE(bson_find_fieldpath_value("error", &it) == BSON_EOO); bson_iterator_init(&it, bret); CU_ASSERT_TRUE(bson_compare_long(0, bson_data(bret), "errorCode") == 0); bson_iterator_init(&it, bret); CU_ASSERT_TRUE(bson_find_fieldpath_value("log", &it) == BSON_STRING); bson_del(bret); bson *ometa = ejdbmeta(jb); CU_ASSERT_TRUE_FATAL(ometa != NULL); ejdbclose(jb); ejdbdel(jb); //Restore data: jb = ejdbnew(); CU_ASSERT_TRUE_FATAL(ejdbopen(jb, "dbt4_export", JBOWRITER | JBOCREAT)); coll = ejdbgetcoll(jb, "col1"); CU_ASSERT_PTR_NOT_NULL_FATAL(coll); bson_init(&bv1); bson_append_int(&bv1, "e", 2); bson_finish(&bv1); CU_ASSERT_TRUE(ejdbsavebson(coll, &bv1, &oid)); bson_destroy(&bv1); bson_init(&cmd); bson_append_start_object(&cmd, "import"); bson_append_string(&cmd, "path", "testBSONExportImport2"); bson_append_int(&cmd, "mode", JBIMPORTREPLACE); bson_append_start_array(&cmd, "cnames"); bson_append_string(&cmd, "0", "col1"); bson_append_string(&cmd, "1", "col2"); bson_append_finish_array(&cmd); bson_append_finish_object(&cmd); bson_finish(&cmd); bret = ejdbcommand(jb, &cmd); CU_ASSERT_PTR_NOT_NULL_FATAL(bret); bson_destroy(&cmd); bson_iterator_init(&it, bret); CU_ASSERT_TRUE_FATAL(bson_find_fieldpath_value("log", &it) == BSON_STRING); log = bson_iterator_string(&it); CU_ASSERT_PTR_NOT_NULL(strstr(log, "Replacing all data in 'col1'")); CU_ASSERT_PTR_NOT_NULL(strstr(log, "1 objects imported into 'col1'")); CU_ASSERT_PTR_NOT_NULL(strstr(log, "2 objects imported into 'col2'")); bson_del(bret); log = NULL; bson *nmeta = ejdbmeta(jb); CU_ASSERT_TRUE_FATAL(nmeta != NULL); CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.0.name", strlen("collections.0.name")) == 0); CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.0.records", strlen("collections.0.records")) == 0); CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.name", strlen("collections.1.name")) == 0); CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.records", strlen("collections.1.records")) == 0); CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.options.buckets", strlen("collections.1.options.buckets")) == 0); CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.options.large", strlen("collections.1.options.large")) == 0); CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.indexes.0.field", strlen("collections.1.indexes.0.field")) == 0); CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.indexes.0.type", strlen("collections.1.indexes.0.type")) == 0); CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.indexes.0.records", strlen("collections.1.indexes.0.records")) == 0); CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.indexes.1.field", strlen("collections.1.indexes.1.field")) == 0); CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.indexes.1.type", strlen("collections.1.indexes.1.type")) == 0); CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.indexes.1.records", strlen("collections.1.indexes.1.records")) == 0); ejdbclose(jb); ejdbdel(jb); jb = ejdbnew(); CU_ASSERT_TRUE_FATAL(ejdbopen(jb, "dbt4_export", JBOWRITER | JBOCREAT | JBOTRUNC)); coll = ejdbcreatecoll(jb, "col1", NULL); CU_ASSERT_PTR_NOT_NULL_FATAL(coll); bson_init(&bv1); bson_append_int(&bv1, "e", 2); bson_finish(&bv1); CU_ASSERT_TRUE(ejdbsavebson(coll, &bv1, &oid)); EJQ *q = ejdbcreatequery(jb, &bv1, NULL, 0, NULL); CU_ASSERT_PTR_NOT_NULL_FATAL(q); uint32_t count = 0; ejdbqryexecute(coll, q, &count, JBQRYCOUNT, NULL); CU_ASSERT_EQUAL(count, 1); bson_init(&cmd); bson_append_start_object(&cmd, "import"); bson_append_string(&cmd, "path", "testBSONExportImport2"); bson_append_int(&cmd, "mode", JBIMPORTUPDATE); bson_append_finish_object(&cmd); bson_finish(&cmd); bret = ejdbcommand(jb, &cmd); CU_ASSERT_PTR_NOT_NULL_FATAL(bret); bson_destroy(&cmd); bson_del(bret); coll = ejdbcreatecoll(jb, "col1", NULL); ejdbqryexecute(coll, q, &count, JBQRYCOUNT, NULL); CU_ASSERT_EQUAL(count, 1); ejdbquerydel(q); bson_destroy(&bv1); ejdbclose(jb); ejdbdel(jb); bson_del(ometa); bson_del(nmeta); }
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),"}"); }
duo_code_t duo_login(struct duo_ctx *ctx, const char *username, const char *client_ip, int flags, const char *command) { bson obj; bson_iterator it; duo_code_t ret; char buf[256]; char *pushinfo = NULL; const char *p; int i; const char *local_ip; if (username == NULL) { _duo_seterr(ctx, "need username to authenticate"); return (DUO_CLIENT_ERROR); } /* Check preauth status */ if ((ret = _duo_preauth(ctx, &obj, username, client_ip)) != DUO_CONTINUE) { return (ret); } /* Handle factor selection */ if ((ret = _duo_prompt(ctx, &obj, flags, buf, sizeof(buf), &p)) != DUO_CONTINUE) { return (ret); } /* Add request parameters */ if (duo_add_param(ctx, "user", username) != DUO_OK || duo_add_param(ctx, "factor", "auto") != DUO_OK || duo_add_param(ctx, "auto", p) != DUO_OK || duo_add_param(ctx, "async", (flags & DUO_FLAG_SYNC) ? "0" : "1") != DUO_OK) { return (DUO_LIB_ERROR); } /* Add client IP, if passed in */ if (client_ip) { if (duo_add_param(ctx, "ipaddr", client_ip) != DUO_OK) { return (DUO_LIB_ERROR); } } /* Add pushinfo parameters */ local_ip = duo_local_ip(); if (asprintf(&pushinfo, "Server+IP=%s&Command=%s", local_ip, command ? urlenc_encode(command) : "") < 0 || duo_add_param(ctx, "pushinfo", pushinfo) != DUO_OK) { return (DUO_LIB_ERROR); } free(pushinfo); /* Try Duo authentication */ if ((ret = duo_call(ctx, "POST", DUO_API_VERSION "/auth.bson")) != DUO_OK || (ret = _duo_bson_response(ctx, &obj)) != DUO_OK) { return (ret); } /* Handle sync status */ if ((flags & DUO_FLAG_SYNC) != 0) { _BSON_FIND(ctx, &it, &obj, "status", bson_string); if (ctx->conv_status != NULL) { ctx->conv_status(ctx->conv_arg, bson_iterator_string(&it)); } _BSON_FIND(ctx, &it, &obj, "result", bson_string); p = bson_iterator_string(&it); if (strcasecmp(p, "allow") == 0) { ret = DUO_OK; } else if (strcasecmp(p, "deny") == 0) { ret = DUO_FAIL; } else { _duo_seterr(ctx, "BSON invalid 'result': %s", p); ret = DUO_SERVER_ERROR; } return (ret); } /* Async status - long-poll on txid */ _BSON_FIND(ctx, &it, &obj, "txid", bson_string); p = bson_iterator_string(&it); if (strlcpy(buf, p, sizeof(buf)) >= sizeof(buf)) { return (DUO_LIB_ERROR); } /* XXX newline between prompt and async status lines */ if (ctx->conv_status != NULL) ctx->conv_status(ctx->conv_arg, ""); ret = DUO_SERVER_ERROR; for (i = 0; i < 20; i++) { if ((ret = duo_add_param(ctx, "txid", buf)) != DUO_OK || (ret = duo_call(ctx, "GET", DUO_API_VERSION "/status.bson")) != DUO_OK || (ret = _duo_bson_response(ctx, &obj)) != DUO_OK) { break; } if (bson_find(&it, &obj, "status") == bson_string) { if (ctx->conv_status != NULL) ctx->conv_status(ctx->conv_arg, bson_iterator_string(&it)); } if (bson_find(&it, &obj, "result") == bson_string) { p = bson_iterator_string(&it); if (strcasecmp(p, "allow") == 0) { ret = DUO_OK; } else if (strcasecmp(p, "deny") == 0) { ret = DUO_FAIL; } else { _duo_seterr(ctx, "BSON invalid 'result': %s", p); ret = DUO_SERVER_ERROR; } break; } } return (ret); }
INT32 migExport::_run( const CHAR *pCSName, const CHAR *pCLName, INT32 &total ) { INT32 rc = SDB_OK ; const CHAR *pTemp = NULL ; bson obj ; bson_iterator it ; bson_type type ; bson_init( &obj ) ; if ( ( pCSName == NULL && pCLName == NULL ) || ( pCSName == NULL && pCLName != NULL ) ) { //never cs cl rc = _getCSList() ; if ( rc ) { PD_LOG ( PDERROR, "Failed to get collection space list, rc = %d", rc ) ; goto error ; } while( TRUE ) { rc = sdbNext( _gCSList, &obj ) ; if ( rc ) { if ( SDB_DMS_EOC != rc ) { PD_LOG ( PDERROR, "Failed to get collection space list, rc = %d", rc ) ; goto error ; } else { rc = SDB_OK ; goto done ; } } type = bson_find( &it, &obj, "Name" ) ; if ( type != BSON_STRING ) { rc = SDB_SYS ; PD_LOG ( PDERROR, "List collection space does not string, rc = %d", rc ) ; goto error ; } pTemp = bson_iterator_string( &it ) ; rc = _run( pTemp, pCLName, total ) ; if ( rc ) { PD_LOG ( PDERROR, "Faild to call _run, rc = %d", rc ) ; goto error ; } } } else if ( pCSName != NULL && pCLName == NULL ) { //cs rc = _getCLList() ; if ( rc ) { PD_LOG ( PDERROR, "Failed to get collection list, rc = %d", rc ) ; goto error ; } while ( TRUE ) { rc = sdbNext( _gCLList, &obj ) ; if ( rc ) { if ( SDB_DMS_EOC != rc ) { PD_LOG ( PDERROR, "Failed to get collection list, rc = %d", rc ) ; goto error ; } else { rc = SDB_OK ; goto done ; } } type = bson_find( &it, &obj, "Name" ) ; if ( type != BSON_STRING ) { rc = SDB_SYS ; PD_LOG ( PDERROR, "List collection does not string, rc = %d", rc ) ; goto error ; } pTemp = bson_iterator_string( &it ) ; rc = _run( pCSName, pTemp, total ) ; if ( rc ) { PD_LOG ( PDERROR, "Faild to call _run, rc = %d", rc ) ; goto error ; } } } else { //cs and cl rc = _exportCL( pCSName, pCLName, total ) ; if ( rc ) { PD_LOG ( PDERROR, "Faild to call _export, rc = %d", rc ) ; goto error ; } } done: bson_destroy ( &obj ) ; return rc ; error: goto done ; }
/** * \brief This function tries to load tag from MongoDB */ static void vs_mongo_tag_load_data(struct VSTag *tag, bson *bson_tag) { bson_iterator tag_iter; if( bson_find(&tag_iter, bson_tag, "data") == BSON_ARRAY) { bson_iterator data_iter; uint8 val_uint8; uint16 val_uint16; uint32 val_uint32; uint64 val_uint64; real32 val_real32; real64 val_real64; const char *str_value; int value_index = 0; bson_iterator_subiterator(&tag_iter, &data_iter); /* Go through all values */ switch(tag->data_type) { case VRS_VALUE_TYPE_UINT8: while( bson_iterator_next(&data_iter) == BSON_INT ) { val_uint8 = (uint8)bson_iterator_int(&data_iter); vs_tag_set_values(tag, 1, value_index, &val_uint8); value_index++; } break; case VRS_VALUE_TYPE_UINT16: while( bson_iterator_next(&data_iter) == BSON_INT ) { val_uint16 = (uint16)bson_iterator_int(&data_iter); vs_tag_set_values(tag, 1, value_index, &val_uint16); value_index++; } break; case VRS_VALUE_TYPE_UINT32: while( bson_iterator_next(&data_iter) == BSON_INT ) { val_uint32 = (uint32)bson_iterator_int(&data_iter); vs_tag_set_values(tag, 1, value_index, &val_uint32); value_index++; } break; case VRS_VALUE_TYPE_UINT64: while( bson_iterator_next(&data_iter) == BSON_LONG ) { val_uint64 = (uint64)bson_iterator_long(&data_iter); vs_tag_set_values(tag, 1, value_index, &val_uint64); value_index++; } break; case VRS_VALUE_TYPE_REAL16: /* TODO: add support for float16 */ break; case VRS_VALUE_TYPE_REAL32: while( bson_iterator_next(&data_iter) == BSON_DOUBLE ) { val_real32 = (real32)bson_iterator_double(&data_iter); vs_tag_set_values(tag, 1, value_index, &val_real32); value_index++; } break; case VRS_VALUE_TYPE_REAL64: while( bson_iterator_next(&data_iter) == BSON_DOUBLE ) { val_real64 = (real64)bson_iterator_double(&data_iter); vs_tag_set_values(tag, 1, value_index, &val_real64); value_index++; } break; case VRS_VALUE_TYPE_STRING8: str_value = bson_iterator_string(&data_iter); strcpy(tag->value, str_value); break; } } }