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);
}
