int mongodb_update_key_stat(bot_t * bot, char *db, char *key, int value) { bson b; bson_iterator i; mongo_cursor cursor; int ret = 0; if (!db || !key || value < 0) { return -1; } debug(bot, "mongodb_update_key_stat: Entered\n"); 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) { mongodb_insert_key_stat(bot, db, key, 0); mongo_cursor_init(&cursor, &gi->mongo_conn, db); mongo_cursor_set_query(&cursor, &b); if (mongo_cursor_next(&cursor) != MONGO_OK) goto cleanup; } debug(bot, "mongodb_update_key_stat: Found!\n"); if (bson_find(&i, mongo_cursor_bson(&cursor), "value")) { bson c; ret = (int)bson_iterator_int(&i); ret++; bson_init(&c); bson_append_string(&c, "key", key); bson_append_int(&c, "value", ret); bson_finish(&c); debug(bot, "mongodb_update_key_stat: updating to %i\n", ret); mongo_update(&gi->mongo_conn, db, &b, &c, 0); bson_destroy(&c); bson_destroy(&b); mongo_cursor_destroy(&cursor); return ret; } debug(bot, "mongodb_update_key_stat: Key not found\n"); cleanup: bson_destroy(&b); mongo_cursor_destroy(&cursor); return -1; }
int test_builder_api( mongo *conn ) { int count = 0; mongo_cursor cursor[1]; remove_sample_data( conn ); insert_sample_data( conn, 10000 ); mongo_cursor_init( cursor, conn, "test.cursors" ); while( mongo_cursor_next( cursor ) == MONGO_OK ) { count++; } ASSERT( count == 10000 ); mongo_cursor_destroy( cursor ); mongo_cursor_init( cursor, conn, "test.cursors" ); mongo_cursor_set_limit( cursor, 10 ); count = 0; while( mongo_cursor_next( cursor ) == MONGO_OK ) { count++; } ASSERT( count == 10 ); mongo_cursor_destroy( cursor ); return 0; }
static void find_range( const char *ns ) { int i; bson bb; mongo_cursor *cursor; for ( i=0; i < PER_TRIAL; i++ ) { int j=0; bson_init( &bb ); bson_append_start_object( &bb, "x" ); bson_append_int( &bb, "$gt", PER_TRIAL/2 ); bson_append_int( &bb, "$lt", PER_TRIAL/2 + BATCH_SIZE ); bson_append_finish_object( &bb ); bson_finish( &bb ); cursor = mongo_find( conn, ns, &bb, NULL, 0,0,0 ); ASSERT( cursor ); while( mongo_cursor_next( cursor ) == MONGO_OK ) { j++; } ASSERT( j == BATCH_SIZE-1 ); mongo_cursor_destroy( cursor ); bson_destroy( &bb ); } }
scale_t *get_signatures(mongo *conn) { scale_t *scales; bson query[1]; mongo_cursor cursor[1]; bson_init(query); bson_finish(query); mongo_cursor_init(cursor, conn, "1101.scales"); mongo_cursor_set_query(cursor, query); int num_scales = 0; while (mongo_cursor_next(cursor) == MONGO_OK) { num_scales++; scales = (scale_t *) realloc(scales, sizeof(scale_t) * num_scales); bson_iterator iterator[1]; bson b[1]; bson_init(b); int i; if (bson_find(iterator, mongo_cursor_bson(cursor), "name")) { printf("name: %s, scale: ", bson_iterator_string(iterator)); strcpy(scales[num_scales - 1].description, bson_iterator_string(iterator)); } if (bson_find(iterator, mongo_cursor_bson(cursor), "scale")) { int scale = bson_iterator_int(iterator); scales[num_scales - 1].mask = scale; for (i = 11; i >= 0; i--) { printf("%s", (scale >> i) & 1 ? "1" : "0"); } printf("\n"); } }
int users_search(mongo* conn, User* users, int limit) { int pos = 0; mongo_cursor cursor[1]; bson_iterator iterator[1]; mongo_cursor_init(cursor, conn, "ruby-mongo-console.users"); // mongo_cursor_set_query mongo_cursor_set_limit(cursor, limit); while(mongo_cursor_next(cursor) == MONGO_OK) { const char* s; s = get_field_value(iterator, cursor, "name"); if (s) { users[pos].name_len = strlen(s); users[pos].name = new_str(s, users[pos].name_len); } else { users[pos].name_len = 0; users[pos].name = NULL; } s = get_field_value(iterator, cursor, "bio"); if (s) { users[pos].bio_len = strlen(s); users[pos].bio = new_str(s, users[pos].bio_len); } else { users[pos].bio_len = 0; users[pos].bio = NULL; } pos++; } mongo_cursor_destroy(cursor); return pos; }
int inode_exists(const char * path) { bson query, fields; mongo * conn = get_conn(); mongo_cursor curs; int res; bson_init(&query); bson_append_string(&query, "dirents", path); bson_finish(&query); bson_init(&fields); bson_append_int(&fields, "dirents", 1); bson_append_int(&fields, "_id", 0); bson_finish(&fields); mongo_cursor_init(&curs, conn, inodes_name); mongo_cursor_set_query(&curs, &query); mongo_cursor_set_fields(&curs, &fields); mongo_cursor_set_limit(&curs, 1); res = mongo_cursor_next(&curs); bson_destroy(&query); bson_destroy(&fields); mongo_cursor_destroy(&curs); if(res == 0) return 0; if(curs.err != MONGO_CURSOR_EXHAUSTED) return -EIO; return -ENOENT; }
static int result_iterator(lua_State *L) { MongoCursor *cursor = userdata_to_cursor(L, lua_upvalueindex(1)); // mongo_cursor_set_fields(&cursor->cursor, &cursor->fields); // 为了配合接口,根本就不能这样使用 // mongo_cursor_set_query(&cursor->cursor, &cursor->query); // bool has_more = true; char key[64] = {'\0'}; // lua_newtable(L); // root {} // long index = 0, n = 1; // while (MONGO_OK == mongo_cursor_next(&(cursor->cursor))) { // if (has_more) has_more = false; // // printf("$_$---\n");bson_print(&(cursor->cursor).current); printf("------^-^------\n"); // // sprintf(key, "%l", index); // // ltoa(index, &key[1], 10);printf("[%s %d]%s\n", __FILE__, __LINE__, key); // // lua_pushstring(L, key); // // // bson_print(&(cursor->cursor).current); // printf("[%s %d]%d\n", __FILE__, __LINE__, index); // bson_to_lua(L, &(cursor->cursor).current); // equal to push the value // lua_rawseti(L, -2, n++); // index++; // } // if (has_more) lua_pushnil(L); if (MONGO_OK == mongo_cursor_next(&(cursor->cursor))) { bson_to_lua(L, &(cursor->cursor).current); } else { lua_pushnil(L); } return 1; }
SEXP rmongo_cursor_next(SEXP cursor) { mongo_cursor* _cursor = _checkCursor(cursor); SEXP ret; PROTECT(ret = allocVector(LGLSXP, 1)); LOGICAL(ret)[0] = (_cursor && mongo_cursor_next(_cursor) == MONGO_OK); UNPROTECT(1); return ret; }
int test_tailable( mongo *conn ) { mongo_cursor *cursor; bson b; int count; remove_sample_data( conn ); create_capped_collection( conn ); insert_sample_data( conn, 10000 ); bson_init( &b ); bson_append_start_object( &b, "$query" ); bson_append_finish_object( &b ); bson_append_start_object( &b, "$sort" ); bson_append_int( &b, "$natural", -1 ); bson_append_finish_object( &b ); bson_finish( &b ); cursor = mongo_find( conn, "test.cursors", &b, bson_shared_empty( ), 0, 0, MONGO_TAILABLE ); bson_destroy( &b ); count = 0; while( mongo_cursor_next( cursor ) == MONGO_OK ) count++; ASSERT( count == 10000 ); ASSERT( mongo_cursor_next( cursor ) == MONGO_ERROR ); ASSERT( cursor->err == MONGO_CURSOR_PENDING ); insert_sample_data( conn, 10 ); count = 0; while( mongo_cursor_next( cursor ) == MONGO_OK ) { count++; } ASSERT( count == 10 ); ASSERT( mongo_cursor_next( cursor ) == MONGO_ERROR ); ASSERT( cursor->err == MONGO_CURSOR_PENDING ); mongo_cursor_destroy( cursor ); remove_sample_data( conn ); return 0; }
result_t MongoCursor::_nextCursor(int32_t &retVal, AsyncEvent *ac) { if (!ac) return CHECK_ERROR(CALL_E_NOSYNC); retVal = mongo_cursor_next(m_cursor); return 0; }
static void tutorial_empty_query( mongo *conn) { mongo_cursor cursor[1]; mongo_cursor_init( cursor, conn, "tutorial.persons" ); while( mongo_cursor_next( cursor ) == MONGO_OK ) bson_print( &cursor->current ); mongo_cursor_destroy( cursor ); }
//------------------------------------------------------------------------------ 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; }
gridfs_offset gridfile_read(gridfile* gfile, gridfs_offset size, char* buf) { mongo_cursor* chunks; bson chunk; int first_chunk; int last_chunk; int total_chunks; gridfs_offset chunksize; gridfs_offset contentlength; gridfs_offset bytes_left; int i; bson_iterator it; gridfs_offset chunk_len; const char * chunk_data; contentlength = gridfile_get_contentlength(gfile); chunksize = gridfile_get_chunksize(gfile); size = (contentlength - gfile->pos < size) ? contentlength - gfile->pos : size; bytes_left = size; first_chunk = (gfile->pos)/chunksize; last_chunk = (gfile->pos+size-1)/chunksize; total_chunks = last_chunk - first_chunk + 1; chunks = gridfile_get_chunks(gfile, first_chunk, total_chunks); for (i = 0; i < total_chunks; i++) { mongo_cursor_next(chunks); chunk = chunks->current; bson_find(&it, &chunk, "data"); chunk_len = bson_iterator_bin_len( &it ); chunk_data = bson_iterator_bin_data( &it ); if (i == 0) { chunk_data += (gfile->pos)%chunksize; chunk_len -= (gfile->pos)%chunksize; } if (bytes_left > chunk_len) { memcpy(buf, chunk_data, chunk_len); bytes_left -= chunk_len; buf += chunk_len; } else { memcpy(buf, chunk_data, bytes_left); } } mongo_cursor_destroy(chunks); gfile->pos = gfile->pos + size; return size; }
bson_bool_t mongo_find_one(mongo_connection* conn, const char* ns, bson* query, bson* fields, bson* out){ mongo_cursor* cursor = mongo_find(conn, ns, query, fields, 1, 0, 0); if (cursor && mongo_cursor_next(cursor)){ bson_copy(out, &cursor->current); mongo_cursor_destroy(cursor); return 1; }else{ mongo_cursor_destroy(cursor); return 0; } }
/* * res = cursor:next() */ static int cursor_next(lua_State *L) { MongoCursor *cursor = userdata_to_cursor(L, 1); if (MONGO_OK == mongo_cursor_next(&(cursor->cursor))) { bson_to_lua(L, &(cursor->cursor).current); } else { lua_pushnil(L); } return 1; }
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; }
int mongo_find_one( mongo *conn, const char *ns, bson *query, bson *fields, bson *out ) { mongo_cursor *cursor = mongo_find( conn, ns, query, fields, 1, 0, 0 ); if ( cursor && mongo_cursor_next( cursor ) == MONGO_OK ) { bson_copy_basic( out, &cursor->current ); mongo_cursor_destroy( cursor ); return MONGO_OK; } else { mongo_cursor_destroy( cursor ); return MONGO_ERROR; } }
int mongodb_insert_key(bot_t * bot, char *db, char *key, char *value, char *fmt, ...) { bson b; mongo_cursor cursor; va_list ap; char buf[1024], *buf_ptr = "NULL"; if (!db || !key || !value) { return -1; } debug(bot, "mongodb_insert_key: Entered\n"); if (fmt) { bz(buf); va_start(ap, fmt); vsnprintf_buf(buf, fmt, ap); va_end(ap); buf_ptr = buf; } 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) { debug(bot, "mongodb_insert_key: Key already exist\n"); bson_destroy(&b); mongo_cursor_destroy(&cursor); return -1; } bson_init(&b); bson_append_string(&b, "key", key); bson_append_string(&b, "value", value); bson_append_string(&b, "comment", buf_ptr); bson_finish(&b); mongo_insert(&gi->mongo_conn, db, &b); bson_destroy(&b); mongo_cursor_destroy(&cursor); return 0; }
int test_multiple_getmore( mongo *conn ) { mongo_cursor *cursor; int count; remove_sample_data( conn ); create_capped_collection( conn ); insert_sample_data( conn, 10000 ); cursor = mongo_find( conn, "test.cursors", bson_shared_empty( ), bson_shared_empty( ), 0, 0, 0 ); count = 0; while( mongo_cursor_next( cursor ) == MONGO_OK ) count++; ASSERT( count == 10000 ); ASSERT( mongo_cursor_next( cursor ) == MONGO_ERROR ); ASSERT( cursor->err == MONGO_CURSOR_EXHAUSTED ); mongo_cursor_destroy( cursor ); remove_sample_data( conn ); return 0; }
dlist_t *mongodb_dump_keyvalue(bot_t * bot, char *db) { dlist_t *dl, *dptr; keyvalue_t *keyvalue_ptr; mongo_cursor *cursor; bson b; bson_iterator bi; char *key; char *value; dl = dptr = NULL; cursor = NULL; if (!db) return NULL; debug(bot, "mongodb_dump_keyvalue: Entered\n"); cursor = mongo_find(&gi->mongo_conn, db, bson_empty(&b), bson_empty(&b), 0, 0, 0); while (mongo_cursor_next(cursor) == MONGO_OK) { key = value = NULL; if (bson_find(&bi, mongo_cursor_bson(cursor), "key")) { key = (char *)bson_iterator_string(&bi); } if (bson_find(&bi, mongo_cursor_bson(cursor), "value")) { value = (char *)bson_iterator_string(&bi); } if (!key && !value) continue; keyvalue_ptr = (keyvalue_t *) calloc(1, sizeof(keyvalue_t)); if (key) keyvalue_ptr->key = strdup(key); if (value) keyvalue_ptr->value = strdup(value); dlist_Dinsert_after(&dl, keyvalue_ptr); } mongo_cursor_destroy(cursor); return dl; }
static void find( const char *ns ) { bson b; int i; for ( i=0; i < PER_TRIAL; i++ ) { mongo_cursor *cursor; make_query( &b ); cursor = mongo_find( conn, ns, &b, NULL, 0,0,0 ); ASSERT( cursor ); while( mongo_cursor_next( cursor ) == MONGO_OK ) {} mongo_cursor_destroy( cursor ); bson_destroy( &b ); } }
int test_copy_cursor_data( mongo *conn ) { mongo_cursor cursor[1]; bson b[1]; insert_sample_data( conn, 10 ); mongo_cursor_init( cursor, conn, "test.cursors" ); mongo_cursor_next( cursor ); ASSERT( bson_copy( b, mongo_cursor_bson( cursor ) ) == MONGO_OK ); ASSERT( memcmp( (void *)b->data, (void *)(cursor->current).data, bson_size( &cursor->current ) ) == 0 ); mongo_cursor_destroy( cursor ); bson_destroy( b ); return 0; }
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; }
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 ); }
MONGO_EXPORT int mongo_find_one( mongo *conn, const char *ns, const bson *query, const bson *fields, bson *out ) { mongo_cursor cursor[1]; mongo_cursor_init( cursor, conn, ns ); mongo_cursor_set_query( cursor, query ); mongo_cursor_set_fields( cursor, fields ); mongo_cursor_set_limit( cursor, 1 ); if ( mongo_cursor_next( cursor ) == MONGO_OK ) { bson_init_size( out, bson_size( (bson *)&cursor->current ) ); memcpy( out->data, cursor->current.data, bson_size( (bson *)&cursor->current ) ); out->finished = 1; mongo_cursor_destroy( cursor ); return MONGO_OK; } else { mongo_cursor_destroy( cursor ); return MONGO_ERROR; } }
result_t MongoCursor::hasNext(bool &retVal) { if (!m_bInit) { result_t hr; hr = encodeObject(&m_bbq, v8::Local<v8::Object>::New(Isolate::now()->m_isolate, m_query)); if (hr < 0) return hr; m_bInit = true; } if (m_state == CUR_NONE) m_state = mongo_cursor_next(m_cursor) == MONGO_OK ? CUR_DATA : CUR_NODATA; retVal = m_state == CUR_DATA; return CHECK_ERROR(m_cursor->m_db->error()); }
int test_bad_query( mongo *conn ) { mongo_cursor cursor[1]; bson b[1]; bson_init( b ); bson_append_start_object( b, "foo" ); bson_append_int( b, "$bad", 1 ); bson_append_finish_object( b ); bson_finish( b ); mongo_cursor_init( cursor, conn, "test.cursors" ); mongo_cursor_set_query( cursor, b ); ASSERT( mongo_cursor_next( cursor ) == MONGO_ERROR ); ASSERT( cursor->err == MONGO_CURSOR_QUERY_FAIL ); ASSERT( cursor->conn->lasterrcode == 10068 ); ASSERT( strlen( cursor->conn->lasterrstr ) > 0 ); mongo_cursor_destroy( cursor ); bson_destroy( b ); return 0; }
void gridfs_remove_filename(gridfs* gfs, const char* filename ) { bson query; bson_buffer buf; mongo_cursor* files; bson file; bson_iterator it; bson_oid_t id; bson b; bson_buffer_init(&buf); bson_append_string(&buf, "filename", filename); bson_from_buffer(&query, &buf); files = mongo_find(gfs->client, gfs->files_ns, &query, NULL, 0, 0, 0); bson_destroy(&query); /* Remove each file and it's chunks from files named filename */ while (mongo_cursor_next(files)) { file = files->current; bson_find(&it, &file, "_id"); id = *bson_iterator_oid(&it); /* Remove the file with the specified id */ bson_buffer_init(&buf); bson_append_oid(&buf, "_id", &id); bson_from_buffer(&b, &buf); mongo_remove( gfs->client, gfs->files_ns, &b); bson_destroy(&b); /* Remove all chunks from the file with the specified id */ bson_buffer_init(&buf); bson_append_oid(&buf, "files_id", &id); bson_from_buffer(&b, &buf); mongo_remove( gfs->client, gfs->chunks_ns, &b); bson_destroy(&b); } }
int mongodb_retrieve_key_stat(bot_t * bot, char *db, char *key) { bson b; mongo_cursor cursor; int ret = 0; if (!db || !key) { return -1; } debug(bot, "mongodb_retrieve_key: Entered\n"); 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), "value")) { ret = (int)bson_iterator_int(&i); } bson_destroy(&b); mongo_cursor_destroy(&cursor); return ret; } debug(bot, "mongodb_retrieve_key: Key not found\n"); bson_destroy(&b); mongo_cursor_destroy(&cursor); return -1; }