ransacklib 1.1.0.dev3__tar.gz → 1.1.0.dev5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ransacklib
-Version: 1.1.0.dev3
+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.dev3 → ransacklib-1.1.0.dev5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ransacklib"
-version = "1.1.0.dev3"
+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.dev3 → ransacklib-1.1.0.dev5}/ransack/operator.py

@@ -567,7 +567,7 @@ def _operator_map_sql(op, l_sql, r_sql, t1, t2) -> tuple[str, Any]:
             (Number, Number): (f"{l_sql} / {r_sql}", Number),
         },
         "%": {
-            (Number, Number): (f"{l_sql} % {r_sql}", timedelta),
+            (Number, Number): (f"{l_sql} % {r_sql}", Number),
         },
     }
     if op == "==":

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

@@ -810,7 +810,7 @@ class SQLInterpreter(Interpreter):
     A class providing a method for translating the query from 'ransack' language to SQL.
     """
 
-    def to_sql(self, tree: Tree, data: dict | None = None) -> str:
+    def to_sql(self, tree: Tree, data: dict | None = None) -> tuple[str, list[Any]]:
         """
         Translates the given tree to PostgreSQL query using the provided data.
 
@@ -823,52 +823,44 @@ class SQLInterpreter(Interpreter):
         """
         self.data = data if data is not None else {}
 
-        result, _ = self.visit(tree)
+        result, params, _ = self.visit(tree)
 
         self.data = {}
-        return result
+        return result, params
 
-    def number(self, token: TokenWrapper) -> tuple[str, type[int | float]]:
-        return (str(token.real_value), type(token.real_value))
+    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, type[datetime]]:
+    def datetime(self, token: TokenWrapper) -> tuple[str, list, type[datetime]]:
         if token.real_value.tzinfo is not None:
-            type_ = "TIMESTAMP WITH TIME ZONE"
+            cast = "TIMESTAMP WITH TIME ZONE"
         else:
-            type_ = "TIMESTAMP"
-        return (
-            f"{type_} '{token.real_value.isoformat()}'",
-            type(token.real_value),
-        )
+            cast = "TIMESTAMP"
+        return (f"%s::{cast}", [token.real_value], type(token.real_value))
 
-    def timedelta_(self, token: TokenWrapper) -> tuple[str, type[timedelta]]:
-        return (f"INTERVAL '{token.real_value!s}'", type(token.real_value))
+    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, type[str]]:
-        return (f"'{token.real_value}'", 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, type[IP]]:
+    def ip(self, token: TokenWrapper) -> tuple[str, list, type[IP]]:
         match token.real_value:
             case IP4() | IP6():
                 cast = "ipaddress"
             case IP4Range() | IP6Range() | IP4Net() | IP6Net():
                 cast = "iprange"
-        return (f"{cast} '{token.real_value!s}'", type(token.real_value))
+        return (f"%s::{cast}", [token.real_value], type(token.real_value))
 
-    def neg(self, tree: Tree) -> tuple[str, Any]:
-        value, type_ = self.visit(tree)
-        return (f"-{value}", type_)
-
-    @v_args(tree=True)
-    def list(self, data: Tree) -> tuple[str, type[list]]:
-        elements = ", ".join(self.visit(x)[0] for x in data.children if x is not None)
-        return (f"ARRAY[{elements}]", list)
+    def neg(self, tree: Tree) -> tuple[str, list[Any], Any]:
+        sql, params, type_ = self.visit(tree)
+        return (f"-{sql}", params, type_)
 
     def range_op(
         self, l_tree: Tree, r_tree: Tree
-    ) -> tuple[str, type[tuple] | type[IP]]:
-        l_sql, l_type = self.visit(l_tree)
-        r_sql, r_type = self.visit(r_tree)
+    ) -> tuple[str, list[Any], type[tuple] | type[IP]]:
+        l_sql, l_params, l_type = self.visit(l_tree)
+        r_sql, r_params, r_type = self.visit(r_tree)
 
         if issubclass(l_type, int) and issubclass(r_type, int):
             range_type = "int4range"
@@ -882,6 +874,7 @@ class SQLInterpreter(Interpreter):
         elif issubclass(l_type, (IP4, IP6)) and issubclass(r_type, (IP4, IP6)):
             return (
                 f"iprange({l_sql}, {r_sql})",
+                l_params + r_params,
                 IP4Range if issubclass(l_type, IP4) else IP6Range,
             )
         else:
@@ -901,13 +894,14 @@ class SQLInterpreter(Interpreter):
                 f"THEN {range_type}({l_sql}, {r_sql}, '[]') "
                 f"ELSE {range_type}({r_sql}, {l_sql}, '[]') END"
             ),
+            l_params + r_params + l_params + r_params + r_params + l_params,
             tuple,
         )
 
-    def var_from_data(self, var: TokenWrapper) -> tuple[str, Any]:
+    def var_from_data(self, var: TokenWrapper) -> tuple[str, list[Any], Any]:
         if var.real_value in self.data:
             column, type_ = self.data[var.real_value]
-            return (f'"{column}"', type_)
+            return (f'"{column}"', [], type_)
         raise EvaluationError(
             f"The type of column '{var.real_value}' was not defined",
             line=var.line,
@@ -918,75 +912,89 @@ class SQLInterpreter(Interpreter):
             end_pos=var.end_pos,
         )
 
-    def _binary_operation(self, operator, l_tree, r_tree) -> tuple[str, Any]:
-        l_sql, l_type = self.visit(l_tree)
-        r_sql, r_type = self.visit(r_tree)
+    def _binary_operation(self, operator, l_tree, r_tree) -> tuple[str, list[Any], Any]:
+        l_sql, l_params, l_type = self.visit(l_tree)
+        r_sql, r_params, r_type = self.visit(r_tree)
+
+        sql, type_ = binary_operation_sql(operator, l_sql, r_sql, l_type, r_type)
 
-        return binary_operation_sql(operator, l_sql, r_sql, l_type, r_type)
+        return sql, l_params + r_params, type_
 
-    def add(self, l_tree: Tree, r_tree: Tree) -> tuple[str, Any]:
+    def add(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list[Any], Any]:
         return self._binary_operation("+", l_tree, r_tree)
 
-    def sub(self, l_tree: Tree, r_tree: Tree) -> tuple[str, Any]:
+    def sub(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list[Any], Any]:
         return self._binary_operation("-", l_tree, r_tree)
 
-    def mul(self, l_tree: Tree, r_tree: Tree) -> tuple[str, Any]:
+    def mul(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list[Any], Any]:
         return self._binary_operation("*", l_tree, r_tree)
 
-    def div(self, l_tree: Tree, r_tree: Tree) -> tuple[str, Any]:
+    def div(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list[Any], Any]:
         return self._binary_operation("/", l_tree, r_tree)
 
-    def mod(self, l_tree: Tree, r_tree: Tree) -> tuple[str, Any]:
-        return self._binary_operation("-", l_tree, r_tree)
+    def mod(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list[Any], Any]:
+        return self._binary_operation("%", l_tree, r_tree)
 
-    def eq(self, l_tree: Tree, r_tree: Tree) -> tuple[str, type[bool]]:
+    def eq(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list[Any], type[bool]]:
         return self._binary_operation("==", l_tree, r_tree)
 
-    def in_op(self, l_tree: Tree, r_tree: Tree) -> tuple[str, type[bool]]:
+    def in_op(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list[Any], type[bool]]:
         return self._binary_operation("in", l_tree, r_tree)
 
-    def any_eq(self, l_tree: Tree, r_tree: Tree) -> tuple[str, type[bool]]:
+    def any_eq(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list[Any], type[bool]]:
         return self._binary_operation("=", l_tree, r_tree)
 
-    def gt(self, l_tree: Tree, r_tree: Tree) -> tuple[str, type[bool]]:
+    def gt(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list[Any], type[bool]]:
         return self._binary_operation(">", l_tree, r_tree)
 
-    def gte(self, l_tree: Tree, r_tree: Tree) -> tuple[str, type[bool]]:
+    def gte(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list[Any], type[bool]]:
         return self._binary_operation(">=", l_tree, r_tree)
 
-    def lt(self, l_tree: Tree, r_tree: Tree) -> tuple[str, type[bool]]:
+    def lt(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list[Any], type[bool]]:
         return self._binary_operation("<", l_tree, r_tree)
 
-    def lte(self, l_tree: Tree, r_tree: Tree) -> tuple[str, type[bool]]:
+    def lte(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list[Any], type[bool]]:
         return self._binary_operation("<=", l_tree, r_tree)
 
-    def or_op(self, l_tree: Tree, r_tree: Tree) -> tuple[str, type[bool]]:
+    def or_op(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list[Any], type[bool]]:
         return self._binary_operation("or", l_tree, r_tree)
 
-    def and_op(self, l_tree: Tree, r_tree: Tree) -> tuple[str, type[bool]]:
+    def and_op(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list[Any], type[bool]]:
         return self._binary_operation("and", l_tree, r_tree)
 
-    def not_op(self, tree: Tree) -> tuple[str, type[bool]]:
-        sql, type_ = self.visit(tree)
-        return (f"NOT {sql}", type_)
+    def not_op(self, tree: Tree) -> tuple[str, list[Any], type[bool]]:
+        sql, params, type_ = self.visit(tree)
+        return f"NOT {sql}", params, type_
 
-    def contains_op(self, l_tree: Tree, r_tree: Tree) -> tuple[str, type[bool]]:
+    def contains_op(
+        self, l_tree: Tree, r_tree: Tree
+    ) -> tuple[str, list[Any], type[bool]]:
         return self._binary_operation("contains", l_tree, r_tree)
 
-    def exists_op(self, path: Token) -> tuple[str, type[bool]]:
-        var, _ = self.var_from_data(TokenWrapper(path, path))
-        return f"{var!s} is not null", bool
+    def exists_op(self, path: Token) -> tuple[str, list[Any], type[bool]]:
+        var_sql, _, _ = self.var_from_data(TokenWrapper(path, path))
+        return f"{var_sql} is not null", [], bool
 
     def exists_with_default(self, path: Token, default: Any) -> Any:
-        var, _ = self.var_from_data(TokenWrapper(path, path))
-        sql, type_ = self.visit(default)
-        return f"COALESCE({var!s}, {sql})", type_
+        var_sql, _, _ = self.var_from_data(TokenWrapper(path, path))
+        default_sql, default_params, default_type = self.visit(default)
+        return f"COALESCE({var_sql}, {default_sql})", default_params, default_type
+
+    def function_(
+        self, name: TokenWrapper, args: Tree | None
+    ) -> tuple[str, list[Any], Any]:
+        function_name = name.real_value
+
+        args_sql = []
+        params = []
+
+        for arg in args.children if args else []:
+            sql, p, _ = self.visit(arg)
+            args_sql.append(sql)
+            params.extend(p)
 
-    def function_(self, name: TokenWrapper, args: Tree | None) -> tuple[str, Any]:
-        function_name = cast("str", name.real_value)
-        args = [self.visit(x) for x in (args.children if args else [])]  # type: ignore
         if function_name == "now":
-            return "localtimestamp", datetime
+            return "localtimestamp", [], datetime
         raise EvaluationError(
             f"Function '{name.real_value}' was not found.",
             line=name.line,
@@ -996,3 +1004,20 @@ class SQLInterpreter(Interpreter):
             end_column=name.end_column,
             end_pos=name.end_pos,
         )
+
+    @v_args(tree=True)
+    def list(self, data: Tree) -> tuple[str, list, Any]:
+        parts = []
+        params = []
+
+        for child in data.children:
+            if child is None:
+                continue
+            sql, p, _ = self.visit(child)
+            parts.append(sql)
+            params.extend(p)
+
+        if not parts:
+            return "'{}'", [], list
+
+        return f"ARRAY[{', '.join(parts)}]", params, list

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ransacklib
-Version: 1.1.0.dev3
+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.dev3 → 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
@@ -30,6 +30,11 @@ def expr_transformer():
     return ExpressionTransformer()
 
 
+@pytest.fixture
+def sql():
+    return SQLInterpreter()
+
+
 sample_data = {
     "Category": ["Intrusion.UserCompromise"],
     "ConnCount": 1,
@@ -508,13 +513,8 @@ class TestFilter:
         assert res
 
 
-@pytest.fixture
-def sql():
-    return SQLInterpreter()
-
-
 class TestSQLInterpreter:
-    def parse_to_sql(self, parser, sql, expression):
+    def parse(self, parser, sql, expression):
         tree = parser.parse(expression)
         data = {
             "a_int": ("a", int),
@@ -526,176 +526,148 @@ class TestSQLInterpreter:
         return sql.to_sql(tree, data)
 
     @pytest.mark.parametrize(
-        ("expression", "expected"),
+        ("expr", "expected_sql", "expected_params"),
         [
-            # Test basic types
-            ("5", "5"),
-            ("-12", "-12"),
-            ("23.22", "23.22"),
-            ("-0.224", "-0.224"),
-            ("13e19", "1.3e+20"),
-            ("2025-01-01", "TIMESTAMP '2025-01-01T00:00:00'"),
+            # 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",
-                "TIMESTAMP WITH TIME ZONE '2025-01-01T22:14:24.142000+02:00'",
+                "%s::TIMESTAMP WITH TIME ZONE",
+                [
+                    datetime(
+                        2025,
+                        1,
+                        1,
+                        22,
+                        14,
+                        24,
+                        142000,
+                        tzinfo=timezone(timedelta(seconds=7200)),
+                    )
+                ],
             ),
-            ("01:23:34", "INTERVAL '1:23:34'"),
-            ("10D23:59:59", "INTERVAL '10 days, 23:59:59'"),
-            ("99:59:59", "INTERVAL '4 days, 3:59:59'"),
-            ("'string'", "'string'"),
-            ("192.168.0.0", "ipaddress '192.168.0.0'"),
-            ("192.168.0.0/16", "iprange '192.168.0.0/16'"),
-            ("192.168.0.10-192.168.0.50", "iprange '192.168.0.10-192.168.0.50'"),
-            ("fd00::1", "ipaddress 'fd00::1'"),
-            ("fd00::/8", "iprange 'fd00::/8'"),
-            ("fd00::1-fd00::10", "iprange 'fd00::1-fd00::10'"),
-            # Test collections
-            ("[1, 2, 3]", "ARRAY[1, 2, 3]"),
+            # 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")]),
             (
-                "[2024-12-12, 2025-12-12]",
-                (
-                    "ARRAY[TIMESTAMP '2024-12-12T00:00:00', "
-                    "TIMESTAMP '2025-12-12T00:00:00']"
-                ),
+                "192.168.0.10-192.168.0.50",
+                "%s::iprange",
+                [from_str("192.168.0.10-192.168.0.50")],
             ),
-            ("[]", "ARRAY[]"),
+            ("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 100 < 1 "
-                    "THEN int4range(100, 1, '[]') "
-                    "ELSE int4range(1, 100, '[]') END"
+                    "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 100.12 < 1.14 "
-                    "THEN numrange(100.12, 1.14, '[]') "
-                    "ELSE numrange(1.14, 100.12, '[]') END"
-                ),
-            ),
-            (
-                "-10..10",
-                (
-                    "CASE WHEN -10 < 10 "
-                    "THEN int4range(-10, 10, '[]') "
-                    "ELSE int4range(10, -10, '[]') END"
+                    "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 TIMESTAMP WITH TIME ZONE '2024-01-01T00:00:00+00:00' "
-                    "< TIMESTAMP WITH TIME ZONE '2024-12-31T00:00:00+00:00' THEN "
-                    "tstzrange(TIMESTAMP WITH TIME ZONE '2024-01-01T00:00:00+00:00', "
-                    "TIMESTAMP WITH TIME ZONE '2024-12-31T00:00:00+00:00', '[]') ELSE "
-                    "tstzrange(TIMESTAMP WITH TIME ZONE '2024-12-31T00:00:00+00:00', "
-                    "TIMESTAMP WITH TIME ZONE '2024-01-01T00:00:00+00:00', '[]') END"
+                    "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),
+                ],
             ),
             (
-                "192.168.0.10..192.168.0.50",
-                "iprange(ipaddress '192.168.0.10', ipaddress '192.168.0.50')",
-            ),
-            ("fd00::1..fd00::10", "iprange(ipaddress 'fd00::1', ipaddress 'fd00::10')"),
-            # Test variable access
-            ("a_int", '"a"'),
-            (
-                "a_int .. b_int",
+                "2024-01-01T00:00:00..2024-12-31T00:00:00",
                 (
-                    'CASE WHEN "a" < "b" '
-                    'THEN int4range("a", "b", \'[]\') '
-                    'ELSE int4range("b", "a", \'[]\') END'
+                    "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),
+                ],
             ),
-            # Test = operator
-            ("1 = 1", "1 = 1"),
-            ("1 = [1, 2, 3]", "1 = ANY(ARRAY[1, 2, 3])"),
-            ("[1, 2, 3] = 1", "1 = ANY(ARRAY[1, 2, 3])"),
-            ("[1, 2] = [3, 4]", "ARRAY[1, 2] && ARRAY[3, 4]"),
             (
-                "1 = 1..10",
-                (
-                    "CASE WHEN 1 < 10 "
-                    "THEN int4range(1, 10, '[]') "
-                    "ELSE int4range(10, 1, '[]') END @> 1"
-                ),
+                "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")],
             ),
             (
-                "1..10 = 1",
-                (
-                    "CASE WHEN 1 < 10 "
-                    "THEN int4range(1, 10, '[]') "
-                    "ELSE int4range(10, 1, '[]') END @> 1"
-                ),
+                "fd00::1..fd00::10",
+                "iprange(%s::ipaddress, %s::ipaddress)",
+                [from_str("fd00::1"), from_str("fd00::10")],
             ),
-            ("0D12:42:24 = 12:42:24", "INTERVAL '12:42:24' = INTERVAL '12:42:24'"),
+            # Test variable access.
+            ("a_int", '"a"', []),
             (
-                "a_int..b_int = c_int..d_int",
+                "a_int .. b_int",
                 (
                     'CASE WHEN "a" < "b" '
                     'THEN int4range("a", "b", \'[]\') '
-                    'ELSE int4range("b", "a", \'[]\') END '
-                    '&& CASE WHEN "c" < "d" '
-                    'THEN int4range("c", "d", \'[]\') '
-                    'ELSE int4range("d", "c", \'[]\') END'
-                ),
-            ),
-            (
-                "10.10.10.10 = 10.10.10.10",
-                "ipaddress '10.10.10.10' && ipaddress '10.10.10.10'",
-            ),
-            (
-                "10.10.10.10 = 10.10.10.0 .. 10.10.10.20",
-                (
-                    "ipaddress '10.10.10.10' && "
-                    "iprange(ipaddress '10.10.10.0', ipaddress '10.10.10.20')"
-                ),
-            ),
-            (
-                "192.168.0.5 = 192.168.0.0-192.168.0.255",
-                "ipaddress '192.168.0.5' && iprange '192.168.0.0-192.168.0.255'",
-            ),
-            (
-                "192.168.0.12 = 192.168.1.0/24",
-                "ipaddress '192.168.0.12' && iprange '192.168.1.0/24'",
-            ),
-            (
-                "10.10.10.10-10.10.10.20 = 10.10.10.15-10.10.10.25",
-                (
-                    "iprange '10.10.10.10-10.10.10.20' && "
-                    "iprange '10.10.10.15-10.10.10.25'"
-                ),
-            ),
-            (
-                "10.10.10.10-10.10.10.20 = 192.168.0.0/16",
-                "iprange '10.10.10.10-10.10.10.20' && iprange '192.168.0.0/16'",
-            ),
-            (
-                "192.168.1.0/24 = 192.168.0.0/16",
-                "iprange '192.168.1.0/24' && iprange '192.168.0.0/16'",
-            ),
-            (
-                "192.168.1.10 = [192.168.0.0/24, 192.168.0.0/16]",
-                (
-                    "ipaddress '192.168.1.10' && "
-                    "ANY(ARRAY[iprange '192.168.0.0/24', iprange '192.168.0.0/16'])"
+                    'ELSE int4range("b", "a", \'[]\') END'
                 ),
+                [],
             ),
-            # Test comparisons
-            ("2 >= 2 and 4 <= 12.89 or 4 == 4", "2 >= 2 AND 4 <= 12.89 OR 4 = 4"),
-            ("3 > 2 or 2 < 1 and 1 > 2", "3 > 2 OR 2 < 1 AND 1 > 2"),
-            ("2 < 3 and 3 > 1 or 1 < 0", "2 < 3 AND 3 > 1 OR 1 < 0"),
-            ("3 > 2 and not 2 < 1", "3 > 2 AND NOT 2 < 1"),
         ],
     )
-    def test_to_sql(self, parser, sql, expression, expected):
-        result = self.parse_to_sql(parser, sql, expression)
-        assert result == expected
+    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):
-        """Parse the expression and expect an exception to be raised."""
         tree = parser.parse(expression)
         with pytest.raises(RansackError):
             sql.to_sql(tree)
@@ -703,8 +675,8 @@ class TestSQLInterpreter:
     @pytest.mark.parametrize(
         "expression",
         [
-            "2000-12-24..192.168.0.50",  # Unsupported type of range
-            "not_there",  # Unknown column
+            "2000-12-24..192.168.0.50",  # Unsupported type of range.
+            "not_there",  # Unknown column.
         ],
     )
     def test_invalid_cases(self, parser, sql, expression):