schema checks and unit tests.

Author: WaVEV

django_mongodb/compiler.py

@@ -17,6 +17,8 @@
 from django.utils.functional import cached_property
 from pymongo import ASCENDING, DESCENDING
 
+from django_mongodb.fields import EmbeddedModelField
+
 from .base import Cursor
 from .query import MongoQuery, wrap_database_errors
 
@@ -547,7 +549,11 @@ def get_combinator_queries(self):
     def get_lookup_pipeline(self):
         result = []
         for alias in tuple(self.query.alias_map):
-            if not self.query.alias_refcount[alias] or self.collection_name == alias:
+            if (
+                not self.query.alias_refcount[alias]
+                or self.collection_name == alias
+                or isinstance(self.query.alias_map[alias].join_field, EmbeddedModelField)
+            ):
                 continue
             result += self.query.alias_map[alias].as_mql(self, self.connection)
         return result

django_mongodb/fields/embedded_model.py

@@ -1,3 +1,4 @@
+from django.core.exceptions import FieldDoesNotExist
 from django.db import models
 from django.db.models.fields.related import lazy_related_operation
 from django.db.models.lookups import Transform
@@ -115,7 +116,8 @@ def get_transform(self, name):
         transform = super().get_transform(name)
         if transform:
             return transform
-        return KeyTransformFactory(name)
+        field = self.embedded_model._meta.get_field(name)
+        return KeyTransformFactory(name, field)
 
     def validate(self, value, model_instance):
         super().validate(value, model_instance)
@@ -137,32 +139,67 @@ def formfield(self, **kwargs):
 
 
 class KeyTransform(Transform):
-    def __init__(self, key_name, *args, **kwargs):
+    def __init__(self, key_name, ref_field=None, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.key_name = str(key_name)
+        self.ref_field = ref_field
+
+    def get_transform(self, name):
+        result = None
+        if isinstance(self.ref_field, EmbeddedModelField):
+            opts = self.ref_field.embedded_model._meta
+            new_field = opts.get_field(name)
+            result = KeyTransformFactory(name, new_field)
+        else:
+            if self.ref_field is not None and self.ref_field.get_transform(name) is None:
+                raise FieldDoesNotExist(
+                    f"{self.ref_field.model._meta.object_name} has no field named '{name}'"
+                )
+            result = KeyTransformFactory(name, None)
+        return result
 
     def preprocess_lhs(self, compiler, connection):
-        key_transforms = [self.key_name]
-        previous = self.lhs
+        previous = self
+        embedded_key_transforms = []
+        json_key_transforms = []
         while isinstance(previous, KeyTransform):
-            key_transforms.insert(0, previous.key_name)
+            if previous.ref_field is not None:
+                embedded_key_transforms.insert(0, previous.key_name)
+            else:
+                json_key_transforms.insert(0, previous.key_name)
             previous = previous.lhs
         mql = previous.as_mql(compiler, connection)
-        return mql, key_transforms
+        return mql, embedded_key_transforms, json_key_transforms
 
 
 def key_transform(self, compiler, connection):
-    mql, key_transforms = self.preprocess_lhs(compiler, connection)
+    mql, key_transforms, json_key_transforms = self.preprocess_lhs(compiler, connection)
     transforms = ".".join(key_transforms)
-    return f"{mql}.{transforms}"
+    result = f"{mql}.{transforms}"
+    for key in json_key_transforms:
+        get_field = {"$getField": {"input": result, "field": key}}
+        # Handle array indexing if the key is a digit. If key is something
+        # like '001', it's not an array index despite isdigit() returning True.
+        if key.isdigit() and str(int(key)) == key:
+            result = {
+                "$cond": {
+                    "if": {"$isArray": result},
+                    "then": {"$arrayElemAt": [result, int(key)]},
+                    "else": get_field,
+                }
+            }
+        else:
+            result = get_field
+    return result
 
 
 class KeyTransformFactory:
-    def __init__(self, key_name):
+    def __init__(self, key_name, ref_field=None):
         self.key_name = key_name
+        self.ref_field = ref_field
 
     def __call__(self, *args, **kwargs):
-        return KeyTransform(self.key_name, *args, **kwargs)
+        return KeyTransform(self.key_name, self.ref_field, *args, **kwargs)
 
 
 def register_embedded_model_field():

tests/model_fields_/models.py

@@ -35,11 +35,12 @@ class DecimalParent(models.Model):
 
 class EmbeddedModelFieldModel(models.Model):
     simple = EmbeddedModelField("EmbeddedModel", null=True, blank=True)
-    decimal_parent = EmbeddedModelField(DecimalParent, null=True, blank=True)
+    decimal_parent = EmbeddedModelField(DecimalKey, null=True, blank=True)
 
 
 class EmbeddedModel(models.Model):
-    some_relation = models.ForeignKey(Target, models.CASCADE, null=True, blank=True)
+    json_value = models.JSONField()
+    decimal = EmbeddedModelField(DecimalModel, null=True, blank=True)
     someint = models.IntegerField(db_column="custom_column")
     auto_now = models.DateTimeField(auto_now=True)
     auto_now_add = models.DateTimeField(auto_now_add=True)

tests/model_fields_/test_embedded_model.py

@@ -1,6 +1,6 @@
 from decimal import Decimal
 
-from django.core.exceptions import ValidationError
+from django.core.exceptions import FieldDoesNotExist, ValidationError
 from django.test import SimpleTestCase, TestCase
 
 from django_mongodb.fields import EmbeddedModelField
@@ -10,10 +10,8 @@
     Author,
     Book,
     DecimalKey,
-    DecimalParent,
     EmbeddedModel,
     EmbeddedModelFieldModel,
-    Target,
 )
 
 
@@ -82,18 +80,10 @@ def test_pre_save(self):
         self.assertEqual(obj.simple.auto_now_add, auto_now_add)
         self.assertGreater(obj.simple.auto_now, auto_now_two)
 
-    def test_foreign_key_in_embedded_object(self):
-        simple = EmbeddedModel(some_relation=Target.objects.create(index=1))
-        obj = EmbeddedModelFieldModel.objects.create(simple=simple)
-        simple = EmbeddedModelFieldModel.objects.get().simple
-        self.assertNotIn("some_relation", simple.__dict__)
-        self.assertIsInstance(simple.__dict__["some_relation_id"], type(obj.id))
-        self.assertIsInstance(simple.some_relation, Target)
-
     def test_embedded_field_with_foreign_conversion(self):
         decimal = DecimalKey.objects.create(decimal=Decimal("1.5"))
-        decimal_parent = DecimalParent.objects.create(child=decimal)
-        EmbeddedModelFieldModel.objects.create(decimal_parent=decimal_parent)
+        # decimal_parent = DecimalParent.objects.create(child=decimal)
+        EmbeddedModelFieldModel.objects.create(decimal_parent=decimal)
 
 
 class QueryingTests(TestCase):
@@ -134,3 +124,50 @@ def test_nested(self):
             author=Author(name="Shakespeare", age=55, address=Address(city="NYC", state="NY"))
         )
         self.assertCountEqual(Book.objects.filter(author__address__city="NYC"), [obj])
+
+    def test_nested_not_exists(self):
+        msg = "Address has no field named 'president'"
+        with self.assertRaisesMessage(FieldDoesNotExist, msg):
+            Book.objects.filter(author__address__city__president="NYC")
+
+    def test_not_exists_in_embedded(self):
+        msg = "Address has no field named 'floor'"
+        with self.assertRaisesMessage(FieldDoesNotExist, msg):
+            Book.objects.filter(author__address__floor="NYC")
+
+    def test_embedded_with_json_field(self):
+        models = []
+        for i in range(4):
+            m = EmbeddedModelFieldModel.objects.create(
+                simple=EmbeddedModel(
+                    json_value={"field1": i * 5, "field2": {"0": {"value": list(range(i))}}}
+                )
+            )
+            models.append(m)
+
+        all_models = EmbeddedModelFieldModel.objects.all()
+
+        self.assertCountEqual(
+            EmbeddedModelFieldModel.objects.filter(simple__json_value__field2__0__value__0=0),
+            models[1:],
+        )
+        self.assertCountEqual(
+            EmbeddedModelFieldModel.objects.filter(simple__json_value__field2__0__value__1=1),
+            models[2:],
+        )
+        self.assertCountEqual(
+            EmbeddedModelFieldModel.objects.filter(simple__json_value__field2__0__value__1=5), []
+        )
+
+        self.assertCountEqual(
+            EmbeddedModelFieldModel.objects.filter(simple__json_value__field1__lt=100), all_models
+        )
+        self.assertCountEqual(
+            EmbeddedModelFieldModel.objects.filter(simple__json_value__field1__gt=100), []
+        )
+        self.assertCountEqual(
+            EmbeddedModelFieldModel.objects.filter(
+                simple__json_value__field1__gte=5, simple__json_value__field1__lte=10
+            ),
+            models[1:3],
+        )