Added support for subobject indexes.

Makes the 'indexes' MongoMeta option understand dot notation indexes
("foo.bar") for use with DictField, ListField and EmbeddedModelField.
Column name substitution has been adapted to recursive into subobjects.

Kudos goes to Ellie Frost for the idea and patch.

Closes #77.

Author: jonashaag

AUTHORS.rst

@@ -13,6 +13,7 @@ Past Primary Authors
 
 Contributions by
 ----------------
+* Ellie Frost (https://github.com/stillinbeta)
 * Dag Stockstad (https://github.com/dstockstad) -- found tons of bugs in our query generator
 * Shane R. Spencer (https://github.com/whardier) -- Website Review
 * Sabin Iacob (https://github.com/m0n5t3r)

django_mongodb_engine/creation.py

@@ -2,12 +2,13 @@
 from djangotoolbox.db.base import NonrelDatabaseCreation
 from .utils import make_index_list
 
+
 class DatabaseCreation(NonrelDatabaseCreation):
     data_types = dict(NonrelDatabaseCreation.data_types, **{
         'AutoField': 'objectid',
         'ForeignKey': 'objectid',
         'OneToOneField': 'objectid',
-        'RelatedAutoField' : 'objectid',
+        'RelatedAutoField': 'objectid',
         'DecimalField': 'float',
     })
 
@@ -34,6 +35,8 @@ def ensure_index(*args, **kwargs):
             self._handle_oldstyle_indexes(ensure_index, meta)
 
     def _handle_newstyle_indexes(self, ensure_index, meta, indexes):
+        from djangotoolbox.fields import AbstractIterableField, EmbeddedModelField
+
         # Django indexes
         for field in meta.local_fields:
             if not (field.unique or field.db_index):
@@ -44,21 +47,35 @@ def _handle_newstyle_indexes(self, ensure_index, meta, indexes):
 
         # Django unique_together indexes
         indexes = list(indexes)
+
         for fields in getattr(meta, 'unique_together', []):
             assert isinstance(fields, (list, tuple))
             indexes.append({'fields': make_index_list(fields), 'unique': True})
 
+        def get_column_name(field):
+            opts = meta
+            parts = field.split('.')
+            for i, part in enumerate(parts):
+                field = opts.get_field(part)
+                parts[i] = field.column
+                if isinstance(field, AbstractIterableField):
+                    field = field.item_field
+                if isinstance(field, EmbeddedModelField):
+                    opts = field.embedded_model._meta
+                else:
+                    break
+            return '.'.join(parts)
+
         for index in indexes:
             if isinstance(index, dict):
                 kwargs = index.copy()
                 fields = kwargs.pop('fields')
             else:
                 fields, kwargs = index, {}
-            fields = [(meta.get_field(name).column, direction)
+            fields = [(get_column_name(name), direction)
                       for name, direction in make_index_list(fields)]
             ensure_index(fields, **kwargs)
 
-
     def _handle_oldstyle_indexes(self, ensure_index, meta):
         from warnings import warn
         warn("'descending_indexes', 'sparse_indexes' and 'index_together' are"

tests/mongodb/models.py

@@ -1,5 +1,5 @@
 from django.db import models
-from djangotoolbox.fields import RawField, ListField, EmbeddedModelField
+from djangotoolbox.fields import RawField, ListField, EmbeddedModelField, DictField
 from django_mongodb_engine.fields import GridFSField, GridFSString
 from query.models import Post
 
@@ -40,26 +40,40 @@ class IndexTestModel2(models.Model):
     class MongoMeta:
         index_together = ['a', ('b', -1)]
 
+class CustomColumnEmbeddedModel(models.Model):
+    a = models.IntegerField(db_column='a2')
+
 class NewStyleIndexesTestModel(models.Model):
-    a = models.IntegerField()
-    b = models.IntegerField(db_column='b2')
-    c = models.IntegerField(db_index=True)
-    d = models.IntegerField()
-    e = models.IntegerField()
-    f = models.IntegerField(unique=True)
+    f1 = models.IntegerField()
+    f2 = models.IntegerField()
+    f3 = models.IntegerField()
+
+    db_index = models.IntegerField(db_index=True)
+    unique = models.IntegerField(unique=True)
+    custom_column = models.IntegerField(db_column='custom')
     geo = models.IntegerField()
-    geo2 = models.IntegerField(db_column='geo')
+    geo_custom_column = models.IntegerField(db_column='geo')
+
+    dict1 = DictField()
+    dict_custom_column = DictField(db_column='dict_custom')
+    embedded = EmbeddedModelField(CustomColumnEmbeddedModel)
+    embedded_list = ListField(EmbeddedModelField(CustomColumnEmbeddedModel))
 
     class Meta:
-        unique_together = [('a', 'b'), ('a', 'd')]
+        unique_together = [('f2', 'custom_column'), ('f2', 'f3')]
 
     class MongoMeta:
         indexes = [
-            [('e', -1)],
-            {'fields': 'a', 'sparse': True},
-            {'fields': [('b', -1), 'd']},
+            [('f1', -1)],
+            {'fields': 'f2', 'sparse': True},
+            {'fields': [('custom_column', -1), 'f3']},
             [('geo', '2d')],
-            {'fields': [('geo2', '2d'), 'a'], 'min': 42, 'max': 21}
+            {'fields': [('geo_custom_column', '2d'), 'f2'], 'min': 42, 'max': 21},
+            {'fields': [('dict1.foo', 1)]},
+            {'fields': [('dict_custom_column.foo', 1)]},
+            {'fields' :[('embedded.a', 1)]},
+            {'fields' :[('embedded_list.a', 1)]},
+
         ]
 
 class GridFSFieldTestModel(models.Model):

tests/mongodb/tests.py

@@ -337,15 +337,19 @@ def assertHaveIndex(self, key, **properties):
         self.assertEqual(info[index_name], dict(default_properties, **properties))
 
     def test_indexes(self):
-        self.assertHaveIndex([('c', 1)])
-        self.assertHaveIndex([('f', 1)], unique=True)
-        self.assertHaveIndex([('a', 1), ('b2', 1)], unique=True)
-        self.assertHaveIndex([('a', 1), ('d', 1)], unique=True)
-        self.assertHaveIndex([('e', -1)])
-        self.assertHaveIndex([('a', 1)], sparse=True)
-        self.assertHaveIndex([('b2', -1), ('d', 1)])
+        self.assertHaveIndex([('db_index', 1)])
+        self.assertHaveIndex([('unique', 1)], unique=True)
+        self.assertHaveIndex([('f2', 1), ('custom', 1)], unique=True)
+        self.assertHaveIndex([('f2', 1), ('f3', 1)], unique=True)
+        self.assertHaveIndex([('f1', -1)])
+        self.assertHaveIndex([('f2', 1)], sparse=True)
+        self.assertHaveIndex([('custom', -1), ('f3', 1)])
         self.assertHaveIndex([('geo', '2d')])
-        self.assertHaveIndex([('geo', '2d'), ('a', 1)], min=42, max=21)
+        self.assertHaveIndex([('geo', '2d'), ('f2', 1)], min=42, max=21)
+        self.assertHaveIndex([('dict1.foo', 1)])
+        self.assertHaveIndex([('dict_custom.foo', 1)])
+        self.assertHaveIndex([('embedded.a2', 1)])
+        self.assertHaveIndex([('embedded_list.a2', 1)])
 
 class GridFSFieldTests(TestCase):
     def tearDown(self):