void test_index_helper( mongo *conn ) { int ret; bson b, out; bson_iterator it; bson_init( &b ); bson_append_int( &b, "foo", -1 ); bson_finish( &b ); mongo_create_index( conn, "test.bar", &b, NULL, MONGO_INDEX_SPARSE | MONGO_INDEX_UNIQUE, &out ); bson_destroy( &b ); bson_destroy( &out ); bson_init( &b ); bson_append_start_object( &b, "key" ); bson_append_int( &b, "foo", -1 ); bson_append_finish_object( &b ); bson_finish( &b ); ret = mongo_find_one( conn, "test.system.indexes", &b, NULL, &out ); ASSERT( ret == MONGO_OK ); bson_print( &out ); bson_iterator_init( &it, &out ); ASSERT( bson_find( &it, &out, "unique" ) ); ASSERT( bson_find( &it, &out, "sparse" ) ); bson_destroy( &b ); bson_destroy( &out ); }
MONGO_EXPORT int mongo_run_command( mongo *conn, const char *db, const bson *command, bson *out ) { bson response = {NULL, 0}; bson fields; int sl = strlen( db ); char *ns = bson_malloc( sl + 5 + 1 ); /* ".$cmd" + nul */ int res, success = 0; strcpy( ns, db ); strcpy( ns+sl, ".$cmd" ); res = mongo_find_one( conn, ns, command, bson_empty( &fields ), &response ); bson_free( ns ); if( res != MONGO_OK ) return MONGO_ERROR; else { bson_iterator it; if( bson_find( &it, &response, "ok" ) ) success = bson_iterator_bool( &it ); if( !success ) { conn->err = MONGO_COMMAND_FAILED; return MONGO_ERROR; } else { if( out ) *out = response; return MONGO_OK; } } }
int gridfs_find_query(gridfs* gfs, bson* query, gridfile* gfile ) { bson_buffer date_buffer; bson uploadDate; bson_buffer buf; bson finalQuery; bson out; int i; bson_buffer_init(&date_buffer); bson_append_int(&date_buffer, "uploadDate", -1); bson_from_buffer(&uploadDate, &date_buffer); bson_buffer_init(&buf); bson_append_bson(&buf, "query", query); bson_append_bson(&buf, "orderby", &uploadDate); bson_from_buffer(&finalQuery, &buf); i = (mongo_find_one(gfs->client, gfs->files_ns, &finalQuery, NULL, &out)); bson_destroy(&uploadDate); bson_destroy(&finalQuery); if (!i) return FALSE; else { gridfile_init(gfs, &out, gfile); bson_destroy(&out); return TRUE; } }
/* Test read timeout by causing the * server to sleep for 10s on a query. */ int test_read_timeout( void ) { mongo conn[1]; bson b, obj, out, fields; int res; CONN_CLIENT_TEST; bson_init( &b ); bson_append_code( &b, "$where", "sleep( 10 * 1000 );"); bson_finish( &b ); bson_init( &obj ); bson_append_string( &obj, "foo", "bar"); bson_finish( &obj ); res = mongo_insert( conn, "test.foo", &obj, NULL ); /* Set the connection timeout here. */ if( mongo_set_op_timeout( conn, 1000 ) != MONGO_OK ) { printf("Could not set socket timeout!."); exit(1); } res = mongo_find_one( conn, "test.foo", &b, bson_empty(&fields), &out ); ASSERT( res == MONGO_ERROR ); ASSERT( conn->err == MONGO_IO_ERROR ); ASSERT( conn->errcode == WSAETIMEDOUT ); return 0; }
int gridfs_find_query( gridfs *gfs, bson *query, gridfile *gfile ) { bson uploadDate; bson finalQuery; bson out; int i; bson_init( &uploadDate ); bson_append_int( &uploadDate, "uploadDate", -1 ); bson_finish( &uploadDate ); bson_init( &finalQuery ); bson_append_bson( &finalQuery, "query", query ); bson_append_bson( &finalQuery, "orderby", &uploadDate ); bson_finish( &finalQuery ); i = ( mongo_find_one( gfs->client, gfs->files_ns, &finalQuery, NULL, &out ) == MONGO_OK ); bson_destroy( &uploadDate ); bson_destroy( &finalQuery ); if ( !i ) return MONGO_ERROR; else { gridfile_init( gfs, &out, gfile ); bson_destroy( &out ); return MONGO_OK; } }
static void get(ngx_str_t *db, ngx_str_t *collection, char* id, ngx_buf_t *b){ bson_buffer bb; bson obj; bson cond; char result[1000] = ""; char ns[1000]; //get the query bson_buffer_init(&bb); bson_append_string(&bb, "_id", id); bson_from_buffer(&cond, &bb); sprintf(ns, "%s.%s", db->data, collection->data); if(!mongo_find_one(cached_connection, ns, &cond, 0, &obj)){ strcpy(result, "{'error':'record not found'}"); } else { to_json(result, obj.data, 10); } b->pos = (u_char*)result; /* address of the first position of the data */ b->last = (u_char*)result + strlen(result); /* address of the last position of the data */ // destroy cond bb and other stuff bson_destroy(&cond); bson_destroy(&obj); }
static void find_one( const char *ns ) { bson b; int i; for ( i=0; i < PER_TRIAL; i++ ) { make_query( &b ); ASSERT( mongo_find_one( conn, ns, &b, NULL, NULL ) == MONGO_OK ); bson_destroy( &b ); } }
SEXP rmongo_find_one(SEXP mongo_conn, SEXP ns, SEXP query, SEXP fields) { mongo* conn = _checkMongo(mongo_conn); const char* _ns = CHAR(STRING_ELT(ns, 0)); bson* _query = _checkBSON(query); bson* _fields = _checkBSON(fields); bson out; if (mongo_find_one(conn, _ns, _query, _fields, &out) != MONGO_OK) { return R_NilValue; } SEXP ret = _mongo_bson_create(&out); bson_destroy(&out); UNPROTECT(3); return ret; }
QVariantMap TMongoDriver::findOne(const QString &ns, const QVariantMap &criteria, const QStringList &fields) { TBson bs; mongo_clear_errors(mongoConnection); int status = mongo_find_one(mongoConnection, qPrintable(ns), (bson *)TBson::toBson(criteria).data(), (bson *)TBson::toBson(fields).data(), (bson *)bs.data()); if (status != MONGO_OK) { tSystemError("MongoDB Error: %s", mongoConnection->lasterrstr); return QVariantMap(); } return TBson::fromBson(bs); }
int mongo_run_command( mongo *conn, const char *db, bson *command, bson *out ) { bson fields; int sl = strlen( db ); char *ns = bson_malloc( sl + 5 + 1 ); /* ".$cmd" + nul */ int res; strcpy( ns, db ); strcpy( ns+sl, ".$cmd" ); res = mongo_find_one( conn, ns, command, bson_empty( &fields ), out ); bson_free( ns ); return res; }
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; }
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; }
int find_radius_options(rlm_mongo_t *data, char *username, char *mac, char *password) { bson_buffer bb; bson query; bson field; bson result; bson_buffer_init(&bb); bson_append_string(&bb, data->search_field, username); if (strcmp(data->mac_field, "") != 0) { bson_append_string(&bb, data->mac_field, mac); } if (strcmp(data->enable_field, "") != 0) { bson_append_bool(&bb, data->enable_field, 1); } bson_from_buffer(&query, &bb); bson_buffer_destroy(&bb); bson_empty(&field); bson_empty(&result); MONGO_TRY{ if (mongo_find_one(conn, data->base, &query, &field, &result) == 0) { return 0; } }MONGO_CATCH{ mongo_start(data); return 0; } bson_iterator it; bson_iterator_init(&it, result.data); find_in_array(&it, data->username_field, username, data->password_field, password); bson_destroy(&result); return 1; }
bool MongodbClient::FindObjectByKey(const String &key, MongodbObject * foundObject) { DVASSERT(foundObject); MongodbObject *query = new MongodbObject(); DVASSERT(query); query->SetObjectName(key); query->Finish(); int32 status = mongo_find_one(clientData->connection, namespaceName.c_str(), (bson *)query->InternalObject(), 0, (bson *)foundObject->InternalObject()); if(MONGO_OK != status) { return false; } SafeRelease(query); return true; }
bson gridfile_get_chunk( gridfile *gfile, int n ) { bson query; bson out; bson_iterator it; bson_oid_t id; bson_init( &query ); bson_find( &it, gfile->meta, "_id" ); id = *bson_iterator_oid( &it ); bson_append_oid( &query, "files_id", &id ); bson_append_int( &query, "n", n ); bson_finish( &query ); assert( mongo_find_one( gfile->gfs->client, gfile->gfs->chunks_ns, &query, NULL, &out ) == MONGO_OK ); bson_destroy( &query ); return out; }
bson gridfile_get_chunk(gridfile* gfile, int n) { bson query; bson out; bson_buffer buf; bson_iterator it; bson_oid_t id; bson_buffer_init(&buf); bson_find(&it, gfile->meta, "_id"); id = *bson_iterator_oid(&it); bson_append_oid(&buf, "files_id", &id); bson_append_int(&buf, "n", n); bson_from_buffer(&query, &buf); assert(mongo_find_one(gfile->gfs->client, gfile->gfs->chunks_ns, &query, NULL, &out)); return out; }
int test_reconnect( const char *set_name ) { mongo conn[1]; int res = 0; int e = 0; bson b; INIT_SOCKETS_FOR_WINDOWS; mongo_replset_init( conn, set_name ); mongo_replset_add_seed( conn, TEST_SERVER, SEED_START_PORT ); mongo_replset_add_seed( conn, TEST_SERVER, SEED_START_PORT + 1 ); if( ( mongo_replset_connect( conn ) != MONGO_OK ) ) { mongo_destroy( conn ); return MONGO_ERROR; } else { fprintf( stderr, "Disconnect now:\n" ); sleep( 10 ); e = 1; do { res = mongo_find_one( conn, "foo.bar", bson_empty( &b ), bson_empty( &b ), NULL ); if( res == MONGO_ERROR && conn->err == MONGO_IO_ERROR ) { sleep( 2 ); if( e++ < 30 ) { fprintf( stderr, "Attempting reconnect %d.\n", e ); mongo_reconnect( conn ); } else { fprintf( stderr, "Fail.\n" ); return -1; } } } while( 1 ); } return 0; }
int get_inode_impl(const char * path, struct inode * out) { bson query, doc; int res; mongo * conn = get_conn(); bson_init(&query); bson_append_string(&query, "dirents", path); bson_finish(&query); res = mongo_find_one(conn, inodes_name, &query, bson_shared_empty(), &doc); if(res != MONGO_OK) { bson_destroy(&query); return -ENOENT; } bson_destroy(&query); res = read_inode(&doc, out); bson_destroy(&doc); return res; }
MONGO_EXPORT void gridfile_get_chunk( gridfile *gfile, int n, bson* out ) { bson query; bson_iterator it; bson_oid_t id; int result; bson_init( &query ); bson_find( &it, gfile->meta, "_id" ); id = *bson_iterator_oid( &it ); bson_append_oid( &query, "files_id", &id ); bson_append_int( &query, "n", n ); bson_finish( &query ); result = (mongo_find_one(gfile->gfs->client, gfile->gfs->chunks_ns, &query, NULL, out ) == MONGO_OK ); bson_destroy( &query ); if (!result) { bson empty; bson_empty(&empty); bson_copy(out, &empty); } }
/* We can test write concern for update * and remove by doing operations on a capped collection. */ static void test_update_and_remove( mongo *conn ) { mongo_write_concern wc[1]; bson *objs[5]; bson query[1], update[1]; int i; create_capped_collection( conn ); for( i=0; i<5; i++ ) { objs[i] = bson_alloc(); bson_init( objs[i] ); bson_append_int( objs[i], "n", i ); bson_finish( objs[i] ); } ASSERT( mongo_insert_batch( conn, "test.wc", (const bson **)objs, 5, NULL, 0 ) == MONGO_OK ); ASSERT( mongo_count( conn, "test", "wc", bson_shared_empty( ) ) == 5 ); bson_init( query ); bson_append_int( query, "n", 2 ); bson_finish( query ); ASSERT( mongo_find_one( conn, "test.wc", query, bson_shared_empty( ), NULL ) == MONGO_OK ); bson_init( update ); bson_append_start_object( update, "$set" ); bson_append_string( update, "n", "a big long string" ); bson_append_finish_object( update ); bson_finish( update ); /* Update will appear to succeed with no write concern specified, but doesn't. */ ASSERT( mongo_find_one( conn, "test.wc", query, bson_shared_empty( ), NULL ) == MONGO_OK ); ASSERT( mongo_update( conn, "test.wc", query, update, 0, NULL ) == MONGO_OK ); ASSERT( mongo_find_one( conn, "test.wc", query, bson_shared_empty( ), NULL ) == MONGO_OK ); /* Remove will appear to succeed with no write concern specified, but doesn't. */ ASSERT( mongo_remove( conn, "test.wc", query, NULL ) == MONGO_OK ); ASSERT( mongo_find_one( conn, "test.wc", query, bson_shared_empty( ), NULL ) == MONGO_OK ); mongo_write_concern_init( wc ); mongo_write_concern_set_w( wc, 1 ); mongo_write_concern_finish( wc ); mongo_clear_errors( conn ); ASSERT( mongo_update( conn, "test.wc", query, update, 0, wc ) == MONGO_ERROR ); ASSERT( conn->err == MONGO_WRITE_ERROR ); ASSERT_EQUAL_STRINGS( conn->lasterrstr, "failing update: objects in a capped ns cannot grow" ); mongo_clear_errors( conn ); ASSERT( mongo_remove( conn, "test.wc", query, wc ) == MONGO_ERROR ); ASSERT( conn->err == MONGO_WRITE_ERROR ); ASSERT_EQUAL_STRINGS( conn->lasterrstr, "can't remove from a capped collection" ); mongo_write_concern_destroy( wc ); bson_destroy( query ); bson_destroy( update ); for( i=0; i<5; i++ ) { bson_destroy( objs[i] ); bson_dealloc( objs[i] ); } }
int main(){ bson obj; INIT_SOCKETS_FOR_WINDOWS; if (mongo_connect( conn , TEST_SERVER, 27017 )){ printf("failed to connect\n"); exit(1); } /*********************/ ASSERT(mongo_cmd_get_prev_error(conn, db, NULL) == MONGO_OK); ASSERT( conn->lasterrcode == 0 ); ASSERT( conn->lasterrstr == NULL ); ASSERT(mongo_cmd_get_last_error(conn, db, NULL) == MONGO_OK); ASSERT( conn->lasterrcode == 0 ); ASSERT( conn->lasterrstr == NULL ); ASSERT(mongo_cmd_get_prev_error(conn, db, &obj) == MONGO_OK); bson_destroy(&obj); ASSERT(mongo_cmd_get_last_error(conn, db, &obj) == MONGO_OK); bson_destroy(&obj); /*********************/ mongo_simple_int_command(conn, db, "forceerror", 1, NULL); ASSERT(mongo_cmd_get_prev_error(conn, db, NULL) == MONGO_ERROR); ASSERT( conn->lasterrcode == 10038 ); ASSERT( strcmp( (const char*)conn->lasterrstr, "forced error" ) == 0 ); ASSERT(mongo_cmd_get_last_error(conn, db, NULL) == MONGO_ERROR); ASSERT(mongo_cmd_get_prev_error(conn, db, &obj) == MONGO_ERROR); bson_destroy(&obj); ASSERT(mongo_cmd_get_last_error(conn, db, &obj) == MONGO_ERROR); bson_destroy(&obj); /* should clear lasterror but not preverror */ mongo_find_one(conn, ns, bson_empty(&obj), bson_empty(&obj), NULL); ASSERT(mongo_cmd_get_prev_error(conn, db, NULL) == MONGO_ERROR); ASSERT(mongo_cmd_get_last_error(conn, db, NULL) == MONGO_OK); ASSERT(mongo_cmd_get_prev_error(conn, db, &obj) == MONGO_ERROR); bson_destroy(&obj); ASSERT(mongo_cmd_get_last_error(conn, db, &obj) == MONGO_OK); bson_destroy(&obj); /*********************/ mongo_cmd_reset_error(conn, db); ASSERT(mongo_cmd_get_prev_error(conn, db, NULL) == MONGO_OK); ASSERT(mongo_cmd_get_last_error(conn, db, NULL) == MONGO_OK); ASSERT(mongo_cmd_get_prev_error(conn, db, &obj) == MONGO_OK); bson_destroy(&obj); ASSERT(mongo_cmd_get_last_error(conn, db, &obj) == MONGO_OK); bson_destroy(&obj); mongo_cmd_drop_db(conn, db); mongo_destroy(conn); return 0; }
static struct dlr_entry* dlr_mongodb_get(const Octstr *smsc, const Octstr *ts, const Octstr *dst) { DBPoolConn *pconn; bson cond, obj; bson_buffer cond_buf; bson_iterator it; struct dlr_entry *res = NULL; bson_bool_t found = 0; mongo_connection *conn = NULL; pconn = dbpool_conn_consume(pool); if (pconn == NULL) { return NULL; } conn = (mongo_connection*)pconn->conn; bson_buffer_init(&cond_buf); bson_append_string(&cond_buf, octstr_get_cstr(fields->field_smsc), octstr_get_cstr(smsc)); bson_append_string(&cond_buf, octstr_get_cstr(fields->field_ts), octstr_get_cstr(ts)); if (dst) { bson_append_string(&cond_buf, octstr_get_cstr(fields->field_dst), octstr_get_cstr(dst)); } bson_from_buffer(&cond, &cond_buf); memset(&obj, 0, sizeof(bson)); MONGO_TRY { found = mongo_find_one(conn, mongodb_namespace, &cond, NULL, &obj); } MONGO_CATCH { mongodb_error("dlr_mongodb_get", conn->exception.type); found = 0; } if (found) { res = dlr_entry_create(); gw_assert(res != NULL); bson_find(&it, &obj, octstr_get_cstr(fields->field_mask)); res->mask = bson_iterator_int(&it); bson_find(&it, &obj, octstr_get_cstr(fields->field_serv)); res->service = octstr_create(bson_iterator_string(&it)); bson_find(&it, &obj, octstr_get_cstr(fields->field_url)); res->url = octstr_create(bson_iterator_string(&it)); bson_find(&it, &obj, octstr_get_cstr(fields->field_src)); res->source = octstr_create(bson_iterator_string(&it)); bson_find(&it, &obj, octstr_get_cstr(fields->field_dst)); res->destination = octstr_create(bson_iterator_string(&it)); bson_find(&it, &obj, octstr_get_cstr(fields->field_boxc)); res->boxc_id = octstr_create(bson_iterator_string(&it)); bson_find(&it, &obj, octstr_get_cstr(fields->field_smsc)); res->smsc = octstr_create(bson_iterator_string(&it)); } dbpool_conn_produce(pconn); bson_destroy(&cond); bson_destroy(&obj); return res; }
int main(){ bson obj; strncpy(opts.host, TEST_SERVER, 255); opts.host[254] = '\0'; opts.port = 27017; if (mongo_connect( conn , &opts )){ printf("failed to connect\n"); exit(1); } /*********************/ ASSERT(!mongo_cmd_get_prev_error(conn, db, NULL)); ASSERT(!mongo_cmd_get_last_error(conn, db, NULL)); ASSERT(!mongo_cmd_get_prev_error(conn, db, &obj)); bson_destroy(&obj); ASSERT(!mongo_cmd_get_last_error(conn, db, &obj)); bson_destroy(&obj); /*********************/ mongo_simple_int_command(conn, db, "forceerror", 1, NULL); ASSERT(mongo_cmd_get_prev_error(conn, db, NULL)); ASSERT(mongo_cmd_get_last_error(conn, db, NULL)); ASSERT(mongo_cmd_get_prev_error(conn, db, &obj)); bson_destroy(&obj); ASSERT(mongo_cmd_get_last_error(conn, db, &obj)); bson_destroy(&obj); /* should clear lasterror but not preverror */ mongo_find_one(conn, ns, bson_empty(&obj), bson_empty(&obj), NULL); ASSERT(mongo_cmd_get_prev_error(conn, db, NULL)); ASSERT(!mongo_cmd_get_last_error(conn, db, NULL)); ASSERT(mongo_cmd_get_prev_error(conn, db, &obj)); bson_destroy(&obj); ASSERT(!mongo_cmd_get_last_error(conn, db, &obj)); bson_destroy(&obj); /*********************/ mongo_cmd_reset_error(conn, db); ASSERT(!mongo_cmd_get_prev_error(conn, db, NULL)); ASSERT(!mongo_cmd_get_last_error(conn, db, NULL)); ASSERT(!mongo_cmd_get_prev_error(conn, db, &obj)); bson_destroy(&obj); ASSERT(!mongo_cmd_get_last_error(conn, db, &obj)); bson_destroy(&obj); return 0; }
int main(){ mongo_connection conn[1]; mongo_connection_options opts; bson_buffer bb; bson b; mongo_cursor * cursor; int i; char hex_oid[25]; const char * col = "c.simple"; const char * ns = "test.c.simple"; INIT_SOCKETS_FOR_WINDOWS; strncpy(opts.host, TEST_SERVER, 255); opts.host[254] = '\0'; opts.port = 27017; if (mongo_connect( conn , &opts )){ printf("failed to connect\n"); exit(1); } /* if the collection doesn't exist dropping it will fail */ if (!mongo_cmd_drop_collection(conn, "test", col, NULL) && mongo_find_one(conn, ns, bson_empty(&b), bson_empty(&b), NULL)){ printf("failed to drop collection\n"); exit(1); } for(i=0; i< 5; i++){ bson_buffer_init( & bb ); bson_append_new_oid( &bb, "_id" ); bson_append_double( &bb , "a" , 17 ); bson_append_int( &bb , "b" , 17 ); bson_append_string( &bb , "c" , "17" ); { bson_buffer * sub = bson_append_start_object( &bb , "d" ); bson_append_int( sub, "i", 71 ); bson_append_finish_object(sub); } { bson_buffer * arr = bson_append_start_array( &bb , "e" ); bson_append_int( arr, "0", 71 ); bson_append_string( arr, "1", "71" ); bson_append_finish_object(arr); } bson_from_buffer(&b, &bb); mongo_insert( conn , ns , &b ); bson_destroy(&b); } cursor = mongo_find( conn , ns , bson_empty(&b) , 0 , 0 , 0 , 0 ); while (mongo_cursor_next(cursor)){ bson_iterator it; bson_iterator_init(&it, cursor->current.data); while(bson_iterator_next(&it)){ fprintf(stderr, " %s: ", bson_iterator_key(&it)); switch(bson_iterator_type(&it)){ case bson_double: fprintf(stderr, "(double) %e\n", bson_iterator_double(&it)); break; case bson_int: fprintf(stderr, "(int) %d\n", bson_iterator_int(&it)); break; case bson_string: fprintf(stderr, "(string) \"%s\"\n", bson_iterator_string(&it)); break; case bson_oid: bson_oid_to_string(bson_iterator_oid(&it), hex_oid); fprintf(stderr, "(oid) \"%s\"\n", hex_oid); break; case bson_object: fprintf(stderr, "(subobject) {...}\n"); break; case bson_array: fprintf(stderr, "(array) [...]\n"); break; default: fprintf(stderr, "(type %d)\n", bson_iterator_type(&it)); break; } } fprintf(stderr, "\n"); } mongo_cursor_destroy(cursor); mongo_cmd_drop_db(conn, "test"); mongo_destroy( conn ); return 0; }
int main(){ mongo_connection conn[1]; bson_buffer bb; bson obj; bson cond; int i; bson_oid_t oid; const char* col = "c.update_test"; const char* ns = "test.c.update_test"; INIT_SOCKETS_FOR_WINDOWS; if (mongo_connect( conn , TEST_SERVER, 27017 )){ printf("failed to connect\n"); exit(1); } /* if the collection doesn't exist dropping it will fail */ if ( mongo_cmd_drop_collection(conn, "test", col, NULL) == MONGO_OK && mongo_find_one(conn, ns, bson_empty(&obj), bson_empty(&obj), NULL) != MONGO_OK ){ printf("failed to drop collection\n"); exit(1); } bson_oid_gen(&oid); { /* insert */ bson_buffer_init(&bb); bson_append_oid(&bb, "_id", &oid); bson_append_int(&bb, "a", 3 ); bson_from_buffer(&obj, &bb); mongo_insert(conn, ns, &obj); bson_destroy(&obj); } { /* insert */ bson op; bson_buffer_init(&bb); bson_append_oid(&bb, "_id", &oid); bson_from_buffer(&cond, &bb); bson_buffer_init(&bb); { bson_append_start_object(&bb, "$inc"); bson_append_int(&bb, "a", 2 ); bson_append_finish_object(&bb); } { bson_append_start_object(&bb, "$set"); bson_append_double(&bb, "b", -1.5 ); bson_append_finish_object(&bb); } bson_from_buffer(&op, &bb); for (i=0; i<5; i++) mongo_update(conn, ns, &cond, &op, 0); /* cond is used later */ bson_destroy(&op); } if( mongo_find_one(conn, ns, &cond, 0, &obj) != MONGO_OK ){ printf("Failed to find object\n"); exit(1); } else { int fields = 0; bson_iterator it; bson_iterator_init(&it, obj.data); bson_destroy(&cond); while(bson_iterator_next(&it)){ switch(bson_iterator_key(&it)[0]){ case '_': /* id */ ASSERT(bson_iterator_type(&it) == BSON_OID); ASSERT(!memcmp(bson_iterator_oid(&it)->bytes, oid.bytes, 12)); fields++; break; case 'a': ASSERT(bson_iterator_type(&it) == BSON_INT); ASSERT(bson_iterator_int(&it) == 3 + 5*2); fields++; break; case 'b': ASSERT(bson_iterator_type(&it) == BSON_DOUBLE); ASSERT(bson_iterator_double(&it) == -1.5); fields++; break; } } ASSERT(fields == 3); } bson_destroy(&obj); mongo_cmd_drop_db(conn, "test"); mongo_destroy(conn); return 0; }