int main() { mongo conn[1]; INIT_SOCKETS_FOR_WINDOWS; CONN_CLIENT_TEST; mongo_cmd_drop_db( conn, db ); ASSERT( mongo_cmd_authenticate( conn, db, "user", "password" ) == MONGO_ERROR ); mongo_cmd_add_user( conn, db, "user", "password" ); ASSERT( mongo_cmd_authenticate( conn, db, "user", "password" ) == MONGO_OK ); mongo_cmd_drop_db( conn, db ); mongo_destroy( conn ); return 0; }
void MongodbClient::DropDatabase() { int32 status = mongo_cmd_drop_db(clientData->connection, database.c_str()); if(MONGO_OK != status) { LogError(String("DropDatabase"), clientData->connection->err); } }
SEXP mongo_drop_database(SEXP mongo_conn, SEXP db) { mongo* conn = _checkMongo(mongo_conn); const char* _db = CHAR(STRING_ELT(db, 0)); SEXP ret; PROTECT(ret = allocVector(LGLSXP, 1)); LOGICAL(ret)[0] = (mongo_cmd_drop_db(conn, _db) == MONGO_OK); UNPROTECT(1); return ret; }
int main(int argc, char **argv) { mongo conn[1]; GETSERVERNAME; INIT_SOCKETS_FOR_WINDOWS; CONN_CLIENT_TEST(_servername)(_servername); mongo_cmd_drop_db( conn, db ); ASSERT( mongo_cmd_authenticate( conn, db, "user", "password" ) == MONGO_ERROR ); mongo_cmd_add_user( conn, db, "user", "password" ); ASSERT( mongo_cmd_authenticate( conn, db, "user", "password" ) == MONGO_OK ); mongo_cmd_drop_db( conn, db ); mongo_destroy( conn ); return 0; }
static void clean( void ) { bson b; if ( mongo_cmd_drop_db( conn, DB ) != MONGO_OK ) { printf( "failed to drop db\n" ); exit( 1 ); } /* create the db */ mongo_insert( conn, DB ".creation", bson_shared_empty(), NULL ); ASSERT( !mongo_cmd_get_last_error( conn, DB, NULL ) ); }
static void clean(){ bson b; if (!mongo_cmd_drop_db(conn, DB)){ printf("failed to drop db\n"); exit(1); } /* create the db */ mongo_insert(conn, DB ".creation", bson_empty(&b)); ASSERT(!mongo_cmd_get_last_error(conn, DB, NULL)); }
int main() { mongo conn[1]; bson cmd[1]; bson out[1]; bson_iterator it[1]; char version[10]; const char *db = "test"; const char *col = "c.capped"; INIT_SOCKETS_FOR_WINDOWS; if ( mongo_connect( conn , TEST_SERVER , 27017 ) ) { printf( "failed to connect\n" ); exit( 1 ); } mongo_cmd_drop_collection( conn, db, col, NULL ); ASSERT( mongo_create_capped_collection( conn, db, col, 1024, 100, NULL ) == MONGO_OK ); bson_init( cmd ); bson_append_string( cmd, "collstats", col ); bson_finish( cmd ); ASSERT( mongo_run_command( conn, db, cmd, out ) == MONGO_OK ); if( mongo_get_server_version( version ) != -1 ){ if( version[0] == '2' && version[2] >= '1' ) ASSERT( bson_find( it, out, "capped" ) == BSON_BOOL ); else ASSERT( bson_find( it, out, "capped" ) == BSON_INT ); } ASSERT( bson_find( it, out, "max" ) == BSON_INT ); bson_destroy( cmd ); bson_destroy( out ); mongo_cmd_drop_collection( conn, "test", col, NULL ); mongo_cmd_drop_db( conn, db ); mongo_destroy( conn ); return 0; }
int main(void) { mongo_connection conn[1]; mongo_connection_options opts; gridfs gfs[1]; char data_before[UPPER]; size_t i; FILE *fd; srand(time(NULL)); INIT_SOCKETS_FOR_WINDOWS; /* strncpy(opts.host, TEST_SERVER, 255);*/ strncpy(opts.host, "127.0.0.1", 255); opts.host[254] = '\0'; opts.port = 27017; if (mongo_connect( conn , &opts )){ printf("failed to connect\n"); exit(1); } gridfs_init(conn, "test", "fs", gfs); for (i = LOWER; i <= UPPER; i+=DELTA) { fill_buffer_randomly(data_before, i); /* Input from buffer */ gridfs_store_buffer(gfs, data_before, i, "input-buffer", "text/html"); test_gridfile(gfs, data_before, i, "input-buffer", "text/html"); /* Input from file */ fd = fopen("input-file", "w"); fwrite(data_before, sizeof(char), i, fd); fclose(fd); gridfs_store_file(gfs, "input-file", "input-file", "text/html"); test_gridfile(gfs, data_before, i, "input-file", "text/html"); } gridfs_destroy(gfs); mongo_cmd_drop_db(conn, "test"); mongo_destroy(conn); return 0; }
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; }
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(){ 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; }
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 b; unsigned char not_utf8[3]; int result; not_utf8[0] = 0xC0; not_utf8[1] = 0xC0; not_utf8[3] = '\0'; INIT_SOCKETS_FOR_WINDOWS; if (mongo_connect( conn , TEST_SERVER, 27017 )){ printf("failed to connect\n"); exit(1); } /* Test valid keys. */ bson_buffer_init( & bb ); result = bson_append_string( &bb , "a.b" , "17" ); ASSERT( result == BSON_OK ); ASSERT( bb.err & BSON_FIELD_HAS_DOT ); result = bson_append_string( &bb , "$ab" , "17" ); ASSERT( result == BSON_OK ); ASSERT( bb.err & BSON_FIELD_INIT_DOLLAR ); result = bson_append_string( &bb , "ab" , "this is valid utf8" ); ASSERT( result == BSON_OK ); ASSERT( ! (bb.err & BSON_NOT_UTF8 ) ); result = bson_append_string( &bb , (const char*)not_utf8, "valid" ); ASSERT( result == BSON_ERROR ); ASSERT( bb.err & BSON_NOT_UTF8 ); bson_from_buffer(&b, &bb); ASSERT( b.err & BSON_FIELD_HAS_DOT ); ASSERT( b.err & BSON_FIELD_INIT_DOLLAR ); ASSERT( b.err & BSON_NOT_UTF8 ); bson_destroy(&b); /* Test valid strings. */ bson_buffer_init( & bb ); result = bson_append_string( &bb , "foo" , "bar" ); ASSERT( result == BSON_OK ); ASSERT( bb.err == 0 ); result = bson_append_string( &bb , "foo" , (const char*)not_utf8 ); ASSERT( result == BSON_ERROR ); ASSERT( bb.err & BSON_NOT_UTF8 ); bb.err = 0; ASSERT( bb.err == 0 ); result = bson_append_regex( &bb , "foo" , (const char*)not_utf8, "s" ); ASSERT( result == BSON_ERROR ); ASSERT( bb.err & BSON_NOT_UTF8 ); mongo_cmd_drop_db(conn, "test"); mongo_disconnect( conn ); mongo_destroy( conn ); return 0; }