void test_batch_insert_with_continue( mongo *conn ) { bson *objs[5]; bson *objs2[5]; bson empty; int i; mongo_cmd_drop_collection( conn, TEST_DB, TEST_COL, NULL ); mongo_create_simple_index( conn, TEST_NS, "n", MONGO_INDEX_UNIQUE, NULL ); for( i=0; i<5; i++ ) { objs[i] = bson_malloc( sizeof( bson ) ); bson_init( objs[i] ); bson_append_int( objs[i], "n", i ); bson_finish( objs[i] ); } ASSERT( mongo_insert_batch( conn, TEST_NS, (const bson **)objs, 5, NULL, 0 ) == MONGO_OK ); ASSERT( mongo_count( conn, TEST_DB, TEST_COL, bson_empty( &empty ) ) == 5 ); /* Add one duplicate value for n. */ objs2[0] = bson_malloc( sizeof( bson ) ); bson_init( objs2[0] ); bson_append_int( objs2[0], "n", 1 ); bson_finish( objs2[0] ); /* Add n for 6 - 9. */ for( i = 1; i < 5; i++ ) { objs2[i] = bson_malloc( sizeof( bson ) ); bson_init( objs2[i] ); bson_append_int( objs2[i], "n", i + 5 ); bson_finish( objs2[i] ); } /* Without continue on error, will fail immediately. */ ASSERT( mongo_insert_batch( conn, TEST_NS, (const bson **)objs2, 5, NULL, 0 ) == MONGO_OK ); ASSERT( mongo_count( conn, TEST_DB, TEST_COL, bson_empty( &empty ) ) == 5 ); /* With continue on error, will insert four documents. */ ASSERT( mongo_insert_batch( conn, TEST_NS, (const bson **)objs2, 5, NULL, MONGO_CONTINUE_ON_ERROR ) == MONGO_OK ); ASSERT( mongo_count( conn, TEST_DB, TEST_COL, bson_empty( &empty ) ) == 9 ); for( i=0; i<5; i++ ) { bson_destroy( objs2[i] ); bson_free( objs2[i] ); bson_destroy( objs[i] ); bson_free( objs[i] ); } }
static void tutorial_insert_batch( mongo *conn ) { bson *p; bson **ps; char *names[4]; int ages[] = { 29, 24, 24, 32 }; int i, n = 4; names[0] = "Eliot"; names[1] = "Mike"; names[2] = "Mathias"; names[3] = "Richard"; ps = ( bson ** )malloc( sizeof( bson * ) * n); for ( i = 0; i < n; i++ ) { p = ( bson * )malloc( sizeof( bson ) ); bson_init( p ); bson_append_new_oid( p, "_id" ); bson_append_string( p, "name", names[i] ); bson_append_int( p, "age", ages[i] ); bson_finish( p ); ps[i] = p; } mongo_insert_batch( conn, "tutorial.persons", (const bson **) ps, n, 0, 0 ); for ( i = 0; i < n; i++ ) { bson_destroy( ps[i] ); free( ps[i] ); } }
SEXP rmongo_insert_batch(SEXP mongo_conn, SEXP ns, SEXP b) { mongo* conn = _checkMongo(mongo_conn); const char* _ns = CHAR(STRING_ELT(ns, 0)); SEXP ret; PROTECT(ret = allocVector(LGLSXP, 1)); if (TYPEOF(b) != VECSXP) error("Expected a list of mongo.bson class objects"); int len = LENGTH(b); bson** blist = Calloc(len, bson*); int i; int success = 1; for (i = 0; i < len && success; i++) { SEXP _b = VECTOR_ELT(b, i); if (!_isBSON(_b)) success = 0; else blist[i] = _checkBSON(_b); } if (success) LOGICAL(ret)[0] = (mongo_insert_batch(conn, _ns, blist, len) == MONGO_OK); Free(blist); if (!success) error("Expected list of mongo.bson class objects"); UNPROTECT(1); return ret; }
int test_namespace_validation_on_insert( void ) { mongo conn[1]; bson b[1], b2[1]; bson *objs[2]; INIT_SOCKETS_FOR_WINDOWS; if ( mongo_connect( conn , TEST_SERVER, 27017 ) ) { printf( "failed to connect\n" ); exit( 1 ); } bson_init( b ); bson_append_int( b, "foo", 1 ); bson_finish( b ); ASSERT( mongo_insert( conn, "tet.fo$o", b, NULL ) == MONGO_ERROR ); ASSERT( conn->err == MONGO_NS_INVALID ); ASSERT( strncmp( conn->errstr, "Collection may not contain '$'", 29 ) == 0 ); mongo_clear_errors( conn ); bson_init( b2 ); bson_append_int( b2, "foo", 1 ); bson_finish( b2 ); objs[0] = b; objs[1] = b2; ASSERT( mongo_insert_batch( conn, "tet.fo$o", (const bson **)objs, 2, NULL, 0 ) == MONGO_ERROR ); ASSERT( conn->err == MONGO_NS_INVALID ); ASSERT( strncmp( conn->errstr, "Collection may not contain '$'", 29 ) == 0 ); return 0; }
int test_insert_limits( const char *set_name ) { char version[10]; mongo conn[1]; mongo_write_concern wc[1]; int i; char key[10]; int res = 0; bson b[1], b2[1]; bson *objs[2]; mongo_write_concern_init( wc ); wc->w = 1; mongo_write_concern_finish( wc ); /* We'll perform the full test if we're running v2.0 or later. */ if( mongo_get_server_version( version ) != -1 && version[0] <= '1' ) return 0; mongo_replset_init( conn, set_name ); mongo_replset_add_seed( conn, TEST_SERVER, SEED_START_PORT + 1 ); mongo_replset_add_seed( conn, TEST_SERVER, SEED_START_PORT ); res = mongo_replset_connect( conn ); if( res != MONGO_OK ) { res = conn->err; return res; } ASSERT( conn->max_bson_size > MONGO_DEFAULT_MAX_BSON_SIZE ); bson_init( b ); for(i=0; i<1200000; i++) { sprintf( key, "%d", i + 10000000 ); bson_append_int( b, key, i ); } bson_finish( b ); ASSERT( bson_size( b ) > conn->max_bson_size ); ASSERT( mongo_insert( conn, "test.foo", b, wc ) == MONGO_ERROR ); ASSERT( conn->err == MONGO_BSON_TOO_LARGE ); mongo_clear_errors( conn ); ASSERT( conn->err == 0 ); bson_init( b2 ); bson_append_int( b2, "foo", 1 ); bson_finish( b2 ); objs[0] = b; objs[1] = b2; ASSERT( mongo_insert_batch( conn, "test.foo", (const bson**)objs, 2, wc, 0 ) == MONGO_ERROR ); ASSERT( conn->err == MONGO_BSON_TOO_LARGE ); mongo_write_concern_destroy( wc ); return 0; }
result_t MongoCollection::_batchInsert(std::vector<const bson*> pdata, int num, int32_t& retVal, AsyncEvent* ac) { if (ac->isSync()) return CHECK_ERROR(CALL_E_NOSYNC); obj_ptr<MongoDB> db(m_db); if (!db) return CHECK_ERROR(CALL_E_INVALID_CALL); retVal = mongo_insert_batch(db->m_conn, m_ns.c_str(), pdata.data(), num, NULL, 0); return 0; }
int test_insert_limits( void ) { char version[10]; mongo conn[1]; int i; char key[10]; bson b[1], b2[1]; bson *objs[2]; /* Test the default max BSON size. */ mongo_init( conn ); ASSERT( conn->max_bson_size == MONGO_DEFAULT_MAX_BSON_SIZE ); /* We'll perform the full test if we're running v2.0 or later. */ if( mongo_get_server_version( version ) != -1 && version[0] <= '1' ) return 0; if ( mongo_connect( conn , TEST_SERVER, 27017 ) ) { printf( "failed to connect\n" ); exit( 1 ); } ASSERT( conn->max_bson_size > MONGO_DEFAULT_MAX_BSON_SIZE ); bson_init( b ); for(i=0; i<1200000; i++) { sprintf( key, "%d", i + 10000000 ); bson_append_int( b, key, i ); } bson_finish( b ); ASSERT( bson_size( b ) > conn->max_bson_size ); ASSERT( mongo_insert( conn, "test.foo", b, NULL ) == MONGO_ERROR ); ASSERT( conn->err == MONGO_BSON_TOO_LARGE ); mongo_clear_errors( conn ); ASSERT( conn->err == 0 ); bson_init( b2 ); bson_append_int( b2, "foo", 1 ); bson_finish( b2 ); objs[0] = b; objs[1] = b2; ASSERT( mongo_insert_batch( conn, "test.foo", (const bson **)objs, 2, NULL, 0 ) == MONGO_ERROR ); ASSERT( conn->err == MONGO_BSON_TOO_LARGE ); return 0; }
static void batch_insert_large_test( void ) { int i, j; bson b[BATCH_SIZE]; const bson *bp[BATCH_SIZE]; for ( j=0; j < BATCH_SIZE; j++ ) bp[j] = &b[j]; for ( i=0; i < ( PER_TRIAL / BATCH_SIZE ); i++ ) { for ( j=0; j < BATCH_SIZE; j++ ) make_large( &b[j], i ); mongo_insert_batch( conn, DB ".batch.large", bp, BATCH_SIZE, NULL, 0 ); for ( j=0; j < BATCH_SIZE; j++ ) bson_destroy( &b[j] ); } }
static void batch_insert_medium_test() { int i, j; bson b[BATCH_SIZE]; bson *bp[BATCH_SIZE]; for ( j=0; j < BATCH_SIZE; j++ ) bp[j] = &b[j]; for ( i=0; i < ( PER_TRIAL / BATCH_SIZE ); i++ ) { for ( j=0; j < BATCH_SIZE; j++ ) make_medium( &b[j], i ); mongo_insert_batch( conn, DB ".batch.medium", bp, BATCH_SIZE ); for ( j=0; j < BATCH_SIZE; j++ ) bson_destroy( &b[j] ); } }
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; }
static void test_insert( mongo *conn ) { mongo_write_concern wc0[1], wc1[1]; bson b[1], b2[1], b3[1], b4[1]; bson *objs[2]; mongo_cmd_drop_collection( conn, TEST_DB, TEST_COL, NULL ); mongo_write_concern_init( wc0 ); mongo_write_concern_set_w( wc0, 0 ); mongo_write_concern_finish( wc0 ); mongo_write_concern_init( wc1 ); mongo_write_concern_set_w( wc1, 1 ); mongo_write_concern_finish( wc1 ); bson_init( b4 ); bson_append_string( b4, "foo", "bar" ); bson_finish( b4 ); ASSERT( mongo_insert( conn, TEST_NS, b4, wc1 ) == MONGO_OK ); ASSERT( mongo_remove( conn, TEST_NS, bson_shared_empty( ), wc1 ) == MONGO_OK ); bson_init( b ); bson_append_new_oid( b, "_id" ); bson_finish( b ); ASSERT( mongo_insert( conn, TEST_NS, b, NULL ) == MONGO_OK ); /* This fails but returns OK with write concern w = 0 */ ASSERT( mongo_insert( conn, TEST_NS, b, wc0 ) == MONGO_OK ); /* no getLastError request */ ASSERT( mongo_insert( conn, TEST_NS, b, wc1 ) == MONGO_ERROR ); ASSERT( conn->err == MONGO_WRITE_ERROR ); ASSERT_EQUAL_STRINGS( conn->errstr, "See conn->lasterrstr for details." ); ASSERT_EQUAL_STRINGS( conn->lasterrstr, "E11000 duplicate key error index" ); ASSERT( conn->lasterrcode == 11000 ); mongo_clear_errors( conn ); /* Still fails but returns OK with write concern w = 0 */ ASSERT( mongo_insert( conn, TEST_NS, b, wc0 ) == MONGO_OK ); /* But not when we set a default write concern on the conn. */ mongo_set_write_concern( conn, wc1 ); ASSERT( mongo_insert( conn, TEST_NS, b, NULL ) != MONGO_OK ); ASSERT( conn->err == MONGO_WRITE_ERROR ); ASSERT_EQUAL_STRINGS( conn->errstr, "See conn->lasterrstr for details." ); ASSERT_EQUAL_STRINGS( conn->lasterrstr, "E11000 duplicate key error index" ); ASSERT( conn->lasterrcode == 11000 ); /* Now test batch insert. */ bson_init( b2 ); bson_append_new_oid( b2, "_id" ); bson_finish( b2 ); bson_init( b3 ); bson_append_new_oid( b3, "_id" ); bson_finish( b3 ); objs[0] = b2; objs[1] = b3; /* Insert two new documents by insert_batch. */ conn->write_concern = NULL; ASSERT( mongo_count( conn, TEST_DB, TEST_COL, bson_shared_empty( ) ) == 1 ); ASSERT( mongo_insert_batch( conn, TEST_NS, (const bson **)objs, 2, NULL, 0 ) == MONGO_OK ); ASSERT( mongo_count( conn, TEST_DB, TEST_COL, bson_shared_empty( ) ) == 3 ); /* This should definitely fail if we try again with write concern. */ mongo_clear_errors( conn ); ASSERT( mongo_insert_batch( conn, TEST_NS, (const bson **)objs, 2, wc1, 0 ) == MONGO_ERROR ); ASSERT( conn->err == MONGO_WRITE_ERROR ); ASSERT_EQUAL_STRINGS( conn->errstr, "See conn->lasterrstr for details." ); ASSERT_EQUAL_STRINGS( conn->lasterrstr, "E11000 duplicate key error index" ); ASSERT( conn->lasterrcode == 11000 ); /* But it will succeed without the write concern set. */ ASSERT( mongo_insert_batch( conn, TEST_NS, (const bson **)objs, 2, NULL, 0 ) == MONGO_OK ); bson_destroy( b ); bson_destroy( b2 ); bson_destroy( b3 ); bson_destroy( b4 ); mongo_write_concern_destroy( wc0 ); mongo_write_concern_destroy( wc1 ); }
/* 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 flush_to_mongo(st_http_request * p, int counter) { mongo conn; mongo_init(&conn); mongo_set_op_timeout(&conn, 10000); int status = mongo_client(&conn, globalArgs.host, globalArgs.port); if (status != MONGO_OK) { switch (conn.err) { case MONGO_CONN_SUCCESS: printf("Connected to mongo\n"); case MONGO_CONN_NO_SOCKET: printf("FAIL: Could not create a socket!\n"); break; case MONGO_CONN_ADDR_FAIL: printf("FAIL: MONGO_CONN_ADDR_FAIL: %s\n", globalArgs.host); break; case MONGO_CONN_NOT_MASTER: printf("FAIL: MONGO_CONN_NOT_MASTER\n"); break; case MONGO_CONN_BAD_SET_NAME: printf("FAIL: MONGO_CONN_BAD_SET_NAME\n"); break; case MONGO_CONN_NO_PRIMARY: printf("FAIL: MONGO_CONN_NO_PRIMARY\n"); break; case MONGO_IO_ERROR: printf("FAIL: MONGO_IO_ERROR\n"); break; case MONGO_SOCKET_ERROR: printf("FAIL: MONGO_SOCKET_ERROR\n"); break; case MONGO_READ_SIZE_ERROR: printf("FAIL: MONGO_READ_SIZE_ERROR\n"); break; case MONGO_COMMAND_FAILED: printf("FAIL: MONGO_COMMAND_FAILED\n"); break; case MONGO_WRITE_ERROR: printf("FAIL: MONGO_WRITE_ERROR\n"); break; case MONGO_NS_INVALID: printf("FAIL: MONGO_NS_INVALID\n"); break; case MONGO_BSON_INVALID: printf("FAIL: MONGO_BSON_INVALIDr\n"); break; case MONGO_BSON_NOT_FINISHED: printf("FAIL: MONGO_BSON_NOT_FINISHED\n"); break; case MONGO_BSON_TOO_LARGE: printf("FAIL: MONGO_BSON_TOO_LARGEr\n"); break; case MONGO_WRITE_CONCERN_INVALID: printf("FAIL: Mongo write concern invalid\n"); break; case MONGO_CONN_FAIL: printf ("FAIL: Mongo connection fail. Make sure it's listening at %s:%d\n", globalArgs.host, globalArgs.port); break; } exit(EXIT_FAILURE); } bson **bps; bps = (bson **) malloc(sizeof(bson *) * counter); char *fields = globalArgs.fields; int i = 0; for (i = 0; i < counter; i++) { bson *bp = (bson *) malloc(sizeof(bson)); bson_init(bp); bson_append_new_oid(bp, "_id"); if (fields == NULL || strstr(fields, "req_ip") != NULL) bson_append_string(bp, "req_ip", p[i].req_ip); if (fields == NULL || strstr(fields, "req_ident") != NULL) bson_append_string(bp, "req_ident", p[i].req_ident); if (fields == NULL || strstr(fields, "req_user") != NULL) bson_append_string(bp, "req_user", p[i].req_user); if (fields == NULL || strstr(fields, "req_datetime") != NULL) bson_append_string(bp, "req_datetime", p[i].req_datetime); if (fields == NULL || strstr(fields, "req_method") != NULL) bson_append_string(bp, "req_method", p[i].req_method); if (fields == NULL || strstr(fields, "req_uri") != NULL) bson_append_string(bp, "req_uri", p[i].req_uri); if (fields == NULL || strstr(fields, "req_proto") != NULL) bson_append_string(bp, "req_proto", p[i].req_proto); if (fields == NULL || strstr(fields, "resp_code") != NULL) bson_append_int(bp, "resp_code", p[i].resp_code); if (fields == NULL || strstr(fields, "resp_bytes") != NULL) bson_append_int(bp, "resp_bytes", atoi(p[i].resp_bytes)); if (fields == NULL || strstr(fields, "req_referer") != NULL) bson_append_string(bp, "req_referer", p[i].req_referer); if (fields == NULL || strstr(fields, "req_agent") != NULL) bson_append_string(bp, "req_agent", p[i].req_agent); bson_finish(bp); bps[i] = bp; } mongo_insert_batch(&conn, globalArgs.collection, (const bson **) bps, counter, 0, MONGO_CONTINUE_ON_ERROR); mongo_destroy(&conn); int j = 0; for (j = 0; j < counter; j++) { bson_destroy(bps[j]); free(bps[j]); } free(bps); return (0); }