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)