ransacklib 1.1.0.dev12__tar.gz → 1.1.0.dev14__tar.gz

{ransacklib-1.1.0.dev12/ransacklib.egg-info → ransacklib-1.1.0.dev14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ransacklib
-Version: 1.1.0.dev12
+Version: 1.1.0.dev14
 Summary: A modern, extensible language for manipulation with structured data
 Author-email: "Rajmund H. Hruška" <rajmund.hruska@cesnet.cz>
 License-Expression: MIT
@@ -26,6 +26,7 @@ Requires-Dist: mypy<2.0,>=1.18; extra == "dev"
 Requires-Dist: ruff<0.15,>=0.14; extra == "dev"
 Requires-Dist: build<1.4,>=1.3; extra == "dev"
 Requires-Dist: twine<7.0,>=6.2; extra == "dev"
+Requires-Dist: psycopg[binary]; extra == "dev"
 Dynamic: license-file
 
 Welcome to ransack

{ransacklib-1.1.0.dev12 → ransacklib-1.1.0.dev14}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ransacklib"
-version = "1.1.0.dev12"
+version = "1.1.0.dev14"
 description = "A modern, extensible language for manipulation with structured data"
 license = "MIT"
 readme = "README.rst"
@@ -33,6 +33,7 @@ dev = [
   "ruff>=0.14,<0.15",
   "build>=1.3,<1.4",
   "twine>=6.2,<7.0",
+  "psycopg[binary]",
 ]
 
 [project.urls]

{ransacklib-1.1.0.dev12 → ransacklib-1.1.0.dev14}/ransack/function.py

@@ -17,12 +17,15 @@ Example usage in query:
 """
 
 import datetime
+from collections.abc import MutableSequence
 
 from ipranges import IP4, IP6, IP4Net, IP4Range, IP6Net, IP6Range
 
 
 def length(x):
-    if isinstance(x, (list, str, IP4, IP4Net, IP4Range, IP6, IP6Net, IP6Range)):
+    if isinstance(
+        x, (MutableSequence, str, IP4, IP4Net, IP4Range, IP6, IP6Net, IP6Range)
+    ):
         return len(x)
     raise TypeError(f"Function length is not defined for value {x}")
 

{ransacklib-1.1.0.dev12 → ransacklib-1.1.0.dev14}/ransack/operator.py

@@ -607,20 +607,16 @@ def _operator_map_sql(op, l_sql, r_sql, t1, t2) -> tuple[str, typing.Any, bool]:
             (Number, Number): (f"{l_sql} {op} {r_sql}", False),
             (Number, List(Number)): (f"{l_sql} {op} ANY({r_sql})", False),
             (Number, Range(Number)): (f"{l_sql} {op} {tuple_repr_f}({r_sql})", False),
-            (List(Number), Number): (f"ANY({l_sql}) {op} {r_sql}", False),
             (Datetime, Datetime): (f"{l_sql} {op} {r_sql}", False),
             (Datetime, List(Datetime)): (f"{l_sql} {op} ANY({r_sql})", False),
             (Datetime, Range(Datetime)): (
                 f"{r_sql} {op} {tuple_repr_f}({l_sql})",
                 True,
             ),
-            (List(Datetime), Datetime): (f"ANY({l_sql}) {op} {r_sql}", False),
             (Timedelta, Timedelta): (f"{l_sql} {op} {r_sql}", False),
             (Timedelta, List(Timedelta)): (f"{l_sql} {op} ANY({r_sql})", False),
-            (List(Timedelta), Timedelta): (f"ANY({l_sql}) {op} {r_sql}", False),
             (IP, IP): (f"{l_sql} {op} {r_sql}", False),
             (IP, List(IP)): (f"{l_sql} {op} ANY({r_sql})", False),
-            (List(IP), IP): (f"ANY({l_sql}) {op} {r_sql}", False),
         }
 
     # Comparison and logical operators (result is always boolean).
@@ -639,6 +635,7 @@ def _operator_map_sql(op, l_sql, r_sql, t1, t2) -> tuple[str, typing.Any, bool]:
             (String, List(String)): (f"{l_sql} = ANY({r_sql})", False),
             (IP, IP): (f"{l_sql} && {r_sql}", False),
             (IP, List(IP)): (f"{l_sql} && ANY({r_sql})", False),
+            (List(IP), IP): (f"{r_sql} && ANY({l_sql})", True),
             (List(Any), List(Any)): (f"{l_sql} && {r_sql}", False),
             (Range(Any), Range(Any)): (f"{l_sql} && {r_sql}", False),
         },
@@ -647,24 +644,40 @@ def _operator_map_sql(op, l_sql, r_sql, t1, t2) -> tuple[str, typing.Any, bool]:
             (Range(Any), Range(Any)): (f"upper({l_sql}) > lower({r_sql})", False),
             (Range(Number), Number): (f"upper({l_sql}) > {r_sql}", False),
             (Range(Datetime), Datetime): (f"upper({l_sql}) > {r_sql}", False),
+            (List(Number), Number): (f"{r_sql} < ANY({l_sql})", True),
+            (List(Datetime), Datetime): (f"{r_sql} < ANY({l_sql})", True),
+            (List(Timedelta), Timedelta): (f"{r_sql} < ANY({l_sql})", True),
+            (List(IP), IP): (f"{r_sql} < ANY({l_sql})", True),
         },
         ">=": _get_comp_dict_sql(">=", "lower")
         | {
             (Range(Any), Range(Any)): (f"upper({l_sql}) >= lower({r_sql})", False),
             (Range(Number), Number): (f"upper({l_sql}) >= {r_sql}", False),
             (Range(Datetime), Datetime): (f"upper({l_sql}) >= {r_sql}", False),
+            (List(Number), Number): (f"{r_sql} <= ANY({l_sql})", True),
+            (List(Datetime), Datetime): (f"{r_sql} <= ANY({l_sql})", True),
+            (List(Timedelta), Timedelta): (f"{r_sql} <= ANY({l_sql})", True),
+            (List(IP), IP): (f"{r_sql} <= ANY({l_sql})", True),
         },
         "<": _get_comp_dict_sql("<", "upper")
         | {
             (Range(Any), Range(Any)): (f"lower({l_sql}) < upper({r_sql})", False),
             (Range(Number), Number): (f"lower({l_sql}) < {r_sql}", False),
             (Range(Datetime), Datetime): (f"lower({l_sql}) < {r_sql}", False),
+            (List(Number), Number): (f"{r_sql} > ANY({l_sql})", True),
+            (List(Datetime), Datetime): (f"{r_sql} > ANY({l_sql})", True),
+            (List(Timedelta), Timedelta): (f"{r_sql} > ANY({l_sql})", True),
+            (List(IP), IP): (f"{r_sql} > ANY({l_sql})", True),
         },
         "<=": _get_comp_dict_sql("<=", "upper")
         | {
             (Range(Any), Range(Any)): (f"lower({l_sql}) <= upper({r_sql})", False),
             (Range(Number), Number): (f"lower({l_sql}) <= {r_sql}", False),
             (Range(Datetime), Datetime): (f"lower({l_sql}) <= {r_sql}", False),
+            (List(Number), Number): (f"{r_sql} >= ANY({l_sql})", True),
+            (List(Datetime), Datetime): (f"{r_sql} >= ANY({l_sql})", True),
+            (List(Timedelta), Timedelta): (f"{r_sql} >= ANY({l_sql})", True),
+            (List(IP), IP): (f"{r_sql} >= ANY({l_sql})", True),
         },
         "and": {(Bool, Bool): (f"{l_sql} AND {r_sql}", False)},
         "or": {(Bool, Bool): (f"({l_sql} OR {r_sql})", False)},
@@ -743,28 +756,28 @@ def _operator_map_sql(op, l_sql, r_sql, t1, t2) -> tuple[str, typing.Any, bool]:
             ),
         },
         "*": {
-            (Timedelta, Number): (f"{l_sql} * {r_sql}", Timedelta),
+            (Timedelta, Number): (f"({l_sql} * {r_sql})", Timedelta),
             (Timedelta, List(Number)): (
                 f"array(select {l_sql} * unnest({r_sql}))",
                 List(Timedelta),
             ),
-            (Number, Number): (f"{l_sql} * {r_sql}", Number),
+            (Number, Number): (f"({l_sql} * {r_sql})", Number),
             (Number, List(Number)): (
                 f"array(select {l_sql} * unnest({r_sql}))",
                 List(Number),
             ),
         },
         "/": {
-            (Timedelta, Timedelta): (f"{l_sql} / {r_sql}", Timedelta),
-            (Timedelta, List(Timedelta)): (
+            (Timedelta, Number): (f"({l_sql} / {r_sql})", Timedelta),
+            (Timedelta, List(Number)): (
                 f"array(select {l_sql} / unnest({r_sql}))",
                 List(Timedelta),
             ),
-            (List(Timedelta), Timedelta): (
+            (List(Timedelta), Number): (
                 f"array(select unnest({l_sql}) / {r_sql})",
                 List(Timedelta),
             ),
-            (Number, Number): (f"{l_sql} / {r_sql}", Number),
+            (Number, Number): (f"({l_sql} / {r_sql})", Number),
             (Number, List(Number)): (
                 f"array(select {l_sql} / unnest({r_sql}))",
                 List(Number),

{ransacklib-1.1.0.dev12 → ransacklib-1.1.0.dev14}/ransack/transformer.py

@@ -853,8 +853,9 @@ class SQLInterpreter(Interpreter):
         return result, params, type_
 
     def number(self, token: TokenWrapper) -> tuple[str, list, types.RansackType]:
-        type_ = types.Integer if isinstance(token.real_value, int) else types.Float
-        return ("%s", [token.real_value], type_)
+        if isinstance(token.real_value, int):
+            return ("%s::int", [token.real_value], types.Integer)
+        return ("%s", [token.real_value], types.Float)
 
     def datetime(self, token: TokenWrapper) -> tuple[str, list, types.RansackType]:
         if token.real_value.tzinfo is not None:
@@ -893,6 +894,8 @@ class SQLInterpreter(Interpreter):
         elif l_type is types.Float and r_type is types.Float:
             range_type = "numrange"
             l_type = types.Number
+            l_sql = l_sql + "::numeric"
+            r_sql = r_sql + "::numeric"
         elif l_type is types.Datetime and r_type is types.Datetime:
             if "WITH TIME ZONE" in l_sql and "WITH TIME ZONE" in r_sql:
                 range_type = "tstzrange"
@@ -950,20 +953,30 @@ class SQLInterpreter(Interpreter):
 
         return sql, params, type_
 
+    def _arithmetic_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)
+
+        if l_type == types.List(types.Empty):
+            return l_sql, l_params, l_type
+        if r_type == types.List(types.Empty):
+            return r_sql, r_params, r_type
+        return self._binary_operation(operator, l_tree, r_tree)
+
     def add(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list, Any]:
-        return self._binary_operation("+", l_tree, r_tree)
+        return self._arithmetic_operation("+", l_tree, r_tree)
 
     def sub(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list, Any]:
-        return self._binary_operation("-", l_tree, r_tree)
+        return self._arithmetic_operation("-", l_tree, r_tree)
 
     def mul(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list, Any]:
-        return self._binary_operation("*", l_tree, r_tree)
+        return self._arithmetic_operation("*", l_tree, r_tree)
 
     def div(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list, Any]:
-        return self._binary_operation("/", l_tree, r_tree)
+        return self._arithmetic_operation("/", l_tree, r_tree)
 
     def mod(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list, Any]:
-        return self._binary_operation("%", l_tree, r_tree)
+        return self._arithmetic_operation("%", l_tree, r_tree)
 
     def eq(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list, type[bool]]:
         return self._binary_operation("==", l_tree, r_tree)

{ransacklib-1.1.0.dev12 → ransacklib-1.1.0.dev14/ransacklib.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ransacklib
-Version: 1.1.0.dev12
+Version: 1.1.0.dev14
 Summary: A modern, extensible language for manipulation with structured data
 Author-email: "Rajmund H. Hruška" <rajmund.hruska@cesnet.cz>
 License-Expression: MIT
@@ -26,6 +26,7 @@ Requires-Dist: mypy<2.0,>=1.18; extra == "dev"
 Requires-Dist: ruff<0.15,>=0.14; extra == "dev"
 Requires-Dist: build<1.4,>=1.3; extra == "dev"
 Requires-Dist: twine<7.0,>=6.2; extra == "dev"
+Requires-Dist: psycopg[binary]; extra == "dev"
 Dynamic: license-file
 
 Welcome to ransack

{ransacklib-1.1.0.dev12 → ransacklib-1.1.0.dev14}/ransacklib.egg-info/SOURCES.txt

@@ -16,4 +16,5 @@ ransacklib.egg-info/requires.txt
 ransacklib.egg-info/top_level.txt
 tests/test_operator.py
 tests/test_parser.py
+tests/test_postgres.py
 tests/test_transformer.py

{ransacklib-1.1.0.dev12 → ransacklib-1.1.0.dev14}/ransacklib.egg-info/requires.txt

@@ -10,3 +10,4 @@ mypy<2.0,>=1.18
 ruff<0.15,>=0.14
 build<1.4,>=1.3
 twine<7.0,>=6.2
+psycopg[binary]