ransacklib 1.1.0.dev7__tar.gz → 1.1.0.dev9__tar.gz

{ransacklib-1.1.0.dev7/ransacklib.egg-info → ransacklib-1.1.0.dev9}/PKG-INFO

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

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

{ransacklib-1.1.0.dev7 → ransacklib-1.1.0.dev9}/ransack/operator.py

@@ -578,10 +578,10 @@ def _operator_map_sql(op, l_sql, r_sql, t1, t2) -> tuple[str, Any, bool]:
         "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),
+            (str, str): (f"{l_sql} like '%' || {r_sql} || '%'", False),
             (list, str): (
-                f"position({r_sql} in array_to_string({l_sql}, ','))>0",
-                True,
+                f"array_to_string({l_sql}, ',') like '%' || {r_sql} || '%'",
+                False,
             ),
         },
     }
@@ -610,6 +610,10 @@ def _operator_map_sql(op, l_sql, r_sql, t1, t2) -> tuple[str, Any, bool]:
         "%": {
             (Number, Number): (f"({l_sql} % {r_sql})", Number),
         },
+        ".": {
+            (str, str): (f"{l_sql} || {r_sql}", str),
+            (list, list): (f"array_cat({l_sql}, {r_sql})", list),
+        },
     }
 
     if op == "==" and t1 == t2:
@@ -676,4 +680,4 @@ def binary_operation_sql(
             return sql, type_, not switch
         except KeyError:
             pass
-    raise OperatorNotFoundError(operator, (l_type, r_type), (left, right)) from None
+    raise OperatorNotFoundError(operator, (l_type, r_type)) from None

{ransacklib-1.1.0.dev7 → ransacklib-1.1.0.dev9}/ransack/transformer.py

@@ -830,7 +830,9 @@ 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) -> tuple[str, list[Any]]:
+    def to_sql(
+        self, tree: Tree, data: dict | None = None
+    ) -> tuple[str, list[Any], Any]:
         """
         Translates the given tree to PostgreSQL query using the provided data.
 
@@ -839,15 +841,15 @@ class SQLInterpreter(Interpreter):
             data: Optional dictionary containing the definition of queried columns.
 
         Returns:
-            A part of the SQL query (the part after 'SELECT' or 'WHERE') and its
-            parameters.
+            A part of the SQL query (the part after 'SELECT' or 'WHERE'), its
+            parameters and a resulting type.
         """
         self.data = data if data is not None else {}
 
-        result, params, _ = self.visit(tree)
+        result, params, type_ = self.visit(tree)
 
         self.data = {}
-        return result, params
+        return result, params, type_
 
     def number(self, token: TokenWrapper) -> tuple[str, list, type[int | float]]:
         return ("%s", [token.real_value], type(token.real_value))
@@ -993,6 +995,9 @@ class SQLInterpreter(Interpreter):
     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 concat_op(self, l_tree: Tree, r_tree: Tree) -> tuple[str, list, Any]:
+        return self._binary_operation(".", l_tree, r_tree)
+
     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

{ransacklib-1.1.0.dev7 → ransacklib-1.1.0.dev9/ransacklib.egg-info}/PKG-INFO

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

@@ -738,16 +738,16 @@ class TestSQLInterpreter:
             ("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"]),
+            ("'abcdf' contains 'bcd'", "%s like '%' || %s || '%'", ["abcdf", "bcd"]),
             (
                 "Category contains 'Attempt'",
-                "position(%s in array_to_string(\"category\", ','))>0",
+                "array_to_string(\"category\", ',') like '%' || %s || '%'",
                 ["Attempt"],
             ),
             (
                 "['abcdfg', 'qwerty', 'azerty'] contains 'bcd'",
-                "position(%s in array_to_string(ARRAY[%s, %s, %s], ','))>0",
-                ["bcd", "abcdfg", "qwerty", "azerty"],
+                "array_to_string(ARRAY[%s, %s, %s], ',') like '%' || %s || '%'",
+                ["abcdfg", "qwerty", "azerty", "bcd"],
             ),
             # Test = operator.
             ("1 = 1", "%s = %s", [1, 1]),
@@ -835,6 +835,10 @@ class TestSQLInterpreter:
                     from_str("192.168.0.0/16"),
                 ],
             ),
+            # Test concatenation.
+            ("[1, 2] . [3]", "array_cat(ARRAY[%s, %s], ARRAY[%s])", [1, 2, 3]),
+            ("Category . Category", 'array_cat("category", "category")', []),
+            ("'abc'.'def'", "%s || %s", ["abc", "def"]),
             # Test functions.
             (
                 "now() > 2025-12-12T12:34:56Z",
@@ -852,7 +856,7 @@ class TestSQLInterpreter:
         ],
     )
     def test_parse_sql(self, parser, sql, expr, expected_sql, expected_params):
-        sql_str, params = self.parse(parser, sql, expr)
+        sql_str, params, _ = self.parse(parser, sql, expr)
 
         assert sql_str == expected_sql
         assert params == expected_params