Improvements and Testing

Author: Jibola

query_conversion/__init__.py renamed to django_mongodb_backend/query_conversion/__init__.py

@@ -14,21 +14,24 @@ def optimize(cls, expr):
     @classmethod
     def is_simple_value(cls, value):
         """
-        Check if the value is a simple type (not a list or dict).
+        Check if the value is a simple type (not a dict).
         """
-        return isinstance(value, (str, int, float, bool)) or value is None
+        if isinstance(value, str) and value.startswith("$"):
+            return False
+        if isinstance(value, list | tuple | set):
+            return all(cls.is_simple_value(v) for v in value)
+        # TODO: Expand functionality to support `$getField` conversion
+        return not isinstance(value, dict) or value is None
 
     @classmethod
     def is_convertable_field_name(cls, field_name):
         """Validate a field_name is one that can be represented in $match"""
         # This needs work and re-evaluation
-        if (
+        return (
             isinstance(field_name, str)
             and field_name.startswith("$")
             and not field_name[:1].isalnum()
-        ):
-            return True
-        return False
+        )
 
 
 class _EqExpressionConverter(_BaseExpressionConverter):
@@ -62,7 +65,7 @@ def optimize(cls, 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) and all(
+                if isinstance(values, list | tuple | set) and all(
                     cls.is_simple_value(v) for v in values
                 ):
                     return {field_name: {"$in": values}}

query_conversion/expression_converters.py renamed to django_mongodb_backend/query_conversion/expression_converters.py

@@ -0,0 +1,107 @@
+from copy import deepcopy
+
+from django_mongodb_backend.query_conversion.expression_converters import convert_expression
+
+
+class QueryOptimizer:
+    def convert_expr_to_match(self, expr):
+        """
+        Takes an MQL query with $expr and optimizes it by extracting
+        optimizable conditions into separate $match stages.
+
+        Args:
+            expr_query: Dictionary containing the $expr query
+
+        Returns:
+            List of optimized match conditions
+        """
+        expr_query = deepcopy(expr)
+
+        if "$expr" not in expr_query:
+            return [expr_query]
+
+        if expr_query["$expr"] == {}:
+            return [{"$match": {}}]
+
+        expr_content = expr_query["$expr"]
+        match_conditions = []
+        remaining_expr_conditions = []
+
+        # Handle the expression content
+        self._process_expression(expr_content, match_conditions, remaining_expr_conditions)
+
+        # If there are remaining conditions that couldn't be optimized,
+        # keep them in an $expr
+        if remaining_expr_conditions:
+            if len(remaining_expr_conditions) == 1:
+                expr_conditions = {"$expr": remaining_expr_conditions[0]}
+            else:
+                expr_conditions = {"$expr": {"$and": remaining_expr_conditions}}
+
+            if match_conditions:
+                # This assumes match_conditions is a list of dicts with $match
+                match_conditions[0]["$match"].update(expr_conditions)
+            else:
+                match_conditions.append({"$match": expr_conditions})
+
+        return match_conditions
+
+    def _process_expression(self, expr, match_conditions, remaining_conditions):
+        """
+        Process an expression and extract optimizable conditions.
+
+        Args:
+            expr: The expression to process
+            match_conditions: List to append optimized match conditions
+            remaining_conditions: List to append non-optimizable conditions
+        """
+        if isinstance(expr, dict):
+            # Check if this is an $and operation
+            has_and = "$and" in expr
+            has_or = "$or" in expr
+            # Do a top-level check for $and or $or because these should inform
+            # If they fail, they should failover to a remaining conditions list
+            # There's probably a better way to do this, but this is a start
+            if has_and:
+                self._process_logical_conditions(
+                    "$and", expr["$and"], match_conditions, remaining_conditions
+                )
+            if has_or:
+                self._process_logical_conditions(
+                    "$or", expr["$or"], match_conditions, remaining_conditions
+                )
+            if not has_and and not has_or:
+                # Process single condition
+                optimized = convert_expression(expr)
+                print(f"{expr=}")
+                if optimized:
+                    match_conditions.append({"$match": optimized})
+                else:
+                    remaining_conditions.append(expr)
+                print(f"{match_conditions=}")
+                print(f"{remaining_conditions=}")
+        else:
+            # Can't optimize
+            remaining_conditions.append(expr)
+
+    def _process_logical_conditions(
+        self, logical_op, logical_conditions, match_conditions, remaining_conditions
+    ):
+        """
+        Process conditions within a logical array.
+
+        Args:
+            logical_conditions: List of conditions within logical operator
+            match_conditions: List to append optimized match conditions
+            remaining_conditions: List to append non-optimizable conditions
+        """
+        optimized_conditions = []
+        for condition in logical_conditions:
+            if isinstance(condition, dict):
+                if optimized := convert_expression(condition):
+                    optimized_conditions.append(optimized)
+                else:
+                    remaining_conditions.append(condition)
+            else:
+                remaining_conditions.append(condition)
+        match_conditions.append({"$match": {logical_op: optimized_conditions}})