ransacklib 1.1.0.dev5__tar.gz → 1.1.0.dev7__tar.gz

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

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

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

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

@@ -500,63 +500,104 @@ 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]:
+    """
+    Maps an expression into its SQL representation.
+
+    Args:
+        op: Operator string (e.g., "=", "+", "and", "contains").
+        l_sql: SQL string representing the left operand.
+        r_sql: SQL string representing the right operand.
+        t1: Resolved type of the left operand.
+        t2: Resolved type of the right operand.
+
+    Returns:
+        A tuple of:
+            - SQL expression string,
+            - result type,
+            - switch flag (True if operands were reversed semantically).
+
+    Raises:
+        KeyError:
+            If no mapping exists for the given operator and operand types.
+    """
+
+    def _get_comp_dict_sql(
+        op: str, tuple_repr_f
+    ) -> dict[tuple[Operand, Operand], tuple[str, bool]]:
+        """
+        Generate comparison operator mappings for multiple type combinations.
+
+        Args:
+            op: SQL comparison operator (e.g., ">", "<=").
+            tuple_repr_f: SQL function name used for tuple bounds (e.g. "lower").
+
+        Returns:
+            Mapping from (type1, type2) -> (SQL string, switch flag).
+        """
         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})",
-            # (list, list): f"{l_sql} && {r_sql}",
-            # (tuple, tuple): f"upper({l_sql}) > lower({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),
         }
 
+    # Comparison and logical operators (result is always boolean).
+    # The boolean flag indicates whether operand order was reversed.
     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),
+            (list, str): (
+                f"position({r_sql} in array_to_string({l_sql}, ','))>0",
+                True,
+            ),
+        },
     }
+
+    # Arithmetic operators (result type varies, operands are not swapped).
     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 +608,55 @@ 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)
+
+    if op == "==" and t1 == t2:
+        return (f"{l_sql} = {r_sql}", bool, False)
+
+    # 'in' operator behaves the same as '=' operator.
     if op == "in":
-        return (d["="][(t1, t2)], bool)
+        sql, switch = d["="][(t1, t2)]
+        return sql, bool, switch
+
+    # Arithmetic operator handling.
     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
+
+    # Default: comparison/logical operator.
+    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]:
+    """
+    Converts a binary operation into its SQL equivalent with type handling.
+
+    This function normalizes operand types (e.g., numeric types, IP types),
+    delegates SQL generation to `_operator_map_sql`, and handles operand
+    swapping if needed.
+
+    Args:
+        operator: Operator string (e.g., "+", "=", "in").
+        left: SQL string for the left operand.
+        right: SQL string for the right operand.
+        l_type: Type of the left operand.
+        r_type: Type of the right operand.
+
+    Returns:
+        A tuple of:
+            - SQL expression string,
+            - result type,
+            - switch flag (True if operands were reversed).
+
+    Raises:
+        OperatorNotFoundError:
+            If no valid SQL mapping exists for the operator/type combination.
+    """
     # 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 +670,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.dev7}/ransack/parser.py

@@ -12,6 +12,7 @@ Classes:
 """
 
 import os
+from datetime import tzinfo
 from pathlib import Path
 from typing import Any, no_type_check
 
@@ -120,7 +121,11 @@ class Parser:
         %ignore WS
         """  # noqa
 
-    def __init__(self, context: dict[str, Any] | None = None) -> None:
+    def __init__(
+        self,
+        context: dict[str, Any] | None = None,
+        default_timezone: tzinfo | None = None,
+    ) -> None:
         """
         Initialize the Parser.
 
@@ -128,6 +133,9 @@ class Parser:
             context (dict[str, Any] | None): Optional dictionary of variables that can
             be referenced in queries. Context variables override data variables unless
             the data variable is explicitly accessed with a leading dot.
+            default_timezone (tzinfo | None): Time zone to apply to parsed datetime
+            values that do not include time zone information. If None, naive datetimes
+            remain naive.
         """
         # Determine the cache file of the grammar. By default, it's in the home
         # directory. But when the environment variable is set, use the value
@@ -142,7 +150,7 @@ class Parser:
             propagate_positions=True,
             cache=cache_path,
         )
-        self.shaper = ExpressionTransformer(context)
+        self.shaper = ExpressionTransformer(context, default_timezone)
 
     @no_type_check
     def parse(self, data: str) -> Tree[Token]:

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

@@ -20,7 +20,7 @@ Classes:
 
 import re
 from collections.abc import Mapping, MutableSequence
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, tzinfo
 from typing import Any, cast
 
 from ipranges import IP4, IP6, IP4Net, IP4Range, IP6Net, IP6Range
@@ -194,7 +194,11 @@ class ExpressionTransformer(Transformer):
     into appropriate objects (ipranges, datetime, list, ...).
     """
 
-    def __init__(self, context: dict[str, Any] | None = None) -> None:
+    def __init__(
+        self,
+        context: dict[str, Any] | None = None,
+        default_timezone: tzinfo | None = None,
+    ) -> None:
         """
         Initializes the ExpressionTransformer with a context dictionary
         for constants.
@@ -203,8 +207,12 @@ class ExpressionTransformer(Transformer):
             context: A dictionary containing constant values that can be
                      accessed by variable names within expressions.
                      Defaults to an empty dictionary if none is provided.
+            default_timezone: Time zone to apply to parsed datetime values
+                              that do not include time zone information.
+                              If None, naive datetimes remain naive.
         """
         self.context = context if context is not None else {}
+        self.default_timezone = default_timezone
 
     def number(self, data: Token) -> Tree[TokenWrapper]:
         """
@@ -322,6 +330,11 @@ class ExpressionTransformer(Transformer):
 
         # Convert to datetime object
         dtime = datetime.fromisoformat(datetime_str)
+
+        # If no time zone was specified, then set to default time zone
+        if dtime.tzinfo is None:
+            dtime = dtime.replace(tzinfo=self.default_timezone)
+
         tw = TokenWrapper(_add_tokens(date, time), dtime)
 
         return Tree("datetime", [tw], _create_meta(tw))
@@ -337,7 +350,14 @@ class ExpressionTransformer(Transformer):
         """
         return Tree(
             "datetime",
-            [TokenWrapper(date, datetime.fromisoformat(date + "T00:00:00"))],
+            [
+                TokenWrapper(
+                    date,
+                    datetime.fromisoformat(date + "T00:00:00").replace(
+                        tzinfo=self.default_timezone
+                    ),
+                )
+            ],
             _create_meta(date),
         )
 
@@ -819,7 +839,8 @@ 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'.
+            A part of the SQL query (the part after 'SELECT' or 'WHERE') and its
+            parameters.
         """
         self.data = data if data is not None else {}
 
@@ -852,13 +873,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)
 
@@ -867,7 +888,7 @@ class SQLInterpreter(Interpreter):
         elif issubclass(l_type, float) and issubclass(r_type, float):
             range_type = "numrange"
         elif issubclass(l_type, datetime) and issubclass(r_type, datetime):
-            if "WITH TIME ZONE" in l_sql or "WITH TIME ZONE" in r_sql:
+            if "WITH TIME ZONE" in l_sql and "WITH TIME ZONE" in r_sql:
                 range_type = "tstzrange"
             else:
                 range_type = "tsrange"
@@ -879,7 +900,7 @@ class SQLInterpreter(Interpreter):
             )
         else:
             raise EvaluationError(
-                f"Range operator is not supported for types '{l_type}' and '{r_type}'",
+                f"Range operator is not supported for types '{l_type}' and '{r_type}'.",
                 line=l_tree.meta.line,
                 column=l_tree.meta.column,
                 start_pos=l_tree.meta.start_pos,
@@ -898,12 +919,12 @@ 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_)
         raise EvaluationError(
-            f"The type of column '{var.real_value}' was not defined",
+            f"The type of column '{var.real_value}' was not defined.",
             line=var.line,
             column=var.column,
             start_pos=var.start_pos,
@@ -912,68 +933,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))
@@ -987,14 +1009,21 @@ class SQLInterpreter(Interpreter):
 
         args_sql = []
         params = []
+        types = []
 
         for arg in args.children if args else []:
-            sql, p, _ = self.visit(arg)
+            sql, p, type_ = self.visit(arg)
             args_sql.append(sql)
             params.extend(p)
-
-        if function_name == "now":
-            return "localtimestamp", [], datetime
+            types.append(type_)
+
+        if function_name == "now" and len(args_sql) == 0:
+            return "localtimestamp", params, datetime
+        if function_name in ("len", "length") and len(args_sql) == 1:
+            if types[0] is list:
+                return f"array_length({args_sql[0]}, 1)", params, int
+            if types[0] is str:
+                return f"length({args_sql[0]})", params, int
         raise EvaluationError(
             f"Function '{name.real_value}' was not found.",
             line=name.line,

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

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

@@ -213,6 +213,68 @@ class TestExpressionTransformer:
         assert result_data.children[0].real_value == "my_var"
 
 
+class TestDefaultTimezone:
+    def test_naive_datetime_gets_default_timezone(self):
+        parser = Parser(default_timezone=timezone.utc)
+
+        result = parser.parse("2024-01-01T12:00:00").children[0].real_value
+
+        assert result.tzinfo == timezone.utc
+        assert str(result) == "2024-01-01 12:00:00+00:00"
+
+        result = parser.parse("2024-01-01").children[0].real_value
+
+        assert result.tzinfo == timezone.utc
+        assert str(result) == "2024-01-01 00:00:00+00:00"
+
+    def test_naive_datetime_with_custom_timezone(self):
+        custom_tz = timezone(timedelta(hours=2))
+        parser = Parser(default_timezone=custom_tz)
+
+        result = parser.parse("2024-01-01T12:00:00").children[0].real_value
+
+        assert result.tzinfo == custom_tz
+        assert str(result) == "2024-01-01 12:00:00+02:00"
+
+        result = parser.parse("2024-01-01").children[0].real_value
+
+        assert result.tzinfo == custom_tz
+        assert str(result) == "2024-01-01 00:00:00+02:00"
+
+    def test_datetime_with_timezone_not_overridden(self):
+        parser = Parser(default_timezone=timezone.utc)
+
+        result = parser.parse("2024-01-01T12:00:00+02:00").children[0].real_value
+
+        # Should keep original timezone
+        assert result.tzinfo.utcoffset(result) == timedelta(hours=2)
+        assert str(result) == "2024-01-01 12:00:00+02:00"
+
+    def test_no_default_timezone_keeps_naive_datetime(self):
+        parser = Parser(default_timezone=None)
+
+        result = parser.parse("2024-01-01T12:00:00").children[0].real_value
+
+        assert result.tzinfo is None
+        assert str(result) == "2024-01-01 12:00:00"
+
+        result = parser.parse("2024-01-01").children[0].real_value
+
+        assert result.tzinfo is None
+        assert str(result) == "2024-01-01 00:00:00"
+
+    def test_expression_transformer_default_timezone_direct(self, parser):
+        transformer = ExpressionTransformer(default_timezone=timezone.utc)
+
+        result = (
+            transformer.transform(parser.parse_only("2024-01-01T12:00:00"))
+            .children[0]
+            .real_value
+        )
+
+        assert result.tzinfo == timezone.utc
+
+
 class TestFilter:
     def parse_filter(self, parser, filter_, expression):
         """Helper to parse, evaluate atoms to Python object, then evaluate."""
@@ -522,6 +584,7 @@ class TestSQLInterpreter:
             "c_int": ("c", int),
             "d_int": ("d", int),
             "Description": ("description", str),
+            "Category": ("category", list),
         }
         return sql.to_sql(tree, data)
 
@@ -530,9 +593,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 +617,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 +722,133 @@ 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"]),
+            (
+                "Category contains 'Attempt'",
+                "position(%s in array_to_string(\"category\", ','))>0",
+                ["Attempt"],
+            ),
+            (
+                "['abcdfg', 'qwerty', 'azerty'] contains 'bcd'",
+                "position(%s in array_to_string(ARRAY[%s, %s, %s], ','))>0",
+                ["bcd", "abcdfg", "qwerty", "azerty"],
+            ),
+            # 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"),
+                ],
+            ),
+            # Test functions.
+            (
+                "now() > 2025-12-12T12:34:56Z",
+                "localtimestamp > %s::TIMESTAMP WITH TIME ZONE",
+                [datetime(2025, 12, 12, 12, 34, 56, tzinfo=timezone.utc)],
+            ),
+            ("length('')", "length(%s)", [""]),
+            ("length('abcde')", "length(%s)", ["abcde"]),
+            (
+                "length([1, 2, 3]) == 3",
+                "array_length(ARRAY[%s, %s, %s], 1) = %s",
+                [1, 2, 3, 3],
+            ),
+            ("len(Category) > 1", 'array_length("category", 1) > %s', [1]),
         ],
     )
     def test_parse_sql(self, parser, sql, expr, expected_sql, expected_params):