flowquery 1.0.43 → 1.0.44

package/flowquery-py/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flowquery"
-version = "1.0.33"
+version = "1.0.34"
 description = "A declarative query language for data processing pipelines"
 readme = "README.md"
 requires-python = ">=3.10"

package/flowquery-py/src/parsing/functions/join.py

@@ -42,6 +42,8 @@ class Join(Function):
     def value(self) -> Any:
         array = self.get_children()[0].value()
         delimiter = self.get_children()[1].value()
+        if array is None:
+            return None
         if not isinstance(array, list) or not isinstance(delimiter, str):
             raise ValueError("Invalid arguments for join function")
         return delimiter.join(str(item) for item in array)

package/flowquery-py/src/parsing/functions/keys.py

@@ -28,7 +28,7 @@ class Keys(Function):
     def value(self) -> Any:
         obj = self.get_children()[0].value()
         if obj is None:
-            return []
+            return None
         if not isinstance(obj, dict):
             raise ValueError("keys() expects an object, not an array or primitive")
         return list(obj.keys())

package/flowquery-py/src/parsing/functions/range_.py

@@ -34,6 +34,8 @@ class Range(Function):
     def value(self) -> Any:
         start = self.get_children()[0].value()
         end = self.get_children()[1].value()
+        if start is None or end is None:
+            return None
         if not isinstance(start, (int, float)) or not isinstance(end, (int, float)):
             raise ValueError("Invalid arguments for range function")
         return list(range(int(start), int(end) + 1))

package/flowquery-py/src/parsing/functions/replace.py

@@ -32,6 +32,8 @@ class Replace(Function):
         text = self.get_children()[0].value()
         pattern = self.get_children()[1].value()
         replacement = self.get_children()[2].value()
+        if text is None:
+            return None
         if not isinstance(text, str) or not isinstance(pattern, str) or not isinstance(replacement, str):
             raise ValueError("Invalid arguments for replace function")
         return re.sub(re.escape(pattern), replacement, text)

package/flowquery-py/src/parsing/functions/round_.py

@@ -27,6 +27,8 @@ class Round(Function):
 
     def value(self) -> Any:
         val = self.get_children()[0].value()
+        if val is None:
+            return None
         if not isinstance(val, (int, float)):
             raise ValueError("Invalid argument for round function")
         return round(val)

package/flowquery-py/src/parsing/functions/size.py

@@ -27,6 +27,8 @@ class Size(Function):
 
     def value(self) -> Any:
         val = self.get_children()[0].value()
+        if val is None:
+            return None
         if not isinstance(val, (list, str)):
             raise ValueError("Invalid argument for size function")
         return len(val)

package/flowquery-py/src/parsing/functions/split.py

@@ -47,6 +47,8 @@ class Split(Function):
     def value(self) -> Any:
         text = self.get_children()[0].value()
         delimiter = self.get_children()[1].value()
+        if text is None:
+            return None
         if not isinstance(text, str) or not isinstance(delimiter, str):
             raise ValueError("Invalid arguments for split function")
         return text.split(delimiter)

package/flowquery-py/src/parsing/functions/string_distance.py

@@ -1,5 +1,7 @@
 """String distance function using Levenshtein distance."""
 
+from typing import Optional
+
 from .function import Function
 from .function_metadata import FunctionDef
 
@@ -80,9 +82,11 @@ class StringDistance(Function):
         super().__init__("string_distance")
         self._expected_parameter_count = 2
 
-    def value(self) -> float:
+    def value(self) -> Optional[float]:
         str1 = self.get_children()[0].value()
         str2 = self.get_children()[1].value()
+        if str1 is None or str2 is None:
+            return None
         if not isinstance(str1, str) or not isinstance(str2, str):
             raise ValueError("Invalid arguments for string_distance function: both arguments must be strings")
         return _levenshtein_distance(str1, str2)

package/flowquery-py/src/parsing/functions/stringify.py

@@ -42,6 +42,8 @@ class Stringify(Function):
     def value(self) -> Any:
         val = self.get_children()[0].value()
         indent = int(self.get_children()[1].value())
+        if val is None:
+            return None
         if not isinstance(val, (dict, list)):
             raise ValueError("Invalid argument for stringify function")
         return json.dumps(val, indent=indent, default=str)

package/flowquery-py/src/parsing/functions/substring.py

@@ -52,6 +52,8 @@ class Substring(Function):
         original = children[0].value()
         start = children[1].value()
 
+        if original is None:
+            return None
         if not isinstance(original, str):
             raise ValueError(
                 "Invalid argument for substring function: expected a string as the first argument"

package/flowquery-py/src/parsing/functions/to_json.py

@@ -28,6 +28,8 @@ class ToJson(Function):
 
     def value(self) -> Any:
         text = self.get_children()[0].value()
+        if text is None:
+            return None
         if not isinstance(text, str):
             raise ValueError("Invalid arguments for tojson function")
         return json.loads(text)

package/flowquery-py/src/parsing/functions/to_lower.py

@@ -30,6 +30,8 @@ class ToLower(Function):
 
     def value(self) -> Any:
         val = self.get_children()[0].value()
+        if val is None:
+            return None
         if not isinstance(val, str):
             raise ValueError("Invalid argument for toLower function: expected a string")
         return val.lower()

package/flowquery-py/src/parsing/functions/to_string.py

@@ -33,7 +33,7 @@ class ToString(Function):
     def value(self) -> Any:
         val = self.get_children()[0].value()
         if val is None:
-            return "null"
+            return None
         if isinstance(val, bool):
             return str(val).lower()
         if isinstance(val, (dict, list)):

package/flowquery-py/src/parsing/functions/trim.py

@@ -30,6 +30,8 @@ class Trim(Function):
 
     def value(self) -> Any:
         val = self.get_children()[0].value()
+        if val is None:
+            return None
         if not isinstance(val, str):
             raise ValueError("Invalid argument for trim function: expected a string")
         return val.strip()

package/flowquery-py/tests/compute/test_runner.py

@@ -849,6 +849,134 @@ class TestRunner:
         assert len(results) == 1
         assert results[0] == {"result": ""}
 
+    # --- Null propagation tests ---
+
+    @pytest.mark.asyncio
+    async def test_to_lower_with_null_returns_null(self):
+        """Test toLower with null returns null."""
+        runner = Runner("RETURN toLower(null) as result")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"result": None}
+
+    @pytest.mark.asyncio
+    async def test_trim_with_null_returns_null(self):
+        """Test trim with null returns null."""
+        runner = Runner("RETURN trim(null) as result")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"result": None}
+
+    @pytest.mark.asyncio
+    async def test_replace_with_null_returns_null(self):
+        """Test replace with null returns null."""
+        runner = Runner("RETURN replace(null, 'a', 'b') as result")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"result": None}
+
+    @pytest.mark.asyncio
+    async def test_substring_with_null_returns_null(self):
+        """Test substring with null returns null."""
+        runner = Runner("RETURN substring(null, 0, 3) as result")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"result": None}
+
+    @pytest.mark.asyncio
+    async def test_split_with_null_returns_null(self):
+        """Test split with null returns null."""
+        runner = Runner("RETURN split(null, ',') as result")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"result": None}
+
+    @pytest.mark.asyncio
+    async def test_size_with_null_returns_null(self):
+        """Test size with null returns null."""
+        runner = Runner("RETURN size(null) as result")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"result": None}
+
+    @pytest.mark.asyncio
+    async def test_round_with_null_returns_null(self):
+        """Test round with null returns null."""
+        runner = Runner("RETURN round(null) as result")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"result": None}
+
+    @pytest.mark.asyncio
+    async def test_join_with_null_returns_null(self):
+        """Test join with null returns null."""
+        runner = Runner("RETURN join(null, ',') as result")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"result": None}
+
+    @pytest.mark.asyncio
+    async def test_string_distance_with_null_returns_null(self):
+        """Test string_distance with null returns null."""
+        runner = Runner("RETURN string_distance(null, 'hello') as result")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"result": None}
+
+    @pytest.mark.asyncio
+    async def test_stringify_with_null_returns_null(self):
+        """Test stringify with null returns null."""
+        runner = Runner("RETURN stringify(null) as result")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"result": None}
+
+    @pytest.mark.asyncio
+    async def test_tojson_with_null_returns_null(self):
+        """Test tojson with null returns null."""
+        runner = Runner("RETURN tojson(null) as result")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"result": None}
+
+    @pytest.mark.asyncio
+    async def test_range_with_null_returns_null(self):
+        """Test range with null returns null."""
+        runner = Runner("RETURN range(null, 5) as result")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"result": None}
+
+    @pytest.mark.asyncio
+    async def test_to_string_with_null_returns_null(self):
+        """Test toString with null returns null."""
+        runner = Runner("RETURN toString(null) as result")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"result": None}
+
+    @pytest.mark.asyncio
+    async def test_keys_with_null_returns_null(self):
+        """Test keys with null returns null."""
+        runner = Runner("RETURN keys(null) as result")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"result": None}
+
     @pytest.mark.asyncio
     async def test_associative_array_with_key_which_is_keyword(self):
         """Test associative array with key which is keyword."""