POC: Manage sub array queries with a different transform path.

Author: WaVEV

django_mongodb_backend/fields/embedded_model_array.py

@@ -62,31 +62,53 @@ def as_mql(self, compiler, connection):
             if isinstance(value, models.Model):
                 value, emf_data = self.model_to_dict(value)
                 # Get conditions for any nested EmbeddedModelFields.
-                conditions = self.get_conditions({"$$item": (value, emf_data)})
+                conditions = self.get_conditions({lhs_mql[1]: (value, emf_data)})
                 return {
                     "$anyElementTrue": {
-                        "$map": {"input": lhs_mql, "as": "item", "in": {"$and": conditions}}
+                        "$ifNull": [
+                            {
+                                "$map": {
+                                    "input": lhs_mql[0],
+                                    "as": "item",
+                                    "in": {"$and": conditions},
+                                }
+                            },
+                            [],
+                        ]
                     }
                 }
-            lhs_mql = process_lhs(self.lhs, compiler, connection)
             return {
                 "$anyElementTrue": {
-                    "$map": {
-                        "input": lhs_mql,
-                        "as": "item",
-                        "in": {"$eq": [f"$$item.{self.lhs.key_name}", value]},
-                    }
+                    "$ifNull": [
+                        {
+                            "$map": {
+                                "input": lhs_mql[0],
+                                "as": "item",
+                                "in": {"$eq": [lhs_mql[1], value]},
+                            }
+                        },
+                        [],
+                    ]
                 }
             }
         return connection.mongo_operators[self.lookup_name](lhs_mql, value)
 
 
 class KeyTransform(Transform):
     # it should be different class than EMF keytransform even most of the methods are equal.
-    def __init__(self, key_name, ref_field, *args, **kwargs):
+    def __init__(self, key_name, base_field, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        self.key_name = str(key_name)
-        self.ref_field = ref_field
+        self.base_field = base_field
+        #  TODO: Need to create a column, will refactor this thing.
+        column_target = base_field.clone()
+        column_target.db_column = f"$item.{key_name}"
+        column_target.set_attributes_from_name(f"$item.{key_name}")
+        self._lhs = Col(None, column_target)
+        self._sub_transform = None
+
+    def __call__(self, this, *args, **kwargs):
+        self._lhs = self._sub_transform(self._lhs, *args, **kwargs)
+        return self
 
     def get_lookup(self, name):
         return self.output_field.get_lookup(name)
@@ -96,33 +118,42 @@ def get_transform(self, name):
         Validate that `name` is either a field of an embedded model or a
         lookup on an embedded model's field.
         """
-        if transform := self.ref_field.get_transform(name):
-            return transform
-        suggested_lookups = difflib.get_close_matches(name, self.ref_field.get_lookups())
+        if isinstance(self._lhs, Transform):
+            transform = self._lhs.get_transform(name)
+        else:
+            transform = self.base_field.get_transform(name)
+        if transform:
+            self._sub_transform = transform
+            return self
+        suggested_lookups = difflib.get_close_matches(name, self.base_field.get_lookups())
         if suggested_lookups:
             suggested_lookups = " or ".join(suggested_lookups)
             suggestion = f", perhaps you meant {suggested_lookups}?"
         else:
             suggestion = "."
         raise FieldDoesNotExist(
             f"Unsupported lookup '{name}' for "
-            f"{self.ref_field.__class__.__name__} '{self.ref_field.name}'"
+            f"{self.base_field.__class__.__name__} '{self.base_field.name}'"
             f"{suggestion}"
         )
 
     def as_mql(self, compiler, connection):
+        if isinstance(self._lhs, Transform):
+            inner_lhs_mql = self._lhs.as_mql(compiler, connection)
+        else:
+            inner_lhs_mql = None
         lhs_mql = process_lhs(self, compiler, connection)
-        return f"{lhs_mql}.{self.key_name}"
+        return lhs_mql, inner_lhs_mql
 
     @property
     def output_field(self):
-        return EmbeddedModelArrayField(self.ref_field)
+        return EmbeddedModelArrayField(self.base_field)
 
 
 class KeyTransformFactory:
-    def __init__(self, key_name, ref_field):
+    def __init__(self, key_name, base_field):
         self.key_name = key_name
-        self.ref_field = ref_field
+        self.base_field = base_field
 
     def __call__(self, *args, **kwargs):
-        return KeyTransform(self.key_name, self.ref_field, *args, **kwargs)
+        return KeyTransform(self.key_name, self.base_field, *args, **kwargs)