ransacklib 1.1.0.dev5__tar.gz → 1.1.0.dev6__tar.gz

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ransacklib"
-version = "1.1.0.dev5"
+version = "1.1.0.dev6"
 description = "A modern, extensible language for manipulation with structured data"
 license = "MIT"
 readme = "README.rst"

{ransacklib-1.1.0.dev5 → ransacklib-1.1.0.dev6}/ransack/operator.py

@@ -500,63 +500,65 @@ def binary_operation(operator: str, left: Any, right: Any) -> Any:
         raise OperatorNotFoundError(operator, (t1, t2), (left, right)) from None
 
 
-def _operator_map_sql(op, l_sql, r_sql, t1, t2) -> tuple[str, Any]:
-    def _get_comp_dict_sql(op: str, tuple_repr_f) -> dict[tuple[Operand, Operand], str]:
+def _operator_map_sql(op, l_sql, r_sql, t1, t2) -> tuple[str, Any, bool]:
+    def _get_comp_dict_sql(
+        op: str, tuple_repr_f
+    ) -> dict[tuple[Operand, Operand], tuple[str, bool]]:
         return {
-            (Number, Number): f"{l_sql} {op} {r_sql}",
-            (Number, list): f"{l_sql} {op} ANY({r_sql})",
-            (Number, tuple): f"{l_sql} {op} {tuple_repr_f}({r_sql})",
-            (datetime, datetime): f"{l_sql} {op} {r_sql}",
-            (datetime, list): f"{l_sql} {op} ANY({r_sql})",
-            (datetime, tuple): f"{r_sql} {op} {tuple_repr_f}({l_sql})",
-            (timedelta, timedelta): f"{l_sql} {op} {r_sql}",
-            (timedelta, list): f"{l_sql} {op} ANY({r_sql})",
-            ("ip", "ip"): f"{l_sql} {op} {r_sql}",
-            ("ip", list): f"{l_sql} {op} ANY({r_sql})",
+            (Number, Number): (f"{l_sql} {op} {r_sql}", False),
+            (Number, list): (f"{l_sql} {op} ANY({r_sql})", False),
+            (Number, tuple): (f"{l_sql} {op} {tuple_repr_f}({r_sql})", False),
+            (datetime, datetime): (f"{l_sql} {op} {r_sql}", False),
+            (datetime, list): (f"{l_sql} {op} ANY({r_sql})", False),
+            (datetime, tuple): (f"{r_sql} {op} {tuple_repr_f}({l_sql})", True),
+            (timedelta, timedelta): (f"{l_sql} {op} {r_sql}", False),
+            (timedelta, list): (f"{l_sql} {op} ANY({r_sql})", False),
+            ("ip", "ip"): (f"{l_sql} {op} {r_sql}", False),
+            ("ip", list): (f"{l_sql} {op} ANY({r_sql})", False),
             # (list, list): f"{l_sql} && {r_sql}",
             # (tuple, tuple): f"upper({l_sql}) > lower({r_sql})",
         }
 
     d: dict[str, dict] = {
         "=": {
-            (Number, Number): f"{l_sql} = {r_sql}",
-            (Number, list): f"{l_sql} = ANY({r_sql})",
-            (Number, tuple): f"{r_sql} @> {l_sql}",
-            (datetime, datetime): f"{l_sql} = {r_sql}",
-            (datetime, list): f"{l_sql} = ANY({r_sql})",
-            (datetime, tuple): f"{r_sql} @> {l_sql}",
-            (timedelta, timedelta): f"{l_sql} = {r_sql}",
-            (timedelta, list): f"{l_sql} = ANY({r_sql})",
-            (str, str): f"{l_sql} = {r_sql}",
-            (str, list): f"{l_sql} = ANY({r_sql})",
-            ("ip", "ip"): f"{l_sql} && {r_sql}",
-            ("ip", list): f"{l_sql} && ANY({r_sql})",
-            (list, list): f"{l_sql} && {r_sql}",
-            (tuple, tuple): f"{l_sql} && {r_sql}",
+            (Number, Number): (f"{l_sql} = {r_sql}", False),
+            (Number, list): (f"{l_sql} = ANY({r_sql})", False),
+            (Number, tuple): (f"{r_sql} @> {l_sql}", True),
+            (datetime, datetime): (f"{l_sql} = {r_sql}", False),
+            (datetime, list): (f"{l_sql} = ANY({r_sql})", False),
+            (datetime, tuple): (f"{r_sql} @> {l_sql}", True),
+            (timedelta, timedelta): (f"{l_sql} = {r_sql}", False),
+            (timedelta, list): (f"{l_sql} = ANY({r_sql})", False),
+            (str, str): (f"{l_sql} = {r_sql}", False),
+            (str, list): (f"{l_sql} = ANY({r_sql})", False),
+            ("ip", "ip"): (f"{l_sql} && {r_sql}", False),
+            ("ip", list): (f"{l_sql} && ANY({r_sql})", False),
+            (list, list): (f"{l_sql} && {r_sql}", False),
+            (tuple, tuple): (f"{l_sql} && {r_sql}", False),
         },
         ">": _get_comp_dict_sql(">", "lower")
-        | {(tuple, tuple): f"upper({l_sql}) > lower({r_sql})"},
+        | {(tuple, tuple): (f"upper({l_sql}) > lower({r_sql})", False)},
         ">=": _get_comp_dict_sql(">=", "lower")
-        | {(tuple, tuple): f"upper({l_sql}) >= lower({r_sql})"},
+        | {(tuple, tuple): (f"upper({l_sql}) >= lower({r_sql})", False)},
         "<": _get_comp_dict_sql("<", "upper")
-        | {(tuple, tuple): f"lower({l_sql}) < upper({r_sql})"},
+        | {(tuple, tuple): (f"lower({l_sql}) < upper({r_sql})", False)},
         "<=": _get_comp_dict_sql("<=", "upper")
-        | {(tuple, tuple): f"lower({l_sql}) <= upper({r_sql})"},
-        "and": {(bool, bool): f"{l_sql} AND {r_sql}"},
-        "or": {(bool, bool): f"{l_sql} OR {r_sql}"},
-        "contains": {(str, str): f"position({r_sql} in {l_sql})>0"},
+        | {(tuple, tuple): (f"lower({l_sql}) <= upper({r_sql})", False)},
+        "and": {(bool, bool): (f"{l_sql} AND {r_sql}", False)},
+        "or": {(bool, bool): (f"({l_sql} OR {r_sql})", False)},
+        "contains": {(str, str): (f"position({r_sql} in {l_sql})>0", True)},
     }
     d2: dict[str, dict] = {
         "+": {
-            (Number, Number): (f"{l_sql} + {r_sql}", Number),
-            (datetime, timedelta): (f"{l_sql} + {r_sql}", datetime),
-            (timedelta, timedelta): (f"{l_sql} + {r_sql}", timedelta),
+            (Number, Number): (f"({l_sql} + {r_sql})", Number),
+            (datetime, timedelta): (f"({l_sql} + {r_sql})", datetime),
+            (timedelta, timedelta): (f"({l_sql} + {r_sql})", timedelta),
         },
         "-": {
-            (Number, Number): (f"{l_sql} - {r_sql}", Number),
-            (datetime, timedelta): (f"{l_sql} - {r_sql}", datetime),
-            (timedelta, timedelta): (f"{l_sql} - {r_sql}", timedelta),
-            (datetime, datetime): (f"{l_sql} - {r_sql}", timedelta),
+            (Number, Number): (f"({l_sql} - {r_sql})", Number),
+            (datetime, timedelta): (f"({l_sql} - {r_sql})", datetime),
+            (timedelta, timedelta): (f"({l_sql} - {r_sql})", timedelta),
+            (datetime, datetime): (f"({l_sql} - {r_sql})", timedelta),
         },
         "*": {
             (timedelta, Number): (f"{l_sql} * {r_sql}", timedelta),
@@ -567,21 +569,24 @@ 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}", Number),
+            (Number, Number): (f"({l_sql} % {r_sql})", Number),
         },
     }
     if op == "==":
-        return (f"{l_sql} = {r_sql}", bool)
+        return (f"{l_sql} = {r_sql}", bool, False)
     if op == "in":
-        return (d["="][(t1, t2)], bool)
+        sql, switch = d["="][(t1, t2)]
+        return sql, bool, switch
     if op in d2:
-        return d2[op][(t1, t2)]
-    return (d[op][(t1, t2)], bool)
+        sql, type_ = d2[op][(t1, t2)]
+        return sql, type_, False
+    sql, switch = d[op][(t1, t2)]
+    return sql, bool, switch
 
 
 def binary_operation_sql(
     operator: str, left: str, right: str, l_type: Any, r_type: Any
-) -> tuple[str, Any]:
+) -> tuple[str, bool, Any]:
     # Normalize numeric types
     l_type = Number if l_type in (int, float) else l_type
     r_type = Number if r_type in (int, float) else r_type
@@ -595,7 +600,10 @@ def binary_operation_sql(
         return _operator_map_sql(operator, left, right, l_type, r_type)
     except KeyError:
         try:
-            return _operator_map_sql(operator, right, left, r_type, l_type)
+            sql, type_, switch = _operator_map_sql(
+                operator, right, left, r_type, l_type
+            )
+            return sql, type_, not switch
         except KeyError:
             pass
     raise OperatorNotFoundError(operator, (l_type, r_type), (left, right)) from None

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

@@ -852,13 +852,13 @@ class SQLInterpreter(Interpreter):
                 cast = "iprange"
         return (f"%s::{cast}", [token.real_value], type(token.real_value))
 
-    def neg(self, tree: Tree) -> tuple[str, list[Any], Any]:
+    def neg(self, tree: Tree) -> tuple[str, list, Any]:
         sql, params, type_ = self.visit(tree)
-        return (f"-{sql}", params, type_)
+        return (f"(-{sql})", params, type_)
 
     def range_op(
         self, l_tree: Tree, r_tree: Tree
-    ) -> tuple[str, list[Any], type[tuple] | type[IP]]:
+    ) -> tuple[str, list, type[tuple] | type[IP]]:
         l_sql, l_params, l_type = self.visit(l_tree)
         r_sql, r_params, r_type = self.visit(r_tree)
 
@@ -898,7 +898,7 @@ class SQLInterpreter(Interpreter):
             tuple,
         )
 
-    def var_from_data(self, var: TokenWrapper) -> tuple[str, list[Any], Any]:
+    def var_from_data(self, var: TokenWrapper) -> tuple[str, list, Any]:
         if var.real_value in self.data:
             column, type_ = self.data[var.real_value]
             return (f'"{column}"', [], type_)
@@ -912,68 +912,69 @@ class SQLInterpreter(Interpreter):
             end_pos=var.end_pos,
         )
 
-    def _binary_operation(self, operator, l_tree, r_tree) -> tuple[str, list[Any], Any]:
+    def _binary_operation(self, operator, l_tree, r_tree) -> tuple[str, list, 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)
+        sql, type_, switch = binary_operation_sql(
+            operator, l_sql, r_sql, l_type, r_type
+        )
+        params = l_params + r_params if not switch else r_params + l_params
 
-        return sql, l_params + r_params, type_
+        return sql, params, type_
 
-    def add(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list[Any], Any]:
+    def add(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list, Any]:
         return self._binary_operation("+", l_tree, r_tree)
 
-    def sub(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list[Any], Any]:
+    def sub(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list, Any]:
         return self._binary_operation("-", l_tree, r_tree)
 
-    def mul(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list[Any], Any]:
+    def mul(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list, Any]:
         return self._binary_operation("*", l_tree, r_tree)
 
-    def div(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list[Any], Any]:
+    def div(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list, Any]:
         return self._binary_operation("/", l_tree, r_tree)
 
-    def mod(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list[Any], Any]:
+    def mod(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list, Any]:
         return self._binary_operation("%", l_tree, r_tree)
 
-    def eq(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list[Any], type[bool]]:
+    def eq(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list, type[bool]]:
         return self._binary_operation("==", l_tree, r_tree)
 
-    def in_op(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list[Any], type[bool]]:
+    def in_op(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list, type[bool]]:
         return self._binary_operation("in", l_tree, r_tree)
 
-    def any_eq(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list[Any], type[bool]]:
+    def any_eq(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list, type[bool]]:
         return self._binary_operation("=", l_tree, r_tree)
 
-    def gt(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list[Any], type[bool]]:
+    def gt(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list, type[bool]]:
         return self._binary_operation(">", l_tree, r_tree)
 
-    def gte(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list[Any], type[bool]]:
+    def gte(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list, type[bool]]:
         return self._binary_operation(">=", l_tree, r_tree)
 
-    def lt(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list[Any], type[bool]]:
+    def lt(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list, type[bool]]:
         return self._binary_operation("<", l_tree, r_tree)
 
-    def lte(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list[Any], type[bool]]:
+    def lte(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list, type[bool]]:
         return self._binary_operation("<=", l_tree, r_tree)
 
-    def or_op(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list[Any], type[bool]]:
+    def or_op(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list, type[bool]]:
         return self._binary_operation("or", l_tree, r_tree)
 
-    def and_op(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list[Any], type[bool]]:
+    def and_op(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list, type[bool]]:
         return self._binary_operation("and", l_tree, r_tree)
 
-    def not_op(self, tree: Tree) -> tuple[str, list[Any], type[bool]]:
+    def not_op(self, tree: Tree) -> tuple[str, list, 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, list[Any], type[bool]]:
+    def contains_op(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list, type[bool]]:
         return self._binary_operation("contains", l_tree, r_tree)
 
-    def exists_op(self, path: Token) -> tuple[str, list[Any], type[bool]]:
+    def exists_op(self, path: Token) -> tuple[str, list, type[bool]]:
         var_sql, _, _ = self.var_from_data(TokenWrapper(path, path))
-        return f"{var_sql} is not null", [], bool
+        return f"{var_sql} IS NOT NULL", [], bool
 
     def exists_with_default(self, path: Token, default: Any) -> Any:
         var_sql, _, _ = self.var_from_data(TokenWrapper(path, path))

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ransacklib
-Version: 1.1.0.dev5
+Version: 1.1.0.dev6
 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.dev5 → ransacklib-1.1.0.dev6}/tests/test_transformer.py

@@ -530,9 +530,9 @@ class TestSQLInterpreter:
         [
             # Numbers.
             ("5", "%s", [5]),
-            ("-12", "-%s", [12]),
+            ("-12", "(-%s)", [12]),
             ("23.22", "%s", [23.22]),
-            ("-0.224", "-%s", [0.224]),
+            ("-0.224", "(-%s)", [0.224]),
             ("13e19", "%s", [1.3e20]),
             # Datetime.
             ("2025-01-01", "%s::TIMESTAMP", [datetime(2025, 1, 1, 0, 0)]),
@@ -554,7 +554,7 @@ class TestSQLInterpreter:
             ),
             # Timedelta.
             ("01:23:34", "%s", [timedelta(seconds=5014)]),
-            ("-10D23:59:59", "-%s", [timedelta(days=10, seconds=86399)]),
+            ("-10D23:59:59", "(-%s)", [timedelta(days=10, seconds=86399)]),
             ("99:59:59", "%s", [timedelta(days=4, seconds=14399)]),
             # Strings.
             ("''", "%s", [""]),
@@ -659,6 +659,109 @@ class TestSQLInterpreter:
                 ),
                 [],
             ),
+            # Test arithmetic operations.
+            (
+                "(10 + 12 - 7) * (15 / (8 % 3)) - (-5)",
+                "(((%s + %s) - %s) * %s / (%s % %s) - (-%s))",
+                [10, 12, 7, 15, 8, 3, 5],
+            ),
+            # Test comparisons.
+            (
+                "10 > 12 and 12 < 20 and (17 >= 12 or 12 <= 1) and not 53 == 13",
+                "%s > %s AND %s < %s AND (%s >= %s OR %s <= %s) AND NOT %s = %s",
+                [10, 12, 12, 20, 17, 12, 12, 1, 53, 13],
+            ),
+            # Test exists operators.
+            ("a_int??", '"a" IS NOT NULL', []),
+            ("a_int??14", 'COALESCE("a", %s)', [14]),
+            # Test contains operator.
+            ("'abcdfg' contains 'bcd'", "position(%s in %s)>0", ["bcd", "abcdfg"]),
+            # Test = operator.
+            ("1 = 1", "%s = %s", [1, 1]),
+            ("1 = [1, 2, 3]", "%s = ANY(ARRAY[%s, %s, %s])", [1, 1, 2, 3]),
+            ("[1, 2, 3] = 1", "%s = ANY(ARRAY[%s, %s, %s])", [1, 1, 2, 3]),
+            ("[1, 2] = [3, 4]", "ARRAY[%s, %s] && ARRAY[%s, %s]", [1, 2, 3, 4]),
+            (
+                "2 = 1..10",
+                (
+                    "CASE WHEN %s < %s "
+                    "THEN int4range(%s, %s, '[]') "
+                    "ELSE int4range(%s, %s, '[]') END @> %s"
+                ),
+                [1, 10, 1, 10, 10, 1, 2],
+            ),
+            (
+                "1..10 = 2",
+                (
+                    "CASE WHEN %s < %s "
+                    "THEN int4range(%s, %s, '[]') "
+                    "ELSE int4range(%s, %s, '[]') END @> %s"
+                ),
+                [1, 10, 1, 10, 10, 1, 2],
+            ),
+            (
+                "a_int..b_int = c_int..d_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",
+                "%s::ipaddress && %s::ipaddress",
+                [from_str("10.10.10.10"), from_str("10.10.10.10")],
+            ),
+            (
+                "10.10.10.10 = 10.10.10.0 .. 10.10.10.20",
+                "%s::ipaddress && iprange(%s::ipaddress, %s::ipaddress)",
+                [
+                    from_str("10.10.10.10"),
+                    from_str("10.10.10.0"),
+                    from_str("10.10.10.20"),
+                ],
+            ),
+            (
+                "192.168.0.5 = 192.168.0.0-192.168.0.255",
+                "%s::ipaddress && %s::iprange",
+                [from_str("192.168.0.5"), from_str("192.168.0.0-192.168.0.255")],
+            ),
+            (
+                "192.168.0.12 = 192.168.1.0/24",
+                "%s::ipaddress && %s::iprange",
+                [from_str("192.168.0.12"), from_str("192.168.1.0/24")],
+            ),
+            (
+                "10.10.10.10-10.10.10.20 = 10.10.10.15-10.10.10.25",
+                "%s::iprange && %s::iprange",
+                [
+                    from_str("10.10.10.10-10.10.10.20"),
+                    from_str("10.10.10.15-10.10.10.25"),
+                ],
+            ),
+            (
+                "10.10.10.10-10.10.10.20 = 192.168.0.0/16",
+                "%s::iprange && %s::iprange",
+                [from_str("10.10.10.10-10.10.10.20"), from_str("192.168.0.0/16")],
+            ),
+            (
+                "192.168.1.0/24 = 192.168.0.0/16",
+                "%s::iprange && %s::iprange",
+                [from_str("192.168.1.0/24"), from_str("192.168.0.0/16")],
+            ),
+            (
+                "192.168.1.10 = [192.168.0.0/24, 192.168.0.0/16]",
+                ("%s::ipaddress && ANY(ARRAY[%s::iprange, %s::iprange])"),
+                [
+                    from_str("192.168.1.10"),
+                    from_str("192.168.0.0/24"),
+                    from_str("192.168.0.0/16"),
+                ],
+            ),
         ],
     )
     def test_parse_sql(self, parser, sql, expr, expected_sql, expected_params):