bson_ext 1.3.1 → 1.4.0

data/ext/cmongo/c-driver/src/platform_hacks.h

@@ -0,0 +1,93 @@
+/* platform_hacks.h */
+/*    Copyright 2009, 2010 10gen Inc.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+
+/* all platform-specific ifdefs should go here */
+
+#ifndef _PLATFORM_HACKS_H_
+#define _PLATFORM_HACKS_H_
+
+#ifdef __GNUC__
+#define MONGO_INLINE static __inline__
+#else
+#define MONGO_INLINE static
+#endif
+
+#ifdef __cplusplus
+#define MONGO_EXTERN_C_START extern "C" {
+#define MONGO_EXTERN_C_END }
+#else
+#define MONGO_EXTERN_C_START
+#define MONGO_EXTERN_C_END
+#endif
+
+
+#if defined(MONGO_HAVE_STDINT) || __STDC_VERSION__ >= 199901L
+#include <stdint.h>
+#elif defined(MONGO_HAVE_UNISTD)
+#include <unistd.h>
+#elif defined(MONGO_USE__INT64)
+typedef __int64 int64_t;
+typedef unsigned __int64 uint64_t;
+#elif defined(MONGO_USE_LONG_LONG_INT)
+typedef long long int int64_t;
+typedef unsigned long long int uint64_t;
+#else
+#error must have a 64bit int type
+#endif
+
+/* big endian is only used for OID generation. little is used everywhere else */
+#ifdef MONGO_BIG_ENDIAN
+#define bson_little_endian64(out, in) ( bson_swap_endian64(out, in) )
+#define bson_little_endian32(out, in) ( bson_swap_endian32(out, in) )
+#define bson_big_endian64(out, in) ( memcpy(out, in, 8) )
+#define bson_big_endian32(out, in) ( memcpy(out, in, 4) )
+#else
+#define bson_little_endian64(out, in) ( memcpy(out, in, 8) )
+#define bson_little_endian32(out, in) ( memcpy(out, in, 4) )
+#define bson_big_endian64(out, in) ( bson_swap_endian64(out, in) )
+#define bson_big_endian32(out, in) ( bson_swap_endian32(out, in) )
+#endif
+
+MONGO_EXTERN_C_START
+
+MONGO_INLINE void bson_swap_endian64(void* outp, const void* inp){
+    const char *in = (const char*)inp;
+    char *out = (char*)outp;
+
+    out[0] = in[7];
+    out[1] = in[6];
+    out[2] = in[5];
+    out[3] = in[4];
+    out[4] = in[3];
+    out[5] = in[2];
+    out[6] = in[1];
+    out[7] = in[0];
+
+}
+MONGO_INLINE void bson_swap_endian32(void* outp, const void* inp){
+    const char *in = (const char*)inp;
+    char *out = (char*)outp;
+
+    out[0] = in[3];
+    out[1] = in[2];
+    out[2] = in[1];
+    out[3] = in[0];
+}
+
+MONGO_EXTERN_C_END
+
+#endif

data/ext/cmongo/c-driver/test/all_types.c

@@ -0,0 +1,223 @@
+#include "test.h"
+#include "bson.h"
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+int main(){
+    bson_buffer bb;
+    bson b;
+    bson_iterator it, it2, it3;
+    bson_oid_t oid;
+    bson_timestamp_t ts;
+    bson_timestamp_t ts_result;
+
+    ts.i = 1;
+    ts.t = 2;
+
+    bson_buffer_init(&bb);
+    bson_append_double(&bb, "d", 3.14);
+    bson_append_string(&bb, "s", "hello");
+    bson_append_string_n(&bb, "s_n", "goodbye cruel world", 7);
+
+    {
+        bson_buffer *obj = bson_append_start_object(&bb, "o");
+        bson_buffer *arr = bson_append_start_array(obj, "a");
+        bson_append_binary(arr, "0", 8, "w\0rld", 5);
+        bson_append_finish_object(arr);
+        bson_append_finish_object(obj);
+    }
+
+    bson_append_undefined(&bb, "u");
+
+    bson_oid_from_string(&oid, "010203040506070809101112");
+    ASSERT(!memcmp(oid.bytes, "\x001\x002\x003\x004\x005\x006\x007\x008\x009\x010\x011\x012", 12));
+    bson_append_oid(&bb, "oid", &oid);
+
+    bson_append_bool(&bb, "b", 1);
+    bson_append_date(&bb, "date", 0x0102030405060708);
+    bson_append_null(&bb, "n");
+    bson_append_regex(&bb, "r", "^asdf", "imx");
+    /* no dbref test (deprecated) */
+    bson_append_code(&bb, "c", "function(){}");
+    bson_append_code_n(&bb, "c_n", "function(){}garbage", 12);
+    bson_append_symbol(&bb, "symbol", "SYMBOL");
+    bson_append_symbol_n(&bb, "symbol_n", "SYMBOL and garbage", 6);
+
+    {
+        bson_buffer scope_buf;
+        bson scope;
+        bson_buffer_init(&scope_buf);
+        bson_append_int(&scope_buf, "i", 123);
+        bson_from_buffer(&scope, &scope_buf);
+
+        bson_append_code_w_scope(&bb, "cws", "function(){return i}", &scope);
+        bson_destroy(&scope);
+    }
+
+    bson_append_timestamp(&bb, "timestamp", &ts);
+    bson_append_long(&bb, "l", 0x1122334455667788);
+
+    bson_from_buffer(&b, &bb);
+
+    bson_print(&b);
+
+    bson_iterator_init(&it, b.data);
+
+    ASSERT(bson_iterator_more(&it));
+    ASSERT(bson_iterator_next(&it) == bson_double);
+    ASSERT(bson_iterator_type(&it) == bson_double);
+    ASSERT(!strcmp(bson_iterator_key(&it), "d"));
+    ASSERT(bson_iterator_double(&it) == 3.14);
+
+    ASSERT(bson_iterator_more(&it));
+    ASSERT(bson_iterator_next(&it) == bson_string);
+    ASSERT(bson_iterator_type(&it) == bson_string);
+    ASSERT(!strcmp(bson_iterator_key(&it), "s"));
+    ASSERT(!strcmp(bson_iterator_string(&it), "hello"));
+
+    ASSERT(bson_iterator_more(&it));
+    ASSERT(bson_iterator_next(&it) == bson_string);
+    ASSERT(bson_iterator_type(&it) == bson_string);
+    ASSERT(!strcmp(bson_iterator_key(&it), "s_n"));
+    ASSERT(!strcmp(bson_iterator_string(&it), "goodbye"));
+
+    ASSERT(bson_iterator_more(&it));
+    ASSERT(bson_iterator_next(&it) == bson_object);
+    ASSERT(bson_iterator_type(&it) == bson_object);
+    ASSERT(!strcmp(bson_iterator_key(&it), "o"));
+    bson_iterator_subiterator(&it, &it2);
+
+    ASSERT(bson_iterator_more(&it2));
+    ASSERT(bson_iterator_next(&it2) == bson_array);
+    ASSERT(bson_iterator_type(&it2) == bson_array);
+    ASSERT(!strcmp(bson_iterator_key(&it2), "a"));
+    bson_iterator_subiterator(&it2, &it3);
+
+    ASSERT(bson_iterator_more(&it3));
+    ASSERT(bson_iterator_next(&it3) == bson_bindata);
+    ASSERT(bson_iterator_type(&it3) == bson_bindata);
+    ASSERT(!strcmp(bson_iterator_key(&it3), "0"));
+    ASSERT(bson_iterator_bin_type(&it3) == 8);
+    ASSERT(bson_iterator_bin_len(&it3) == 5);
+    ASSERT(!memcmp(bson_iterator_bin_data(&it3), "w\0rld", 5));
+
+    ASSERT(bson_iterator_more(&it3));
+    ASSERT(bson_iterator_next(&it3) == bson_eoo);
+    ASSERT(bson_iterator_type(&it3) == bson_eoo);
+    ASSERT(!bson_iterator_more(&it3));
+
+    ASSERT(bson_iterator_more(&it2));
+    ASSERT(bson_iterator_next(&it2) == bson_eoo);
+    ASSERT(bson_iterator_type(&it2) == bson_eoo);
+    ASSERT(!bson_iterator_more(&it2));
+
+    ASSERT(bson_iterator_more(&it));
+    ASSERT(bson_iterator_next(&it) == bson_undefined);
+    ASSERT(bson_iterator_type(&it) == bson_undefined);
+    ASSERT(!strcmp(bson_iterator_key(&it), "u"));
+
+    ASSERT(bson_iterator_more(&it));
+    ASSERT(bson_iterator_next(&it) == bson_oid);
+    ASSERT(bson_iterator_type(&it) == bson_oid);
+    ASSERT(!strcmp(bson_iterator_key(&it), "oid"));
+    ASSERT(!memcmp(bson_iterator_oid(&it)->bytes, "\x001\x002\x003\x004\x005\x006\x007\x008\x009\x010\x011\x012", 12));
+    ASSERT(bson_iterator_oid(&it)->ints[0] == oid.ints[0]);
+    ASSERT(bson_iterator_oid(&it)->ints[1] == oid.ints[1]);
+    ASSERT(bson_iterator_oid(&it)->ints[2] == oid.ints[2]);
+
+    ASSERT(bson_iterator_more(&it));
+    ASSERT(bson_iterator_next(&it) == bson_bool);
+    ASSERT(bson_iterator_type(&it) == bson_bool);
+    ASSERT(!strcmp(bson_iterator_key(&it), "b"));
+    ASSERT(bson_iterator_bool(&it) == 1);
+
+    ASSERT(bson_iterator_more(&it));
+    ASSERT(bson_iterator_next(&it) == bson_date);
+    ASSERT(bson_iterator_type(&it) == bson_date);
+    ASSERT(!strcmp(bson_iterator_key(&it), "date"));
+    ASSERT(bson_iterator_date(&it) == 0x0102030405060708);
+
+    ASSERT(bson_iterator_more(&it));
+    ASSERT(bson_iterator_next(&it) == bson_null);
+    ASSERT(bson_iterator_type(&it) == bson_null);
+    ASSERT(!strcmp(bson_iterator_key(&it), "n"));
+
+    ASSERT(bson_iterator_more(&it));
+    ASSERT(bson_iterator_next(&it) == bson_regex);
+    ASSERT(bson_iterator_type(&it) == bson_regex);
+    ASSERT(!strcmp(bson_iterator_key(&it), "r"));
+    ASSERT(!strcmp(bson_iterator_regex(&it), "^asdf"));
+    ASSERT(!strcmp(bson_iterator_regex_opts(&it), "imx"));
+
+    ASSERT(bson_iterator_more(&it));
+    ASSERT(bson_iterator_next(&it) == bson_code);
+    ASSERT(bson_iterator_type(&it) == bson_code);
+    ASSERT(!strcmp(bson_iterator_key(&it), "c"));
+    ASSERT(!strcmp(bson_iterator_string(&it), "function(){}"));
+    ASSERT(!strcmp(bson_iterator_code(&it), "function(){}"));
+
+    ASSERT(bson_iterator_more(&it));
+    ASSERT(bson_iterator_next(&it) == bson_code);
+    ASSERT(bson_iterator_type(&it) == bson_code);
+    ASSERT(!strcmp(bson_iterator_key(&it), "c_n"));
+    ASSERT(!strcmp(bson_iterator_string(&it), "function(){}"));
+    ASSERT(!strcmp(bson_iterator_code(&it), "function(){}"));
+
+    ASSERT(bson_iterator_more(&it));
+    ASSERT(bson_iterator_next(&it) == bson_symbol);
+    ASSERT(bson_iterator_type(&it) == bson_symbol);
+    ASSERT(!strcmp(bson_iterator_key(&it), "symbol"));
+    ASSERT(!strcmp(bson_iterator_string(&it), "SYMBOL"));
+
+    ASSERT(bson_iterator_more(&it));
+    ASSERT(bson_iterator_next(&it) == bson_symbol);
+    ASSERT(bson_iterator_type(&it) == bson_symbol);
+    ASSERT(!strcmp(bson_iterator_key(&it), "symbol_n"));
+    ASSERT(!strcmp(bson_iterator_string(&it), "SYMBOL"));
+
+    ASSERT(bson_iterator_more(&it));
+    ASSERT(bson_iterator_next(&it) == bson_codewscope);
+    ASSERT(bson_iterator_type(&it) == bson_codewscope);
+    ASSERT(!strcmp(bson_iterator_key(&it), "cws"));
+    ASSERT(!strcmp(bson_iterator_code(&it), "function(){return i}"));
+
+    {
+        bson scope;
+        bson_iterator_code_scope(&it, &scope);
+        bson_iterator_init(&it2, scope.data);
+
+        ASSERT(bson_iterator_more(&it2));
+        ASSERT(bson_iterator_next(&it2) == bson_int);
+        ASSERT(bson_iterator_type(&it2) == bson_int);
+        ASSERT(!strcmp(bson_iterator_key(&it2), "i"));
+        ASSERT(bson_iterator_int(&it2) == 123);
+
+        ASSERT(bson_iterator_more(&it2));
+        ASSERT(bson_iterator_next(&it2) == bson_eoo);
+        ASSERT(bson_iterator_type(&it2) == bson_eoo);
+        ASSERT(!bson_iterator_more(&it2));
+    }
+
+    ASSERT(bson_iterator_more(&it));
+    ASSERT(bson_iterator_next(&it) == bson_timestamp);
+    ASSERT(bson_iterator_type(&it) == bson_timestamp);
+    ASSERT(!strcmp(bson_iterator_key(&it), "timestamp"));
+    ts_result = bson_iterator_timestamp(&it);
+    ASSERT( ts_result.i == 1 );
+    ASSERT( ts_result.t == 2);
+
+    ASSERT(bson_iterator_more(&it));
+    ASSERT(bson_iterator_next(&it) == bson_long);
+    ASSERT(bson_iterator_type(&it) == bson_long);
+    ASSERT(!strcmp(bson_iterator_key(&it), "l"));
+    ASSERT(bson_iterator_long(&it) == 0x1122334455667788);
+
+    ASSERT(bson_iterator_more(&it));
+    ASSERT(bson_iterator_next(&it) == bson_eoo);
+    ASSERT(bson_iterator_type(&it) == bson_eoo);
+    ASSERT(!bson_iterator_more(&it));
+
+    return 0;
+}
+

data/ext/cmongo/c-driver/test/auth.c

@@ -0,0 +1,28 @@
+#include "test.h"
+#include "mongo.h"
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+static mongo_connection conn[1];
+static const char* db = "test";
+
+int main(){
+
+    INIT_SOCKETS_FOR_WINDOWS;
+
+    if (mongo_connect( conn , TEST_SERVER, 27017 )){
+        printf("failed to connect\n");
+        exit(1);
+    }
+
+    mongo_cmd_drop_db(conn, db);
+
+    ASSERT(mongo_cmd_authenticate(conn, db, "user", "password") == 0);
+    mongo_cmd_add_user(conn, db, "user", "password");
+    ASSERT(mongo_cmd_authenticate(conn, db, "user", "password") == 1);
+
+    mongo_cmd_drop_db(conn, db);
+    mongo_destroy(conn);
+    return 0;
+}

data/ext/cmongo/c-driver/test/benchmark.c

@@ -0,0 +1,434 @@
+/* test.c */
+
+#include "test.h"
+#include "mongo.h"
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#ifndef _WIN32
+#include <sys/time.h>
+#endif
+
+/* supports preprocessor concatenation */
+#define DB "benchmarks"
+
+/* finds without indexes */
+#define DO_SLOW_TESTS 1
+
+#ifndef TEST_SERVER
+#define TEST_SERVER "127.0.0.1"
+#endif
+
+#define PER_TRIAL 5000
+#define BATCH_SIZE  100
+
+static mongo_connection conn[1];
+
+static void make_small(bson * out, int i){
+    bson_buffer bb;
+    bson_buffer_init(&bb);
+    bson_append_new_oid(&bb, "_id");
+    bson_append_int(&bb, "x", i);
+    bson_from_buffer(out, &bb);
+}
+
+static void make_medium(bson * out, int i){
+    bson_buffer bb;
+    bson_buffer_init(&bb);
+    bson_append_new_oid(&bb, "_id");
+    bson_append_int(&bb, "x", i);
+    bson_append_int(&bb, "integer", 5);
+    bson_append_double(&bb, "number", 5.05);
+    bson_append_bool(&bb, "boolean", 0);
+
+    bson_append_start_array(&bb, "array");
+    bson_append_string(&bb, "0", "test");
+    bson_append_string(&bb, "1", "benchmark");
+    bson_append_finish_object(&bb);
+
+    bson_from_buffer(out, &bb);
+}
+
+static const char *words[14] = 
+    {"10gen","web","open","source","application","paas",
+    "platform-as-a-service","technology","helps",
+    "developers","focus","building","mongodb","mongo"};
+
+static void make_large(bson * out, int i){
+    int num;
+    char numstr[4];
+    bson_buffer bb;
+    bson_buffer_init(&bb);
+
+    bson_append_new_oid(&bb, "_id");
+    bson_append_int(&bb, "x", i);
+    bson_append_string(&bb, "base_url", "http://www.example.com/test-me");
+    bson_append_int(&bb, "total_word_count", 6743);
+    bson_append_int(&bb, "access_time", 999); /*TODO use date*/
+
+    bson_append_start_object(&bb, "meta_tags");
+    bson_append_string(&bb, "description", "i am a long description string");
+    bson_append_string(&bb, "author", "Holly Man");
+    bson_append_string(&bb, "dynamically_created_meta_tag", "who know\n what");
+    bson_append_finish_object(&bb);
+
+    bson_append_start_object(&bb, "page_structure");
+    bson_append_int(&bb, "counted_tags", 3450);
+    bson_append_int(&bb, "no_of_js_attached", 10);
+    bson_append_int(&bb, "no_of_images", 6);
+    bson_append_finish_object(&bb);
+
+
+    bson_append_start_array(&bb, "harvested_words");
+    for (num=0; num < 14*20; num++){
+        bson_numstr(numstr, num);
+        bson_append_string(&bb, numstr, words[num%14]);
+    }
+    bson_append_finish_object(&bb);
+
+    bson_from_buffer(out, &bb);
+}
+
+static void serialize_small_test(){
+    int i;
+    bson b;
+    for (i=0; i<PER_TRIAL; i++){
+        make_small(&b, i);
+        bson_destroy(&b);
+    }
+}
+static void serialize_medium_test(){
+    int i;
+    bson b;
+    for (i=0; i<PER_TRIAL; i++){
+        make_medium(&b, i);
+        bson_destroy(&b);
+    }
+}
+static void serialize_large_test(){
+    int i;
+    bson b;
+    for (i=0; i<PER_TRIAL; i++){
+        make_large(&b, i);
+        bson_destroy(&b);
+    }
+}
+static void single_insert_small_test(){
+    int i;
+    bson b;
+    for (i=0; i<PER_TRIAL; i++){
+        make_small(&b, i);
+        mongo_insert(conn, DB ".single.small", &b);
+        bson_destroy(&b);
+    }
+}
+
+static void single_insert_medium_test(){
+    int i;
+    bson b;
+    for (i=0; i<PER_TRIAL; i++){
+        make_medium(&b, i);
+        mongo_insert(conn, DB ".single.medium", &b);
+        bson_destroy(&b);
+    }
+}
+
+static void single_insert_large_test(){
+    int i;
+    bson b;
+    for (i=0; i<PER_TRIAL; i++){
+        make_large(&b, i);
+        mongo_insert(conn, DB ".single.large", &b);
+        bson_destroy(&b);
+    }
+}
+
+static void index_insert_small_test(){
+    int i;
+    bson b;
+    ASSERT(mongo_create_simple_index(conn, DB ".index.small", "x", 0, NULL));
+    for (i=0; i<PER_TRIAL; i++){
+        make_small(&b, i);
+        mongo_insert(conn, DB ".index.small", &b);
+        bson_destroy(&b);
+    }
+}
+
+static void index_insert_medium_test(){
+    int i;
+    bson b;
+    ASSERT(mongo_create_simple_index(conn, DB ".index.medium", "x", 0, NULL));
+    for (i=0; i<PER_TRIAL; i++){
+        make_medium(&b, i);
+        mongo_insert(conn, DB ".index.medium", &b);
+        bson_destroy(&b);
+    }
+}
+
+static void index_insert_large_test(){
+    int i;
+    bson b;
+    ASSERT(mongo_create_simple_index(conn, DB ".index.large", "x", 0, NULL));
+    for (i=0; i<PER_TRIAL; i++){
+        make_large(&b, i);
+        mongo_insert(conn, DB ".index.large", &b);
+        bson_destroy(&b);
+    }
+}
+
+static void batch_insert_small_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_small(&b[j], i);
+
+        mongo_insert_batch(conn, DB ".batch.small", bp, BATCH_SIZE);
+
+        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]);
+    }
+}
+
+static void batch_insert_large_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_large(&b[j], i);
+
+        mongo_insert_batch(conn, DB ".batch.large", bp, BATCH_SIZE);
+
+        for (j=0; j < BATCH_SIZE; j++)
+            bson_destroy(&b[j]);
+    }
+}
+
+static void make_query(bson* b){
+    bson_buffer bb;
+    bson_buffer_init(&bb);
+    bson_append_int(&bb, "x", PER_TRIAL/2);
+    bson_from_buffer(b, &bb);
+}
+
+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));
+        bson_destroy(&b);
+    }
+}
+
+static void find_one_noindex_small_test()  {find_one(DB ".single.small");}
+static void find_one_noindex_medium_test() {find_one(DB ".single.medium");}
+static void find_one_noindex_large_test()  {find_one(DB ".single.large");}
+
+static void find_one_index_small_test()  {find_one(DB ".index.small");}
+static void find_one_index_medium_test() {find_one(DB ".index.medium");}
+static void find_one_index_large_test()  {find_one(DB ".index.large");}
+
+static void find(const char* ns){
+    bson b;
+    int i;
+    for (i=0; i < PER_TRIAL; i++){
+        mongo_cursor * cursor;
+        make_query(&b);
+        cursor = mongo_find(conn, ns, &b, NULL, 0,0,0);
+        ASSERT(cursor);
+
+        while(mongo_cursor_next(cursor))
+        {}
+
+        mongo_cursor_destroy(cursor);
+        bson_destroy(&b);
+    }
+}
+
+static void find_noindex_small_test()  {find(DB ".single.small");}
+static void find_noindex_medium_test() {find(DB ".single.medium");}
+static void find_noindex_large_test()  {find(DB ".single.large");}
+
+static void find_index_small_test()  {find(DB ".index.small");}
+static void find_index_medium_test() {find(DB ".index.medium");}
+static void find_index_large_test()  {find(DB ".index.large");}
+
+
+static void find_range(const char* ns){
+    int i;
+    bson b;
+
+    for (i=0; i < PER_TRIAL; i++){
+        int j=0;
+        mongo_cursor * cursor;
+        bson_buffer bb;
+
+        bson_buffer_init(&bb);
+        bson_append_start_object(&bb, "x");
+        bson_append_int(&bb, "$gt", PER_TRIAL/2);
+        bson_append_int(&bb, "$lt", PER_TRIAL/2 + BATCH_SIZE);
+        bson_append_finish_object(&bb);
+        bson_from_buffer(&b, &bb);
+
+        cursor = mongo_find(conn, ns, &b, NULL, 0,0,0);
+        ASSERT(cursor);
+
+        while(mongo_cursor_next(cursor)) {
+            j++;
+        }
+        ASSERT(j == BATCH_SIZE-1);
+
+        mongo_cursor_destroy(cursor);
+        bson_destroy(&b);
+    }
+}
+
+static void find_range_small_test()  {find_range(DB ".index.small");}
+static void find_range_medium_test() {find_range(DB ".index.medium");}
+static void find_range_large_test()  {find_range(DB ".index.large");}
+
+typedef void(*nullary)();
+static void time_it(nullary func, const char* name, bson_bool_t gle){
+    double timer;
+    double ops;
+
+#ifdef _WIN32
+    int64_t start, end;
+
+    start = GetTickCount64();
+    func();
+    if (gle) ASSERT(!mongo_cmd_get_last_error(conn, DB, NULL));
+    end = GetTickCount64();
+
+    timer = end - start;
+#else
+    struct timeval start, end;
+
+    gettimeofday(&start, NULL);
+    func();
+    if (gle) ASSERT(!mongo_cmd_get_last_error(conn, DB, NULL));
+    gettimeofday(&end, NULL);
+
+    timer = end.tv_sec - start.tv_sec;
+    timer *= 1000000;
+    timer += end.tv_usec - start.tv_usec;
+#endif
+
+    ops = PER_TRIAL / timer;
+    ops *= 1000000;
+
+    printf("%-45s\t%15f\n", name, ops);
+}
+
+#define TIME(func, gle) (time_it(func, #func, gle))
+
+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_connection_options opts;
+
+    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);
+    }
+
+    clean();
+
+    printf("-----\n");
+    TIME(serialize_small_test, 0);
+    TIME(serialize_medium_test, 0);
+    TIME(serialize_large_test, 0);
+
+    printf("-----\n");
+    TIME(single_insert_small_test, 1);
+    TIME(single_insert_medium_test, 1);
+    TIME(single_insert_large_test, 1);
+
+    printf("-----\n");
+    TIME(index_insert_small_test, 1);
+    TIME(index_insert_medium_test, 1);
+    TIME(index_insert_large_test, 1);
+
+    printf("-----\n");
+    TIME(batch_insert_small_test, 1);
+    TIME(batch_insert_medium_test, 1);
+    TIME(batch_insert_large_test, 1);
+
+#if DO_SLOW_TESTS
+    printf("-----\n");
+    TIME(find_one_noindex_small_test, 0);
+    TIME(find_one_noindex_medium_test, 0);
+    TIME(find_one_noindex_large_test, 0);
+#endif
+
+    printf("-----\n");
+    TIME(find_one_index_small_test, 0);
+    TIME(find_one_index_medium_test, 0);
+    TIME(find_one_index_large_test, 0);
+
+#if DO_SLOW_TESTS
+    printf("-----\n");
+    TIME(find_noindex_small_test, 0);
+    TIME(find_noindex_medium_test, 0);
+    TIME(find_noindex_large_test, 0);
+#endif
+
+    printf("-----\n");
+    TIME(find_index_small_test, 0);
+    TIME(find_index_medium_test, 0);
+    TIME(find_index_large_test, 0);
+
+    printf("-----\n");
+    TIME(find_range_small_test, 0);
+    TIME(find_range_medium_test, 0);
+    TIME(find_range_large_test, 0);
+
+
+    mongo_destroy(conn);
+
+    return 0;
+}