Merge pull request #30 from microsoft/new_functions

New functions

Author: niclasko

flowquery-py/src/parsing/functions/__init__.py

@@ -37,6 +37,8 @@
 # Built-in functions
 from .sum import Sum
 from .to_json import ToJson
+from .to_lower import ToLower
+from .to_string import ToString
 from .type_ import Type
 from .value_holder import ValueHolder
 
@@ -74,6 +76,8 @@
     "StringDistance",
     "Stringify",
     "ToJson",
+    "ToLower",
+    "ToString",
     "Type",
     "Functions",
     "Schema",

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

@@ -0,0 +1,35 @@
+"""ToLower function."""
+
+from typing import Any
+
+from .function import Function
+from .function_metadata import FunctionDef
+
+
+@FunctionDef({
+    "description": "Converts a string to lowercase",
+    "category": "scalar",
+    "parameters": [
+        {"name": "text", "description": "String to convert to lowercase", "type": "string"}
+    ],
+    "output": {"description": "Lowercase string", "type": "string", "example": "hello world"},
+    "examples": [
+        "WITH 'Hello World' AS s RETURN toLower(s)",
+        "WITH 'FOO' AS s RETURN toLower(s)"
+    ]
+})
+class ToLower(Function):
+    """ToLower function.
+
+    Converts a string to lowercase.
+    """
+
+    def __init__(self) -> None:
+        super().__init__("tolower")
+        self._expected_parameter_count = 1
+
+    def value(self) -> Any:
+        val = self.get_children()[0].value()
+        if not isinstance(val, str):
+            raise ValueError("Invalid argument for toLower function: expected a string")
+        return val.lower()

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

@@ -0,0 +1,41 @@
+"""ToString function."""
+
+import json
+from typing import Any
+
+from .function import Function
+from .function_metadata import FunctionDef
+
+
+@FunctionDef({
+    "description": "Converts a value to its string representation",
+    "category": "scalar",
+    "parameters": [
+        {"name": "value", "description": "Value to convert to a string", "type": "any"}
+    ],
+    "output": {"description": "String representation of the value", "type": "string", "example": "42"},
+    "examples": [
+        "WITH 42 AS n RETURN toString(n)",
+        "WITH true AS b RETURN toString(b)",
+        "WITH [1, 2, 3] AS arr RETURN toString(arr)"
+    ]
+})
+class ToString(Function):
+    """ToString function.
+
+    Converts a value to its string representation.
+    """
+
+    def __init__(self) -> None:
+        super().__init__("tostring")
+        self._expected_parameter_count = 1
+
+    def value(self) -> Any:
+        val = self.get_children()[0].value()
+        if val is None:
+            return "null"
+        if isinstance(val, bool):
+            return str(val).lower()
+        if isinstance(val, (dict, list)):
+            return json.dumps(val)
+        return str(val)

flowquery-py/tests/compute/test_runner.py

@@ -636,6 +636,51 @@ async def test_stringify_function(self):
         assert len(results) == 1
         assert results[0] == {"stringify": '{\n   "a": 1,\n   "b": 2\n}'}
 
+    @pytest.mark.asyncio
+    async def test_to_string_function_with_number(self):
+        """Test toString function with a number."""
+        runner = Runner("RETURN toString(42) as result")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"result": "42"}
+
+    @pytest.mark.asyncio
+    async def test_to_string_function_with_boolean(self):
+        """Test toString function with a boolean."""
+        runner = Runner("RETURN toString(true) as result")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"result": "true"}
+
+    @pytest.mark.asyncio
+    async def test_to_string_function_with_object(self):
+        """Test toString function with an object."""
+        runner = Runner("RETURN toString({a: 1}) as result")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"result": '{"a": 1}'}
+
+    @pytest.mark.asyncio
+    async def test_to_lower_function(self):
+        """Test toLower function."""
+        runner = Runner('RETURN toLower("Hello World") as result')
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"result": "hello world"}
+
+    @pytest.mark.asyncio
+    async def test_to_lower_function_with_all_uppercase(self):
+        """Test toLower function with all uppercase."""
+        runner = Runner('RETURN toLower("FOO BAR") as result')
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"result": "foo bar"}
+
     @pytest.mark.asyncio
     async def test_associative_array_with_key_which_is_keyword(self):
         """Test associative array with key which is keyword."""

src/parsing/functions/function_factory.ts

@@ -27,6 +27,8 @@ import "./stringify";
 // Import built-in functions to ensure their @FunctionDef decorators run
 import "./sum";
 import "./to_json";
+import "./to_lower";
+import "./to_string";
 import "./type";
 
 // Re-export AsyncDataProvider for backwards compatibility

src/parsing/functions/to_lower.ts

@@ -0,0 +1,25 @@
+import Function from "./function";
+import { FunctionDef } from "./function_metadata";
+
+@FunctionDef({
+    description: "Converts a string to lowercase",
+    category: "scalar",
+    parameters: [{ name: "text", description: "String to convert to lowercase", type: "string" }],
+    output: { description: "Lowercase string", type: "string", example: "hello world" },
+    examples: ["WITH 'Hello World' AS s RETURN toLower(s)", "WITH 'FOO' AS s RETURN toLower(s)"],
+})
+class ToLower extends Function {
+    constructor() {
+        super("tolower");
+        this._expectedParameterCount = 1;
+    }
+    public value(): any {
+        const val = this.getChildren()[0].value();
+        if (typeof val !== "string") {
+            throw new Error("Invalid argument for toLower function: expected a string");
+        }
+        return val.toLowerCase();
+    }
+}
+
+export default ToLower;

src/parsing/functions/to_string.ts

@@ -0,0 +1,32 @@
+import Function from "./function";
+import { FunctionDef } from "./function_metadata";
+
+@FunctionDef({
+    description: "Converts a value to its string representation",
+    category: "scalar",
+    parameters: [{ name: "value", description: "Value to convert to a string", type: "any" }],
+    output: { description: "String representation of the value", type: "string", example: "42" },
+    examples: [
+        "WITH 42 AS n RETURN toString(n)",
+        "WITH true AS b RETURN toString(b)",
+        "WITH [1, 2, 3] AS arr RETURN toString(arr)",
+    ],
+})
+class ToString extends Function {
+    constructor() {
+        super("tostring");
+        this._expectedParameterCount = 1;
+    }
+    public value(): any {
+        const val = this.getChildren()[0].value();
+        if (val === null || val === undefined) {
+            return String(val);
+        }
+        if (typeof val === "object") {
+            return JSON.stringify(val);
+        }
+        return String(val);
+    }
+}
+
+export default ToString;

tests/compute/runner.test.ts

@@ -573,6 +573,46 @@ test("Test stringify function", async () => {
     });
 });
 
+test("Test toString function with number", async () => {
+    const runner = new Runner("RETURN toString(42) as result");
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ result: "42" });
+});
+
+test("Test toString function with boolean", async () => {
+    const runner = new Runner("RETURN toString(true) as result");
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ result: "true" });
+});
+
+test("Test toString function with object", async () => {
+    const runner = new Runner("RETURN toString({a: 1}) as result");
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ result: '{"a":1}' });
+});
+
+test("Test toLower function", async () => {
+    const runner = new Runner('RETURN toLower("Hello World") as result');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ result: "hello world" });
+});
+
+test("Test toLower function with all uppercase", async () => {
+    const runner = new Runner('RETURN toLower("FOO BAR") as result');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ result: "foo bar" });
+});
+
 test("Test associative array with key which is keyword", async () => {
     const runner = new Runner("RETURN {return: 1} as aa");
     await runner.run();