added getfield tests to expression conversion

Author: Jibola

tests/expression_converter_/test_match_conversion.py

@@ -214,3 +214,69 @@ 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 = {"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 = {"item.price.value": {"$gt": 100}}
+        self.assertOptimizerEqual(expr, expected)
+
+    def test_getfield_with_non_constant_field(self):
+        expr = {"$expr": {"$gt": [{"$getField": {"input": "$price", "field": "$field_name"}}, 100]}}
+        self.assertOptimizerEqual(expr, expr)
+
+    def test_getfield_with_object_non_simple_input(self):
+        expr = {
+            "$expr": {
+                "$gt": [
+                    {
+                        "$getField": {
+                            "input": {"$literal": "$item"},
+                            "field": "price",
+                        }
+                    },
+                    100,
+                ]
+            }
+        }
+        self.assertOptimizerEqual(expr, expr)

tests/expression_converter_/test_op_expressions.py

@@ -74,6 +74,45 @@ def test_eq_conversion_various_types(self):
     def test_eq_conversion_various_array_types(self):
         self._test_conversion_various_types(self._test_eq_conversion_valid_array_type)
 
+    def test_eq_conversion_getfield(self):
+        expr = {"$eq": [{"$getField": {"input": "$item", "field": "age"}}, 10]}
+        expected = {"item.age": 10}}
+        self.assertConversionEqual(expr, expected)
+
+    def test_eq_conversion_nested_getfield(self):
+        expr = {
+            "$eq": [
+                {
+                    "$getField": {
+                        "input": {"$getField": {"input": "$item", "field": "shelf_life"}},
+                        "field": "age",
+                    }
+                },
+                10,
+            ]
+        }
+        expected = {"item.shelf_life.age": 10}}
+        self.assertConversionEqual(expr, expected)
+    
+    def test_eq_conversion_dual_getfield_ineligible(self):
+        expr = {
+            "$eq": [
+                {
+                    "$getField": {
+                        "input": {"$getField": {"input": "$item", "field": "shelf_life"}},
+                        "field": "age",
+                    }
+                },
+                {
+                    "$getField": {
+                        "input": {"$getField": {"input": "$item", "field": "shelf_life"}},
+                        "field": "age",
+                    }
+                },
+            ]
+        }
+        self.assertNotOptimizable(expr)
+
 
 class TestInExprConversion(ExpressionConversionTestCase):
     def test_in_conversion(self):
@@ -112,6 +151,46 @@ def test_in_conversion_various_types(self):
             with self.subTest(_type=_type, val=val):
                 self._test_in_conversion_valid_type(val)
 
+    def test_in_conversion_getfield(self):
+        expr = {"$in": [{"$getField": {"input": "$item", "field": "age"}}, [10]]}
+        expected = {"item.age": {"$in": [10]}}
+        self.assertConversionEqual(expr, expected)
+
+    def test_in_conversion_nested_getfield(self):
+        expr = {
+            "$in": [
+                {
+                    "$getField": {
+                        "input": {"$getField": {"input": "$item", "field": "shelf_life"}},
+                        "field": "age",
+                    }
+                },
+                10,
+            ]
+        }
+        expected = {"item.shelf_life.age": {"$in": [10]}}
+        self.assertConversionEqual(expr, expected)
+
+    def test_in_conversion_dual_getfield_ineligible(self):
+        expr = {
+            "$in": [
+                {
+                    "$getField": {
+                        "input": "$root",
+                        "field": "age",
+                    }
+                },
+                [{
+                    "$getField": {
+                        "input": "$value",
+                        "field": "age",
+                    }
+                }],
+            ]
+        }
+        self.assertNotOptimizable(expr)
+
+
 
 class TestLogicalExpressionConversion(ExpressionConversionTestCase):
     def test_logical_and_conversion(self):
@@ -173,6 +252,7 @@ def test_logical_mixed_conversion(self):
                 {"$in": ["$category", ["electronics", "books"]]},
                 {"$eq": ["$verified", True]},
                 {"$lte": ["$price", 2000]},
+                {"$eq": [{"$getField": {"input": "$root", "field": "age"}}, 10]}
             ]
         }
         expected = {
@@ -181,6 +261,7 @@ def test_logical_mixed_conversion(self):
                 {"category": {"$in": ["electronics", "books"]}},
                 {"verified": True},
                 {"price": {"$lte": 2000}},
+                {"root.age": 10}
             ]
         }
         self.assertConversionEqual(expr, expected)