INTPYTHON-750: Support converting $expr with $getField paths

django_mongodb_backend/query_conversion/expression_converters.py

@@ -5,6 +5,45 @@ class BaseConverter:
     def convert(cls, expr):
         raise NotImplementedError("Subclasses must implement this method.")
 
+    @classmethod
+    def is_simple_path_name(cls, field_name):
+        return (
+            isinstance(field_name, str)
+            and field_name != ""
+            and field_name.startswith("$")
+            # Case for catching variables
+            and not field_name.startswith("$$")
+        )
+
+    @classmethod
+    def is_simple_get_field(cls, get_field_object):
+        if not isinstance(get_field_object, dict):
+            return False
+
+        get_field_expr = get_field_object.get("$getField")
+
+        if (
+            isinstance(get_field_expr, dict)
+            and "input" in get_field_expr
+            and "field" in get_field_expr
+        ):
+            input_expr = get_field_expr["input"]
+            field_name = get_field_expr["field"]
+            return cls.convert_path_name(input_expr) and (
+                isinstance(field_name, str) and "$" not in field_name and "." not in field_name
+            )
+        return False
+
+    @classmethod
+    def convert_path_name(cls, field_name):
+        if cls.is_simple_path_name(field_name):
+            return field_name[1:]
+        if cls.is_simple_get_field(field_name):
+            get_field_input = field_name["$getField"]["input"]
+            get_field_field_name = field_name["$getField"]["field"]
+            return f"{cls.convert_path_name(get_field_input)}.{get_field_field_name}"
+        return None
+
     @classmethod
     def is_simple_value(cls, value):
         """Is the value is a simple type (not a dict)?"""
@@ -14,7 +53,6 @@ def is_simple_value(cls, value):
             return False
         if isinstance(value, (list, tuple, set)):
             return all(cls.is_simple_value(v) for v in value)
-        # TODO: Support `$getField` conversion.
         return not isinstance(value, dict)
 
 
@@ -27,7 +65,7 @@ class BinaryConverter(BaseConverter):
             {"$gt": ["$price", 100]}
         }
     is converted to:
-        {"$gt": ["price", 100]}
+        {"price": {"$gt": 100}}
     """
 
     operator: str
@@ -37,15 +75,14 @@ def convert(cls, args):
         if isinstance(args, list) and len(args) == 2:
             field_expr, value = args
             # Check if first argument is a simple field reference.
-            if (
-                isinstance(field_expr, str)
-                and field_expr.startswith("$")
-                and cls.is_simple_value(value)
-            ):
-                field_name = field_expr[1:]  # Remove the $ prefix.
+            if (field_name := cls.convert_path_name(field_expr)) and cls.is_simple_value(value):
                 if cls.operator == "$eq":
-                    return {field_name: value}
-                return {field_name: {cls.operator: value}}
+                    query = {field_name: value}
+                else:
+                    query = {field_name: {cls.operator: value}}
+                if value is None:
+                    query = {"$and": [{field_name: {"$exists": True}}, query]}
+                return query
         return None
 
 
@@ -96,13 +133,18 @@ class InConverter(BaseConverter):
     def convert(cls, in_args):
         if isinstance(in_args, list) and len(in_args) == 2:
             field_expr, values = in_args
-            # Check if first argument is a simple field reference.
-            if isinstance(field_expr, str) and field_expr.startswith("$"):
-                field_name = field_expr[1:]  # Remove the $ prefix.
-                if isinstance(values, (list, tuple, set)) and all(
-                    cls.is_simple_value(v) for v in values
-                ):
-                    return {field_name: {"$in": values}}
+            # Check if first argument is a simple field reference
+            # Check if second argument is a list of simple values
+            if (field_name := cls.convert_path_name(field_expr)) and (
+                isinstance(values, list | tuple | set)
+                and all(cls.is_simple_value(v) for v in values)
+            ):
+                core_check = {field_name: {"$in": values}}
+                return (
+                    {"$and": [{field_name: {"$exists": True}}, core_check]}
+                    if None in values
+                    else core_check
+                )
         return None
 
 

tests/expression_converter_/test_match_conversion.py

@@ -213,3 +213,49 @@ def test_deeply_nested_logical_operator_with_variable(self):
             }
         ]
         self.assertOptimizerEqual(expr, expected)
+
+    def test_getfield_usage_on_dual_binary_operator(self):
+        expr = {
+            "$expr": {
+                "$gt": [
+                    {"$getField": {"input": "$price", "field": "value"}},
+                    {"$getField": {"input": "$discounted_price", "field": "value"}},
+                ]
+            }
+        }
+        expected = [
+            {
+                "$match": {
+                    "$expr": {
+                        "$gt": [
+                            {"$getField": {"input": "$price", "field": "value"}},
+                            {"$getField": {"input": "$discounted_price", "field": "value"}},
+                        ]
+                    }
+                }
+            }
+        ]
+        self.assertOptimizerEqual(expr, expected)
+
+    def test_getfield_usage_on_onesided_binary_operator(self):
+        expr = {"$expr": {"$gt": [{"$getField": {"input": "$price", "field": "value"}}, 100]}}
+        # This should create a proper match condition with no $expr
+        expected = [{"$match": {"price.value": {"$gt": 100}}}]
+        self.assertOptimizerEqual(expr, expected)
+
+    def test_nested_getfield_usage_on_onesided_binary(self):
+        expr = {
+            "$expr": {
+                "$gt": [
+                    {
+                        "$getField": {
+                            "input": {"$getField": {"input": "$item", "field": "price"}},
+                            "field": "value",
+                        }
+                    },
+                    100,
+                ]
+            }
+        }
+        expected = [{"$match": {"item.price.value": {"$gt": 100}}}]
+        self.assertOptimizerEqual(expr, expected)