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