CDRIVER-360 add additional geo index options

Closes #109

Author: TylerBrock

NEWS

@@ -1,3 +1,9 @@
+TODO: Existing complex index names may contain a zero instead of a type due to
+a bug in mongoc_collection_keys_to_index_string. As a result those indexes may 
+be hard to drop from the driver as they have a name you would not expect.
+
+-- Ask Tyler if you need more info.
+
 mongo-c-driver 1.0.2
 ====================
 

build/cmake/libmongoc.def

@@ -129,6 +129,8 @@ mongoc_gridfs_find_one_by_filename
 mongoc_gridfs_get_chunks
 mongoc_gridfs_get_files
 mongoc_gridfs_remove_by_filename
+mongoc_index_opt_geo_get_default
+mongoc_index_opt_geo_init
 mongoc_index_opt_get_default
 mongoc_index_opt_init
 mongoc_init

src/libmongoc.symbols

@@ -130,6 +130,8 @@ mongoc_gridfs_find_one_by_filename
 mongoc_gridfs_get_chunks
 mongoc_gridfs_get_files
 mongoc_gridfs_remove_by_filename
+mongoc_index_opt_geo_get_default
+mongoc_index_opt_geo_init
 mongoc_index_opt_get_default
 mongoc_index_opt_init
 mongoc_init

src/mongoc/mongoc-collection.c

@@ -683,10 +683,24 @@ mongoc_collection_keys_to_index_string (const bson_t *keys)
    s = bson_string_new (NULL);
 
    while (bson_iter_next (&iter)) {
-      bson_string_append_printf (s,
-                                 (i++ ? "_%s_%d" : "%s_%d"),
-                                 bson_iter_key (&iter),
-                                 bson_iter_int32 (&iter));
+
+      /* Index type can be specified as a string ("2d") or as an integer representing direction */
+      if (bson_iter_type(&iter) == BSON_TYPE_UTF8)
+      {
+          bson_string_append_printf (s,
+                                     (i++ ? "_%s_%s" : "%s_%s"),
+                                     bson_iter_key (&iter),
+                                     bson_iter_utf8 (&iter, NULL));
+      }
+      else
+      {
+
+          bson_string_append_printf (s,
+                                     (i++ ? "_%s_%d" : "%s_%d"),
+                                     bson_iter_key (&iter),
+                                     bson_iter_int32 (&iter));
+      }
+
    }
 
    return bson_string_free (s, false);
@@ -811,12 +825,14 @@ mongoc_collection_create_index (mongoc_collection_t      *collection,
                                 bson_error_t             *error)
 {
    const mongoc_index_opt_t *def_opt;
+   const mongoc_index_opt_geo_t *def_geo;
    bson_error_t local_error;
    const char *name;
    bson_t cmd = BSON_INITIALIZER;
    bson_t ar;
    bson_t doc;
    bson_t reply;
+   const mongoc_index_opt_geo_t *geo_opt;
    char *alloc_name = NULL;
    bool ret = false;
 
@@ -870,6 +886,25 @@ mongoc_collection_create_index (mongoc_collection_t      *collection,
    if (opt->language_override != def_opt->language_override) {
       BSON_APPEND_UTF8 (&doc, "language_override", opt->language_override);
    }
+   if (opt->geo_options) {
+       geo_opt = opt->geo_options;
+       def_geo = mongoc_index_opt_geo_get_default ();
+       if (geo_opt->twod_sphere_version != def_geo->twod_sphere_version) {
+          BSON_APPEND_INT32 (&doc, "2dsphereIndexVersion", geo_opt->twod_sphere_version);
+       }
+       if (geo_opt->twod_bits_precision != def_geo->twod_bits_precision) {
+          BSON_APPEND_INT32 (&doc, "bits", geo_opt->twod_bits_precision);
+       }
+       if (geo_opt->twod_location_min != def_geo->twod_location_min) {
+          BSON_APPEND_DOUBLE (&doc, "min", geo_opt->twod_location_min);
+       }
+       if (geo_opt->twod_location_max != def_geo->twod_location_max) {
+          BSON_APPEND_DOUBLE (&doc, "max", geo_opt->twod_location_max);
+       }
+       if (geo_opt->haystack_bucket_size != def_geo->haystack_bucket_size) {
+          BSON_APPEND_DOUBLE (&doc, "bucketSize", geo_opt->haystack_bucket_size);
+       }
+   }
    bson_append_document_end (&ar, &doc);
    bson_append_array_end (&cmd, &ar);
 

src/mongoc/mongoc-index.c

@@ -32,15 +32,28 @@ static mongoc_index_opt_t gMongocIndexOptDefault = {
    0,
    -1,
    -1,
+   NULL
 };
 
+static mongoc_index_opt_geo_t gMongocIndexOptGeoDefault = {
+   26,
+   -90,
+   90,
+   -1,
+   2
+};
 
 const mongoc_index_opt_t *
 mongoc_index_opt_get_default (void)
 {
    return &gMongocIndexOptDefault;
 }
 
+const mongoc_index_opt_geo_t *
+mongoc_index_opt_geo_get_default (void)
+{
+   return &gMongocIndexOptGeoDefault;
+}
 
 void
 mongoc_index_opt_init (mongoc_index_opt_t *opt)
@@ -49,3 +62,11 @@ mongoc_index_opt_init (mongoc_index_opt_t *opt)
 
    memcpy (opt, &gMongocIndexOptDefault, sizeof *opt);
 }
+
+void
+mongoc_index_opt_geo_init (mongoc_index_opt_geo_t *opt)
+{
+   BSON_ASSERT (opt);
+
+   memcpy (opt, &gMongocIndexOptGeoDefault, sizeof *opt);
+}

src/mongoc/mongoc-index.h

@@ -26,26 +26,38 @@
 
 BSON_BEGIN_DECLS
 
+typedef struct
+{
+   uint8_t twod_sphere_version;
+   uint8_t twod_bits_precision;
+   double  twod_location_min;
+   double  twod_location_max;
+   double  haystack_bucket_size;
+   uint8_t *padding[32];
+} mongoc_index_opt_geo_t;
 
 typedef struct
 {
-   bool          is_initialized;
-   bool          background;
-   bool          unique;
-   const char   *name;
-   bool          drop_dups;
-   bool          sparse;
-   int32_t       expire_after_seconds;
-   int32_t       v;
-   const bson_t *weights;
-   const char   *default_language;
-   const char   *language_override;
-   void         *padding[8];
+   bool                   is_initialized;
+   bool                   background;
+   bool                   unique;
+   const char             *name;
+   bool                   drop_dups;
+   bool                   sparse;
+   int32_t                expire_after_seconds;
+   int32_t                v;
+   const bson_t           *weights;
+   const char             *default_language;
+   const char             *language_override;
+   mongoc_index_opt_geo_t *geo_options;
+   void                   *padding[7];
 } mongoc_index_opt_t;
 
 
-const mongoc_index_opt_t *mongoc_index_opt_get_default (void) BSON_GNUC_CONST;
-void                      mongoc_index_opt_init        (mongoc_index_opt_t *opt);
+const mongoc_index_opt_t     *mongoc_index_opt_get_default     (void) BSON_GNUC_CONST;
+const mongoc_index_opt_geo_t *mongoc_index_opt_geo_get_default (void) BSON_GNUC_CONST;
+void                          mongoc_index_opt_init            (mongoc_index_opt_t *opt);
+void                          mongoc_index_opt_geo_init        (mongoc_index_opt_geo_t *opt);
 
 
 BSON_END_DECLS

tests/test-mongoc-collection.c

@@ -506,6 +506,118 @@ test_index (void)
    mongoc_client_destroy(client);
 }
 
+static void
+test_index_compound (void)
+{
+   mongoc_collection_t *collection;
+   mongoc_database_t *database;
+   mongoc_client_t *client;
+   mongoc_index_opt_t opt;
+   bson_error_t error;
+   bool r;
+   bson_t keys;
+
+   mongoc_index_opt_init(&opt);
+
+   client = mongoc_client_new(gTestUri);
+   ASSERT (client);
+
+   database = get_test_database (client);
+   ASSERT (database);
+
+   collection = get_test_collection (client, "test_index_compound");
+   ASSERT (collection);
+
+   bson_init(&keys);
+   bson_append_int32(&keys, "hello", -1, 1);
+   bson_append_int32(&keys, "world", -1, -1);
+   r = mongoc_collection_create_index(collection, &keys, &opt, &error);
+   ASSERT (r);
+
+   r = mongoc_collection_create_index(collection, &keys, &opt, &error);
+   ASSERT (r);
+
+   r = mongoc_collection_drop_index(collection, "hello_1_world_-1", &error);
+   ASSERT (r);
+
+   bson_destroy(&keys);
+
+   r = mongoc_collection_drop (collection, &error);
+   ASSERT (r);
+
+   mongoc_collection_destroy(collection);
+   mongoc_database_destroy(database);
+   mongoc_client_destroy(client);
+}
+
+static void
+test_index_geo (void)
+{
+   mongoc_collection_t *collection;
+   mongoc_database_t *database;
+   mongoc_client_t *client;
+   mongoc_index_opt_t opt;
+   mongoc_index_opt_geo_t geo_opt;
+   bson_error_t error;
+   bool r;
+   bson_t keys;
+
+   mongoc_index_opt_init(&opt);
+   mongoc_index_opt_geo_init(&geo_opt);
+
+   client = mongoc_client_new(gTestUri);
+   ASSERT (client);
+
+   database = get_test_database (client);
+   ASSERT (database);
+
+   collection = get_test_collection (client, "test_geo_index");
+   ASSERT (collection);
+
+   /* Create a basic 2d index */
+   bson_init(&keys);
+   BSON_APPEND_UTF8(&keys, "location", "2d");
+   r = mongoc_collection_create_index(collection, &keys, &opt, &error);
+   ASSERT (r);
+
+   r = mongoc_collection_drop_index(collection, "location_2d", &error);
+   ASSERT (r);
+
+   /* Create a 2d index with bells and whistles */
+   bson_init(&keys);
+   BSON_APPEND_UTF8(&keys, "location", "2d");
+
+   geo_opt.twod_location_min = -123;
+   geo_opt.twod_location_max = +123;
+   geo_opt.twod_bits_precision = 30;
+   opt.geo_options = &geo_opt;
+
+   r = mongoc_collection_create_index(collection, &keys, &opt, &error);
+   ASSERT (r);
+
+   r = mongoc_collection_drop_index(collection, "location_2d", &error);
+   ASSERT (r);
+
+   /* Create a Haystack index */
+   bson_init(&keys);
+   BSON_APPEND_UTF8(&keys, "location", "geoHaystack");
+   BSON_APPEND_INT32(&keys, "category", 1);
+
+   mongoc_index_opt_geo_init(&geo_opt);
+   geo_opt.haystack_bucket_size = 5;
+   opt.geo_options = &geo_opt;
+
+   r = mongoc_collection_create_index(collection, &keys, &opt, &error);
+   ASSERT (r);
+
+   r = mongoc_collection_drop_index(collection, "location_geoHaystack_category_1", &error);
+   ASSERT (r);
+
+   mongoc_collection_destroy(collection);
+   mongoc_database_destroy(database);
+   mongoc_client_destroy(client);
+}
+
 
 static void
 test_count (void)
@@ -1216,6 +1328,8 @@ test_collection_install (TestSuite *suite)
    TestSuite_Add (suite, "/Collection/insert", test_insert);
    TestSuite_Add (suite, "/Collection/save", test_save);
    TestSuite_Add (suite, "/Collection/index", test_index);
+   TestSuite_Add (suite, "/Collection/index_compound", test_index_compound);
+   TestSuite_Add (suite, "/Collection/index_geo", test_index_geo);
    TestSuite_Add (suite, "/Collection/regex", test_regex);
    TestSuite_Add (suite, "/Collection/update", test_update);
    TestSuite_Add (suite, "/Collection/remove", test_remove);