sqlakit 0.22.6__tar.gz → 0.22.8__tar.gz

{sqlakit-0.22.6 → sqlakit-0.22.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlakit
-Version: 0.22.6
+Version: 0.22.8
 Summary: A toolkit for SQLAlchemy applications.
 Keywords: sqlalchemy,database,orm,sql,asyncio
 Author: Anton Ruhlov

{sqlakit-0.22.6 → sqlakit-0.22.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sqlakit"
-version = "0.22.6"
+version = "0.22.8"
 description = "A toolkit for SQLAlchemy applications."
 readme = "README.md"
 license = "MIT"

{sqlakit-0.22.6 → sqlakit-0.22.8}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "sqlakit"
-version = "0.22.6"
+version = "0.22.8"
 description = "A toolkit for SQLAlchemy applications."
 readme = "README.md"
 license = "MIT"

{sqlakit-0.22.6 → sqlakit-0.22.8}/sqlakit/_sql.py

@@ -10,7 +10,7 @@ from collections.abc import Mapping, Sized
 from contextlib import contextmanager
 from contextvars import ContextVar
 from dataclasses import dataclass, is_dataclass
-from functools import cache, cached_property, lru_cache
+from functools import cache, cached_property, lru_cache, partial
 from inspect import iscoroutinefunction
 from pathlib import Path
 from types import SimpleNamespace
@@ -328,12 +328,15 @@ class Context:
         self.values: dict[str, Any] = dict(values)
         self._bound = 0
 
-    no_order = "(SELECT NULL)"
-    """An `ORDER BY` term that orders by nothing, for a macro with nothing to sort by.
+    @property
+    def no_order(self) -> str:
+        """An `ORDER BY` term that orders by nothing, for a macro with nothing to sort by.
 
-    Every database takes it after `ORDER BY`, and a direction after it: `NULL`
-    and `NULL DESC` are refused by PostgreSQL, and `0` is a column's position.
-    """
+        PostgreSQL and SQL Server refuse a bare `NULL` there, and take
+        `(SELECT NULL)`. Snowflake refuses a subquery there, and takes `NULL`,
+        as MySQL, SQLite and Oracle do. `0` would be a column's position.
+        """
+        return "(SELECT NULL)" if self.dialect in ("postgresql", "mssql") else "NULL"
 
     def __repr__(self) -> str:
         return f"{type(self).__name__}({self.dialect!r})"
@@ -2074,7 +2077,8 @@ def order_by(ctx: Context, sort: Param, column: Sql, *columns: Sql) -> str:
     the nulls of every term whose sort string does not say, and MySQL, which
     has no `NULLS LAST`, sorts by `IS NULL` first. Any other string is the sort
     when the call passes none, `'name.asc'` above. With neither, the rows come
-    in no order: `(SELECT NULL)`, since PostgreSQL refuses a bare `NULL`.
+    in no order: `NULL`, or `(SELECT NULL)` on PostgreSQL and SQL Server, which
+    refuse a bare `NULL`.
     """
     written = [one.strip() for one in (column, *columns)]
     options = [one.strip("'") for one in written if one.startswith("'")]
@@ -2289,6 +2293,69 @@ def array_contains_all(ctx: Context, array: Sql, other: Sql) -> str:
     return f"({array} @> {other})"
 
 
+@sql_macro(optional=True)
+def any_of(ctx: Context, rows: Param, row: Sql, condition: Sql) -> str:
+    """Whether the condition holds for any of the rows, `row.field` reading a field.
+
+    ```sql
+    WHERE tpl.any_of(
+        :cities, city,
+        ST_DISTANCE(p.location, ST_POINT(city.lon, city.lat)) <= city.radius
+    )
+    ```
+
+    The condition is written once for each row, its `city.field` bound to the
+    row's field, and the conditions joined with `OR`. A row is an object or a
+    mapping. No rows, or none passed, is `FALSE`: wrap the call in
+    `tpl.if_set(:cities, ...)` for a filter that is off when nothing is passed.
+
+    The SQL grows with the rows, so this is for a few dozen. A condition made
+    of equalities only is better as `EXISTS (SELECT 1 FROM tpl.values(:rows) AS
+    v WHERE t.a = v.column1)`, which the database joins. Snowflake evaluates no
+    subquery tied to the outer row by anything else, a distance, a range or a
+    `LIKE`, and this macro covers those.
+
+    Raises:
+        MacroArgumentError: if ``row`` is not a name, or a row has no field the
+            condition reads.
+
+    """
+    name = str(row).strip()
+    if not _IDENTIFIER.fullmatch(name):
+        problem = f"`{name}` is not a name to read the fields of a row under"
+        raise MacroArgumentError(any_of.name, problem)
+    field = re.compile(
+        rf"{_LITERAL}|(?<![\w.]){re.escape(name)}\.(?P<field>[A-Za-z_]\w*)\b",
+        re.DOTALL,
+    )
+    prefix = _named(rows)
+
+    def written(item: Any, found: re.Match[str]) -> str:  # noqa: ANN401
+        key = found.group("field")
+        if key is None:
+            return found.group()
+        try:
+            value = item[key] if isinstance(item, Mapping) else getattr(item, key)
+        except (KeyError, AttributeError):
+            problem = f"a row of `{_as_written(rows)}` has no field `{key}`"
+            raise MacroArgumentError(any_of.name, problem) from None
+        return ctx.bind(value, f"{prefix}_{key}" if prefix else key)
+
+    text = str(condition)
+    # A `--` comment at the end would take the `)` and the `OR` after it along.
+    if any(
+        found.group().startswith("--") and found.end() == len(text.rstrip())
+        for found in re.finditer(_LITERAL, text, re.DOTALL)
+    ):
+        text = text.rstrip() + "\n"
+    conditions = [
+        _grouped(field.sub(partial(written, item), text)) for item in rows.value or ()
+    ]
+    if not conditions:
+        return "FALSE"
+    return _grouped(" OR ".join(conditions))
+
+
 @sql_macro(name="values")
 def values_table(ctx: Context, rows: Param) -> str:
     """Write a small table out in the query, one parameter per value.
@@ -2306,7 +2373,9 @@ def values_table(ctx: Context, rows: Param) -> str:
     and PostgreSQL wants one type down a column: cast where the rows mix them.
 
     For a few dozen rows. Hundreds are better sent as one JSON value and
-    unpacked in the database, with `FLATTEN` or `json_array_elements`.
+    unpacked in the database, with `FLATTEN` or `json_array_elements`. In an
+    `EXISTS` tied to the outer row, compare by equalities only: Snowflake
+    refuses any other tie, and `any_of` writes that condition for each row.
 
     Raises:
         MacroArgumentError: if there are no rows, or they differ in length.
@@ -2591,6 +2660,7 @@ BUILTIN_MACROS: Mapping[str, Macro] = {
         arrays_overlap,
         array_contains_all,
         values_table,
+        any_of,
     )
 }