ransacklib 1.1.0.dev4__tar.gz → 1.1.0.dev5__tar.gz

{ransacklib-1.1.0.dev4/ransacklib.egg-info → ransacklib-1.1.0.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ransacklib
-Version: 1.1.0.dev4
+Version: 1.1.0.dev5
 Summary: A modern, extensible language for manipulation with structured data
 Author-email: "Rajmund H. Hruška" <rajmund.hruska@cesnet.cz>
 License-Expression: MIT

{ransacklib-1.1.0.dev4 → ransacklib-1.1.0.dev5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ransacklib"
-version = "1.1.0.dev4"
+version = "1.1.0.dev5"
 description = "A modern, extensible language for manipulation with structured data"
 license = "MIT"
 readme = "README.rst"
@@ -83,4 +83,5 @@ select = [
 
 ignore = [
     "PLR0913",  # too-many-arguments
+    "DTZ001",  # call-datetime-without-tzinfo
 ]

{ransacklib-1.1.0.dev4 → ransacklib-1.1.0.dev5}/ransack/transformer.py

@@ -828,19 +828,23 @@ class SQLInterpreter(Interpreter):
         self.data = {}
         return result, params
 
-    def number(self, token: TokenWrapper) -> tuple[str, list[Any], type[int | float]]:
+    def number(self, token: TokenWrapper) -> tuple[str, list, type[int | float]]:
         return ("%s", [token.real_value], type(token.real_value))
 
-    def datetime(self, token: TokenWrapper) -> tuple[str, list[Any], type[datetime]]:
-        return ("%s", [token.real_value], type(token.real_value))
+    def datetime(self, token: TokenWrapper) -> tuple[str, list, type[datetime]]:
+        if token.real_value.tzinfo is not None:
+            cast = "TIMESTAMP WITH TIME ZONE"
+        else:
+            cast = "TIMESTAMP"
+        return (f"%s::{cast}", [token.real_value], type(token.real_value))
 
-    def timedelta_(self, token: TokenWrapper) -> tuple[str, list[Any], type[timedelta]]:
+    def timedelta_(self, token: TokenWrapper) -> tuple[str, list, type[timedelta]]:
         return ("%s", [token.real_value], type(token.real_value))
 
-    def string_(self, token: TokenWrapper) -> tuple[str, list[Any], type[str]]:
+    def string_(self, token: TokenWrapper) -> tuple[str, list, type[str]]:
         return ("%s", [token.real_value], type(token.real_value))
 
-    def ip(self, token: TokenWrapper) -> tuple[str, list[Any], type[IP]]:
+    def ip(self, token: TokenWrapper) -> tuple[str, list, type[IP]]:
         match token.real_value:
             case IP4() | IP6():
                 cast = "ipaddress"
@@ -858,8 +862,6 @@ class SQLInterpreter(Interpreter):
         l_sql, l_params, l_type = self.visit(l_tree)
         r_sql, r_params, r_type = self.visit(r_tree)
 
-        params = l_params + r_params
-
         if issubclass(l_type, int) and issubclass(r_type, int):
             range_type = "int4range"
         elif issubclass(l_type, float) and issubclass(r_type, float):
@@ -872,7 +874,7 @@ class SQLInterpreter(Interpreter):
         elif issubclass(l_type, (IP4, IP6)) and issubclass(r_type, (IP4, IP6)):
             return (
                 f"iprange({l_sql}, {r_sql})",
-                params,
+                l_params + r_params,
                 IP4Range if issubclass(l_type, IP4) else IP6Range,
             )
         else:
@@ -892,7 +894,7 @@ class SQLInterpreter(Interpreter):
                 f"THEN {range_type}({l_sql}, {r_sql}, '[]') "
                 f"ELSE {range_type}({r_sql}, {l_sql}, '[]') END"
             ),
-            params,
+            l_params + r_params + l_params + r_params + r_params + l_params,
             tuple,
         )
 
@@ -1004,7 +1006,7 @@ class SQLInterpreter(Interpreter):
         )
 
     @v_args(tree=True)
-    def list(self, data):
+    def list(self, data: Tree) -> tuple[str, list, Any]:
         parts = []
         params = []
 
@@ -1015,4 +1017,7 @@ class SQLInterpreter(Interpreter):
             parts.append(sql)
             params.extend(p)
 
+        if not parts:
+            return "'{}'", [], list
+
         return f"ARRAY[{', '.join(parts)}]", params, list

{ransacklib-1.1.0.dev4 → ransacklib-1.1.0.dev5/ransacklib.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ransacklib
-Version: 1.1.0.dev4
+Version: 1.1.0.dev5
 Summary: A modern, extensible language for manipulation with structured data
 Author-email: "Rajmund H. Hruška" <rajmund.hruska@cesnet.cz>
 License-Expression: MIT

{ransacklib-1.1.0.dev4 → ransacklib-1.1.0.dev5}/tests/test_transformer.py

@@ -1,7 +1,7 @@
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 
 import pytest
-from ipranges import IP4, IP6, IP4Net, IP4Range, IP6Net, IP6Range
+from ipranges import IP4, IP6, IP4Net, IP4Range, IP6Net, IP6Range, from_str
 from lark import Token
 
 from ransack.exceptions import RansackError, ShapeError
@@ -9,6 +9,7 @@ from ransack.parser import Parser
 from ransack.transformer import (
     ExpressionTransformer,
     Filter,
+    SQLInterpreter,
     TokenWrapper,
     get_values,
 )
@@ -29,6 +30,11 @@ def expr_transformer():
     return ExpressionTransformer()
 
 
+@pytest.fixture
+def sql():
+    return SQLInterpreter()
+
+
 sample_data = {
     "Category": ["Intrusion.UserCompromise"],
     "ConnCount": 1,
@@ -505,3 +511,177 @@ class TestFilter:
         exp_tree = expr_transformer.transform(parser.parse_only("my_var == 14"))
         res = filter_.transform(exp_tree)
         assert res
+
+
+class TestSQLInterpreter:
+    def parse(self, parser, sql, expression):
+        tree = parser.parse(expression)
+        data = {
+            "a_int": ("a", int),
+            "b_int": ("b", int),
+            "c_int": ("c", int),
+            "d_int": ("d", int),
+            "Description": ("description", str),
+        }
+        return sql.to_sql(tree, data)
+
+    @pytest.mark.parametrize(
+        ("expr", "expected_sql", "expected_params"),
+        [
+            # Numbers.
+            ("5", "%s", [5]),
+            ("-12", "-%s", [12]),
+            ("23.22", "%s", [23.22]),
+            ("-0.224", "-%s", [0.224]),
+            ("13e19", "%s", [1.3e20]),
+            # Datetime.
+            ("2025-01-01", "%s::TIMESTAMP", [datetime(2025, 1, 1, 0, 0)]),
+            (
+                "2025-01-01T22:14:24.142+02:00",
+                "%s::TIMESTAMP WITH TIME ZONE",
+                [
+                    datetime(
+                        2025,
+                        1,
+                        1,
+                        22,
+                        14,
+                        24,
+                        142000,
+                        tzinfo=timezone(timedelta(seconds=7200)),
+                    )
+                ],
+            ),
+            # Timedelta.
+            ("01:23:34", "%s", [timedelta(seconds=5014)]),
+            ("-10D23:59:59", "-%s", [timedelta(days=10, seconds=86399)]),
+            ("99:59:59", "%s", [timedelta(days=4, seconds=14399)]),
+            # Strings.
+            ("''", "%s", [""]),
+            ('"string"', "%s", ["string"]),
+            ('"\';DROP TABLE USERS"', "%s", ["';DROP TABLE USERS"]),
+            # IPs.
+            ("192.168.0.0", "%s::ipaddress", [from_str("192.168.0.0")]),
+            ("192.168.0.0/16", "%s::iprange", [from_str("192.168.0.0/16")]),
+            (
+                "192.168.0.10-192.168.0.50",
+                "%s::iprange",
+                [from_str("192.168.0.10-192.168.0.50")],
+            ),
+            ("fd00::1", "%s::ipaddress", [from_str("fd00::1")]),
+            ("fd00::/8", "%s::iprange", [from_str("fd00::/8")]),
+            ("fd00::1-fd00::10", "%s::iprange", [from_str("fd00::1-fd00::10")]),
+            # List.
+            ("[1, 2, 3]", "ARRAY[%s, %s, %s]", [1, 2, 3]),
+            ("[01:23:34]", "ARRAY[%s]", [timedelta(seconds=5014)]),
+            ("[]", "'{}'", []),
+            # Ranges.
+            (
+                "100..1",
+                (
+                    "CASE WHEN %s < %s "
+                    "THEN int4range(%s, %s, '[]') "
+                    "ELSE int4range(%s, %s, '[]') END"
+                ),
+                [100, 1, 100, 1, 1, 100],
+            ),
+            (
+                "100.12..1.14",
+                (
+                    "CASE WHEN %s < %s "
+                    "THEN numrange(%s, %s, '[]') "
+                    "ELSE numrange(%s, %s, '[]') END"
+                ),
+                [100.12, 1.14, 100.12, 1.14, 1.14, 100.12],
+            ),
+            (
+                "2024-01-01T00:00:00+00:00..2024-12-31T00:00:00Z",
+                (
+                    "CASE WHEN %s::TIMESTAMP WITH TIME ZONE "
+                    "< %s::TIMESTAMP WITH TIME ZONE THEN "
+                    "tstzrange(%s::TIMESTAMP WITH TIME ZONE, "
+                    "%s::TIMESTAMP WITH TIME ZONE, '[]') ELSE "
+                    "tstzrange(%s::TIMESTAMP WITH TIME ZONE, "
+                    "%s::TIMESTAMP WITH TIME ZONE, '[]') END"
+                ),
+                [
+                    datetime(2024, 1, 1, 0, 0, tzinfo=timezone.utc),
+                    datetime(2024, 12, 31, 0, 0, tzinfo=timezone.utc),
+                    datetime(2024, 1, 1, 0, 0, tzinfo=timezone.utc),
+                    datetime(2024, 12, 31, 0, 0, tzinfo=timezone.utc),
+                    datetime(2024, 12, 31, 0, 0, tzinfo=timezone.utc),
+                    datetime(2024, 1, 1, 0, 0, tzinfo=timezone.utc),
+                ],
+            ),
+            (
+                "2024-01-01T00:00:00..2024-12-31T00:00:00",
+                (
+                    "CASE WHEN %s::TIMESTAMP "
+                    "< %s::TIMESTAMP THEN "
+                    "tsrange(%s::TIMESTAMP, "
+                    "%s::TIMESTAMP, '[]') ELSE "
+                    "tsrange(%s::TIMESTAMP, "
+                    "%s::TIMESTAMP, '[]') END"
+                ),
+                [
+                    datetime(
+                        2024,
+                        1,
+                        1,
+                        0,
+                        0,
+                    ),
+                    datetime(2024, 12, 31, 0, 0),
+                    datetime(2024, 1, 1, 0, 0),
+                    datetime(2024, 12, 31, 0, 0),
+                    datetime(2024, 12, 31, 0, 0),
+                    datetime(2024, 1, 1, 0, 0),
+                ],
+            ),
+            (
+                "192.168.0.10..192.168.0.50",
+                "iprange(%s::ipaddress, %s::ipaddress)",
+                [from_str("192.168.0.10"), from_str("192.168.0.50")],
+            ),
+            (
+                "fd00::1..fd00::10",
+                "iprange(%s::ipaddress, %s::ipaddress)",
+                [from_str("fd00::1"), from_str("fd00::10")],
+            ),
+            # Test variable access.
+            ("a_int", '"a"', []),
+            (
+                "a_int .. b_int",
+                (
+                    'CASE WHEN "a" < "b" '
+                    'THEN int4range("a", "b", \'[]\') '
+                    'ELSE int4range("b", "a", \'[]\') END'
+                ),
+                [],
+            ),
+        ],
+    )
+    def test_parse_sql(self, parser, sql, expr, expected_sql, expected_params):
+        sql_str, params = self.parse(parser, sql, expr)
+
+        assert sql_str == expected_sql
+        assert params == expected_params
+
+    def to_sql_and_expect_error(self, parser, sql, expression):
+        tree = parser.parse(expression)
+        with pytest.raises(RansackError):
+            sql.to_sql(tree)
+
+    @pytest.mark.parametrize(
+        "expression",
+        [
+            "2000-12-24..192.168.0.50",  # Unsupported type of range.
+            "not_there",  # Unknown column.
+        ],
+    )
+    def test_invalid_cases(self, parser, sql, expression):
+        self.to_sql_and_expect_error(
+            parser,
+            sql,
+            expression,
+        )