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; }
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; }
/* * cursor,err = db:query(ns, query) */ int cursor_create(lua_State *L, mongo *connection, const char *ns, const Query *query, int nToReturn, int nToSkip, const QueryCursor *fieldsToReturn, int queryOptions, int batchSize) { MongoCursor **cursor = (MongoCursor **) lua_newuserdata(L, sizeof(MongoCursor *)); *cursor = (MongoCursor *)malloc(sizeof(MongoCursor)); mongo_cursor_init( &(*cursor)->cursor, connection, ns ); // mongo_cursor_set_options(*cursor, queryOptions); // mongo_cursor_set_skip( &(*cursor)->cursor, nToSkip ); // mongo_cursor_set_limit( &(*cursor)->cursor, nToReturn ); bson_copy(&(*cursor)->fields, fieldsToReturn->condition); // mongo_cursor_set_fields( (*cursor)->cursor, fieldsToReturn->condition ); bson_copy(&(*cursor)->query, query->condition); mongo_cursor_set_query( &(*cursor)->cursor, &(*cursor)->query ); // // while(mongo_cursor_next(&(*cursor)->cursor) == MONGO_OK) { // printf("iterator1: \t"); // bson_print(&((*cursor)->cursor.current)); // } luaL_getmetatable(L, LUAMONGO_CURSOR); lua_setmetatable(L, -2); return 1; }
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 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; }
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; }
MongoCursor::MongoCursor(MongoDB *db, const std::string &ns, const std::string &name, v8::Local<v8::Object> query, v8::Local<v8::Object> projection) { m_state = CUR_NONE; m_ns = ns; m_name = name; m_cursor = new cursor; m_cursor->m_db = db; mongo_cursor_init(m_cursor, &db->m_conn, ns.c_str()); v8::Local<v8::Value> _query; util_base::clone(query, _query); m_query.Reset(Isolate::now()->m_isolate, v8::Local<v8::Object>::Cast(_query)->Clone()); mongo_cursor_set_query(m_cursor, &m_bbq); encodeObject(&m_bbp, projection); mongo_cursor_set_fields(m_cursor, &m_bbp); m_bInit = false; m_bSpecial = false; }
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; }
result_t MongoCursor::_initCursor(MongoDB *db, AsyncEvent *ac) { if (!ac) return CHECK_ERROR(CALL_E_NOSYNC); m_cursor = new cursor; m_cursor->m_db = db; mongo_cursor_init(m_cursor, &(m_cursor->m_db)->m_conn, m_ns.c_str()); mongo_cursor_set_query(m_cursor, &m_bbq); mongo_cursor_set_fields(m_cursor, &m_bbp); return 0; }
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_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; }
MONGO_EXPORT mongo_cursor *mongo_find( mongo *conn, const char *ns, const bson *query, const bson *fields, int limit, int skip, int options ) { mongo_cursor *cursor = ( mongo_cursor * )bson_malloc( sizeof( mongo_cursor ) ); mongo_cursor_init( cursor, conn, ns ); cursor->flags |= MONGO_CURSOR_MUST_FREE; mongo_cursor_set_query( cursor, query ); mongo_cursor_set_fields( cursor, fields ); mongo_cursor_set_limit( cursor, limit ); mongo_cursor_set_skip( cursor, skip ); mongo_cursor_set_options( cursor, options ); if( mongo_cursor_op_query( cursor ) == MONGO_OK ) return cursor; else { 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; } }
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; }
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; }
int main() { mongo conn[1]; bson b, empty; mongo_cursor cursor[1]; unsigned char not_utf8[3]; int result = 0; const char *ns = "test.c.validate"; int i=0, j=0; bson bs[BATCH_SIZE]; bson *bp[BATCH_SIZE]; not_utf8[0] = 0xC0; not_utf8[1] = 0xC0; not_utf8[2] = '\0'; INIT_SOCKETS_FOR_WINDOWS; if ( mongo_connect( conn, TEST_SERVER, 27017 ) ) { printf( "failed to connect\n" ); exit( 1 ); } /* Test checking for finished bson. */ bson_init( &b ); bson_append_int( &b, "foo", 1 ); ASSERT( mongo_insert( conn, "test.foo", &b, NULL ) == MONGO_ERROR ); ASSERT( conn->err == MONGO_BSON_NOT_FINISHED ); bson_destroy( &b ); /* Test valid keys. */ bson_init( &b ); result = bson_append_string( &b , "a.b" , "17" ); ASSERT( result == BSON_OK ); ASSERT( b.err & BSON_FIELD_HAS_DOT ); /* Don't set INIT dollar if deb ref fields are being used. */ result = bson_append_string( &b , "$id" , "17" ); ASSERT( result == BSON_OK ); ASSERT( !(b.err & BSON_FIELD_INIT_DOLLAR) ); result = bson_append_string( &b , "$ref" , "17" ); ASSERT( result == BSON_OK ); ASSERT( !(b.err & BSON_FIELD_INIT_DOLLAR) ); result = bson_append_string( &b , "$db" , "17" ); ASSERT( result == BSON_OK ); ASSERT( !(b.err & BSON_FIELD_INIT_DOLLAR) ); result = bson_append_string( &b , "$ab" , "17" ); ASSERT( result == BSON_OK ); ASSERT( b.err & BSON_FIELD_INIT_DOLLAR ); result = bson_append_string( &b , "ab" , "this is valid utf8" ); ASSERT( result == BSON_OK ); ASSERT( ! ( b.err & BSON_NOT_UTF8 ) ); result = bson_append_string( &b , ( const char * )not_utf8, "valid" ); ASSERT( result == BSON_ERROR ); ASSERT( b.err & BSON_NOT_UTF8 ); ASSERT( bson_finish( &b ) == BSON_ERROR ); ASSERT( b.err & BSON_FIELD_HAS_DOT ); ASSERT( b.err & BSON_FIELD_INIT_DOLLAR ); ASSERT( b.err & BSON_NOT_UTF8 ); result = mongo_insert( conn, ns, &b, NULL ); ASSERT( result == MONGO_ERROR ); ASSERT( conn->err & MONGO_BSON_NOT_FINISHED ); result = mongo_update( conn, ns, bson_empty( &empty ), &b, 0, NULL ); ASSERT( result == MONGO_ERROR ); ASSERT( conn->err & MONGO_BSON_NOT_FINISHED ); mongo_cursor_init( cursor, conn, "test.cursors" ); mongo_cursor_set_query( cursor, &b ); result = mongo_cursor_next( cursor ); ASSERT( result == MONGO_ERROR ); ASSERT( cursor->err & MONGO_CURSOR_BSON_ERROR ); ASSERT( cursor->conn->err & MONGO_BSON_NOT_FINISHED ); bson_destroy( &b ); mongo_cursor_destroy( cursor ); /* Test valid strings. */ bson_init( &b ); result = bson_append_string( &b , "foo" , "bar" ); ASSERT( result == BSON_OK ); ASSERT( b.err == 0 ); result = bson_append_string( &b , "foo" , ( const char * )not_utf8 ); ASSERT( result == BSON_ERROR ); ASSERT( b.err & BSON_NOT_UTF8 ); b.err = 0; ASSERT( b.err == 0 ); result = bson_append_regex( &b , "foo" , ( const char * )not_utf8, "s" ); ASSERT( result == BSON_ERROR ); ASSERT( b.err & BSON_NOT_UTF8 ); for ( j=0; j < BATCH_SIZE; j++ ) bp[j] = &bs[j]; for ( j=0; j < BATCH_SIZE; j++ ) make_small_invalid( &bs[j], i ); result = mongo_insert_batch( conn, ns, (const bson **)bp, BATCH_SIZE, NULL, 0 ); ASSERT( result == MONGO_ERROR ); ASSERT( conn->err == MONGO_BSON_INVALID ); for ( j=0; j < BATCH_SIZE; j++ ) bson_destroy( &bs[j] ); bson_destroy( &b ); mongo_cmd_drop_db( conn, "test" ); mongo_disconnect( conn ); mongo_destroy( conn ); return 0; }
int main() { bson b, sub, out; bson_iterator it; mongo conn; mongo_cursor cursor; int result; /* Create a rich document like this one: * * { _id: ObjectId("4d95ea712b752328eb2fc2cc"), * user_id: ObjectId("4d95ea712b752328eb2fc2cd"), * * items: [ * { sku: "col-123", * name: "John Coltrane: Impressions", * price: 1099, * }, * * { sku: "young-456", * name: "Larry Young: Unity", * price: 1199 * } * ], * * address: { * street: "59 18th St.", * zip: 10010 * }, * * total: 2298 * } */ bson_init( &b ); bson_append_new_oid( &b, "_id" ); bson_append_new_oid( &b, "user_id" ); bson_append_start_array( &b, "items" ); bson_append_start_object( &b, "0" ); bson_append_string( &b, "name", "John Coltrane: Impressions" ); bson_append_int( &b, "price", 1099 ); bson_append_finish_object( &b ); bson_append_start_object( &b, "1" ); bson_append_string( &b, "name", "Larry Young: Unity" ); bson_append_int( &b, "price", 1199 ); bson_append_finish_object( &b ); bson_append_finish_object( &b ); bson_append_start_object( &b, "address" ); bson_append_string( &b, "street", "59 18th St." ); bson_append_int( &b, "zip", 10010 ); bson_append_finish_object( &b ); bson_append_int( &b, "total", 2298 ); /* Finish the BSON obj. */ bson_finish( &b ); printf("Here's the whole BSON object:\n"); bson_print( &b ); /* Advance to the 'items' array */ bson_find( &it, &b, "items" ); /* Get the subobject representing items */ bson_iterator_subobject_init( &it, &sub, 0 ); /* Now iterate that object */ printf("And here's the inner sub-object by itself.\n"); bson_print( &sub ); bson_destroy( &sub ); /* Now make a connection to MongoDB. */ if( mongo_client( &conn, "127.0.0.1", 27017 ) != MONGO_OK ) { switch( conn.err ) { case MONGO_CONN_SUCCESS: break; case MONGO_CONN_NO_SOCKET: printf( "FAIL: Could not create a socket!\n" ); break; case MONGO_CONN_FAIL: printf( "FAIL: Could not connect to mongod. Make sure it's listening at 127.0.0.1:27017.\n" ); break; default: printf( "MongoDB connection error number %d.\n", conn.err ); break; } exit( 1 ); } /* Insert the sample BSON document. */ if( mongo_insert( &conn, "test.records", &b, NULL ) != MONGO_OK ) { printf( "FAIL: Failed to insert document with error %d\n", conn.err ); exit( 1 ); } /* Query for the sample document. */ mongo_cursor_init( &cursor, &conn, "test.records" ); mongo_cursor_set_query( &cursor, bson_shared_empty() ); if( mongo_cursor_next( &cursor ) != MONGO_OK ) { printf( "FAIL: Failed to find inserted document." ); exit( 1 ); } printf( "Found saved BSON object:\n" ); bson_print( (bson *)mongo_cursor_bson( &cursor ) ); mongo_cmd_drop_collection( &conn, "test", "records", NULL ); mongo_cursor_destroy( &cursor ); bson_destroy( &b ); mongo_destroy( &conn ); return 0; }
/** * \brief This function tries to load tag group from MongoDB * * \param[in] *vs_ctx The verse server context * \param[in] *oid The pointer at ObjectID of tag group in MongoDB * \param[in] *node The node containing tag group * \param[in] taggroup_id The tag group ID that is requested from database * \param[in] version The version of tag group id that is requested * from database. When version is equal to -1, then * current version is loaded from MongoDB. * * \return This function returns pointer at tag group, when tag group is found. * Otherwise it returns NULL. */ struct VSTagGroup *vs_mongo_taggroup_load_linked(struct VS_CTX *vs_ctx, bson_oid_t *oid, struct VSNode *node, uint16 taggroup_id, uint32 req_version) { struct VSTagGroup *tg = NULL; bson query; mongo_cursor cursor; uint32 node_id = -1, tmp_taggroup_id = -1, current_version = -1, custom_type = -1; int found = 0; bson_iterator tg_data_iter; const bson *bson_tg; bson_init(&query); bson_append_oid(&query, "_id", oid); bson_finish(&query); mongo_cursor_init(&cursor, vs_ctx->mongo_conn, vs_ctx->mongo_tg_ns); mongo_cursor_set_query(&cursor, &query); /* ObjectID should be unique */ while( mongo_cursor_next(&cursor) == MONGO_OK ) { bson_tg = mongo_cursor_bson(&cursor); /* Try to get node id */ if( bson_find(&tg_data_iter, bson_tg, "node_id") == BSON_INT ) { node_id = bson_iterator_int(&tg_data_iter); } /* Try to get tag group id */ if( bson_find(&tg_data_iter, bson_tg, "taggroup_id") == BSON_INT ) { tmp_taggroup_id = bson_iterator_int(&tg_data_iter); } /* ObjectID is ALMOST unique. So it is check, if node id and * tag group id matches */ if(node_id == node->id && tmp_taggroup_id == taggroup_id) { found = 1; break; } } /* When tag group was found, then load required data from MongoDB */ if(found == 1) { /* Try to get current version of tag group */ if( bson_find(&tg_data_iter, bson_tg, "current_version") == BSON_INT ) { current_version = bson_iterator_int(&tg_data_iter); } /* Try to get custom type of tag group */ if( bson_find(&tg_data_iter, bson_tg, "custom_type") == BSON_INT ) { custom_type = bson_iterator_int(&tg_data_iter); } /* Create tag group with specific ID */ if((int)current_version != -1 && (int)custom_type != -1) { tg = vs_taggroup_create(node, taggroup_id, custom_type); if(tg != NULL) { tg->state = ENTITY_CREATED; /* Save ObjectID to tag group */ memcpy(&tg->oid, oid, sizeof(bson_oid_t)); /* Try to get versions of tag group */ if( bson_find(&tg_data_iter, bson_tg, "versions") == BSON_OBJECT ) { bson bson_versions; bson_iterator version_iter; char str_num[15]; /* Initialize sub-object of versions */ bson_iterator_subobject_init(&tg_data_iter, &bson_versions, 0); sprintf(str_num, "%u", req_version); /* Try to find required version of tag group */ if( bson_find(&version_iter, &bson_versions, str_num) == BSON_OBJECT ) { bson bson_version; /* Set version of tag group */ tg->version = tg->saved_version = current_version; bson_iterator_subobject_init(&version_iter, &bson_version, 0); /* Try to load tags */ vs_mongo_taggroup_load_data(tg, &bson_version); } } } } } bson_destroy(&query); mongo_cursor_destroy(&cursor); return tg; }
int main(int argc, char **argv) { bson b[1]; bson query[1]; mongo conn[1]; mongo_cursor cursor[1]; int result; if(mongo_client(conn, "127.0.0.1", 27017) != MONGO_OK) { switch(conn->err) { case MONGO_CONN_SUCCESS: fprintf(stderr, "OK: Connected to MongoDB!\n"); break; case MONGO_CONN_NO_SOCKET: fprintf(stderr, "FAIL: Cloud not create a socket!\n"); break; case MONGO_CONN_FAIL: fprintf(stderr, "FAIL: Could not connect to mongod!."); break; default: fprintf(stderr, "MongoDB connection error number: %d.\n", conn->err); } } bson_init(query); bson_append_string(query, "city_name", "南京"); bson_finish(query); mongo_cursor_init(cursor, conn, "bangboox.city_shop"); mongo_cursor_set_query(cursor, query); while(mongo_cursor_next(cursor) == MONGO_OK) { bson_print((bson *)mongo_cursor_bson(cursor)); } bson_init(b); bson_append_new_oid(b, "_id"); bson_append_new_oid(b, "record_id"); bson_append_start_array(b, "items"); bson_append_start_object(b, "0"); bson_append_string(b, "name", "roy.lieu"); bson_append_int(b, "age", 30); bson_append_finish_object(b); bson_append_start_object(b, "1"); bson_append_string(b, "name", "jimmy.chen"); bson_append_int(b, "age", 35); bson_append_finish_object(b); bson_append_finish_object(b); bson_append_start_object(b, "address"); bson_append_string(b, "stree", "Jufeng RD."); bson_append_int(b, "zip", 232044); bson_append_finish_object(b); bson_finish(b); //printf("\n\n"); //bson_print(b); if(mongo_insert(conn, "test.record", b, NULL) != MONGO_OK) { fprintf(stderr, "FAIL: Failed to insert document whth err: %d\n", conn->err); } return 0; }
static int resolve_block(struct inode * e, uint8_t hash[HASH_LEN], char * buf) { bson query; int res; mongo_cursor curs; bson_iterator i; bson_type bt; const char * key; mongo * conn = get_conn(); bson_init(&query); bson_append_binary(&query, "_id", 0, (char*)hash, 20); bson_finish(&query); mongo_cursor_init(&curs, conn, blocks_name); mongo_cursor_set_query(&curs, &query); mongo_cursor_set_limit(&curs, 1); res = mongo_cursor_next(&curs); bson_destroy(&query); if(res != MONGO_OK) { mongo_cursor_destroy(&curs); return -EIO; } bson_iterator_init(&i, mongo_cursor_bson(&curs)); size_t outsize, compsize = 0; const char * compdata = NULL; uint32_t offset = 0, size = 0; while((bt = bson_iterator_next(&i)) > 0) { key = bson_iterator_key(&i); if(strcmp(key, "data") == 0) { compsize = bson_iterator_bin_len(&i); compdata = bson_iterator_bin_data(&i); } else if(strcmp(key, "offset") == 0) offset = bson_iterator_int(&i); else if(strcmp(key, "size") == 0) size = bson_iterator_int(&i); } if(curs.err != MONGO_CURSOR_EXHAUSTED) { fprintf(stderr, "Error getting extents %d", curs.err); return -EIO; } if(!compdata) { fprintf(stderr, "No data in block?\n"); return -EIO; } outsize = MAX_BLOCK_SIZE; if((res = snappy_uncompress(compdata, compsize, buf + offset, &outsize)) != SNAPPY_OK) { fprintf(stderr, "Error uncompressing block %d\n", res); return -EIO; } if(offset > 0) memset(buf, 0, offset); compsize = outsize + offset; if(compsize < size) memset(buf + compsize, 0, size - compsize); mongo_cursor_destroy(&curs); return 0; }
void db_init_cursor(void* cursor, const char* documents_name) { char* cursor_spec = (char*)malloc(strlen(db_name) + strlen(documents_name) + 2); sprintf(cursor_spec, "%s.%s", db_name, documents_name); mongo_cursor_init((mongo_cursor*)cursor, db, cursor_spec); free(cursor_spec); }