pyfect-dev 0.1.0__py3-none-any.whl

pyfect/persistence/persisted_queue/_sql_statements.py

@@ -0,0 +1,441 @@
+"""The SQL of the queue store, per dialect: the claimed ``Element``, the
+offer, poll and cleanup statements, and ``Settlements``, the statements
+that settle or renew a claim."""
+
+from __future__ import annotations
+
+import math
+import re
+from collections.abc import Callable, Generator, Sequence
+from dataclasses import dataclass
+from typing import Any, Final
+
+from pyfect._core import Effect
+from pyfect.cause import Cause
+from pyfect.duration import Seconds
+from pyfect.effect import gen, sync, void
+from pyfect.persistence._columns import column_int
+from pyfect.persistence.persistence._sql import SQL_CLEANUP_BATCH_SIZE
+from pyfect.schedule import Schedule
+from pyfect.scope import Scope, scoped
+from pyfect.sql.client import SqlClientService
+from pyfect.sql.connection import Row
+from pyfect.sql.error import SqlError
+from pyfect.sql.statement import Fragment, Statement
+
+_LONE_SURROGATE = re.compile("[\ud800-\udfff]")
+_BATCH_LIMIT: Final = str(SQL_CLEANUP_BATCH_SIZE)
+
+
+@dataclass(eq=False, slots=True)
+class Element:
+    """A row this store claimed and has not settled, under the ``lock`` of
+    the poll that claimed it."""
+
+    sequence: int | str
+    id: str
+    element: str
+    attempts: int
+    lock: str
+
+
+def store_text(text: str) -> str:
+    """Text as Node's drivers store it: a lone surrogate becomes U+FFFD."""
+    return _LONE_SURROGATE.sub("\ufffd", text)
+
+
+def _string(text: str) -> str:
+    return f"'{text}'"
+
+
+def _national_string(text: str) -> str:
+    return f"N'{text}'"
+
+
+class Dialect:
+    """The SQL of one client's dialect."""
+
+    __slots__ = ("now", "sql", "wrap_string")
+
+    def __init__(self, sql: SqlClientService) -> None:
+        self.sql = sql
+        # SYSDATETIME: GETDATE() rounds to 1/300 s and can land in the
+        # future, hiding freshly written visible_at values from a poll
+        self.now: Fragment = sql.on_dialect_or_else(
+            mssql=lambda: sql.literal("SYSDATETIME()"),
+            mysql=lambda: sql.literal("NOW()"),
+            pg=lambda: sql.literal("NOW()"),
+            or_else=lambda: sql.literal("CURRENT_TIMESTAMP"),
+        )
+        self.wrap_string: Callable[[str], str] = sql.on_dialect_or_else(
+            mssql=lambda: _national_string, or_else=lambda: _string
+        )
+
+    def string_literal(self, text: str) -> Statement[Row]:
+        """``text`` (a UUID this store made) as a string literal."""
+        return self.sql.unsafe(self.wrap_string(text))
+
+    def seconds_offset(self, seconds: int) -> Fragment:
+        """The database's now plus ``seconds`` (a whole number, maybe
+        negative)."""
+        sql = self.sql
+        s = sql.unsafe(str(seconds))
+        return sql.on_dialect_or_else(
+            pg=lambda: sql("{} + INTERVAL '{} seconds'", self.now, s),
+            mysql=lambda: sql("DATE_ADD({}, INTERVAL {} SECOND)", self.now, s),
+            mssql=lambda: sql("DATEADD(SECOND, {}, {})", s, self.now),
+            or_else=lambda: sql("datetime({}, '{} seconds')", self.now, s),
+        )
+
+    def seconds_ago(self, seconds: float) -> Fragment:
+        return self.seconds_offset(-max(math.ceil(seconds), 0))
+
+    def seconds_from_now(self, seconds: float) -> Fragment:
+        return self.seconds_offset(max(math.ceil(seconds), 0))
+
+    def delayed_visible_at(self, delay: Seconds) -> Fragment:
+        """When a delayed offer becomes visible, never before ``delay``
+        elapses: PostgreSQL reads ``clock_timestamp()`` (``NOW()`` is fixed
+        at the transaction's start); MySQL and SQLite clocks drop the
+        current second's fraction, so they get a whole second more."""
+        sql = self.sql
+        seconds = math.ceil(delay)
+        return sql.on_dialect_or_else(
+            pg=lambda: sql("clock_timestamp() + INTERVAL '{} seconds'", sql.unsafe(str(seconds))),
+            mssql=lambda: self.seconds_offset(seconds),
+            or_else=lambda: self.seconds_offset(seconds + 1),
+        )
+
+
+type OfferStatement = Callable[[str, str, str, Fragment], Effect[object, SqlError]]
+type PollStatement = Callable[[str, int, int, Fragment], Effect[Sequence[Row], SqlError]]
+type CleanupBatch = Callable[[str, float], Effect[int, SqlError]]
+
+
+def offer_statement(dialect: Dialect, table_name: str) -> OfferStatement:
+    sql = dialect.sql
+    table = sql.identifier(table_name)
+    now = dialect.now
+
+    def pg() -> OfferStatement:
+        return lambda id, name, element, visible_at: sql(
+            "INSERT INTO {} (id, queue_name, element, state, attempts, visible_at, created_at, "
+            "updated_at) VALUES ({}, {}, {}, 'pending', 0, {}, {}, {}) "
+            "ON CONFLICT (id, queue_name) DO NOTHING",
+            table,
+            id,
+            name,
+            element,
+            visible_at,
+            now,
+            now,
+        )
+
+    def mysql() -> OfferStatement:
+        return lambda id, name, element, visible_at: sql(
+            "INSERT IGNORE INTO {} (id, queue_name, element, state, attempts, visible_at, "
+            "created_at, updated_at) VALUES ({}, {}, {}, 'pending', 0, {}, {}, {})",
+            table,
+            id,
+            name,
+            element,
+            visible_at,
+            now,
+            now,
+        )
+
+    def mssql() -> OfferStatement:
+        # No MERGE WITH (HOLDLOCK), whose range locks deadlock concurrent
+        # offers: READCOMMITTEDLOCK makes the check wait for an uncommitted
+        # duplicate; a duplicate inserted after it raises 2601 / 2627 with
+        # XACT_ABORT off, so the caller's transaction survives; the nested
+        # sp_executesql restores XACT_ABORT on exit.
+        def escape(name: str) -> str:
+            return "[" + name.replace("]", "]]").replace(".", "].[") + "]"
+
+        escaped = escape(table_name)
+        index = escape(f"idx_{table_name}_id")
+        offer_sql = (
+            "SET XACT_ABORT OFF; BEGIN TRY IF NOT EXISTS (SELECT 1 FROM "
+            f"{escaped} WITH (READCOMMITTEDLOCK, FORCESEEK, INDEX({index})) "
+            "WHERE id = @id AND queue_name = @name) "
+            f"INSERT INTO {escaped} (id, queue_name, element, state, attempts, visible_at, "
+            "created_at, updated_at) VALUES (@id, @name, @element, 'pending', 0, @visible_at, "
+            "SYSDATETIME(), SYSDATETIME()); END TRY BEGIN CATCH "
+            "IF ERROR_NUMBER() NOT IN (2601, 2627) OR XACT_STATE() = -1 BEGIN "
+            "IF @xact_abort <> 0 SET XACT_ABORT ON; THROW; END END CATCH"
+        )
+        return lambda id, name, element, visible_at: sql(
+            "DECLARE @visible_at DATETIME2 = {}; DECLARE @xact_abort INT = @@OPTIONS & 16384; "
+            "EXEC sp_executesql {}, N'@id NVARCHAR(MAX), @name NVARCHAR(MAX), "
+            "@element NVARCHAR(MAX), @visible_at DATETIME2, @xact_abort INT', "
+            "@id = {}, @name = {}, @element = {}, @visible_at = @visible_at, "
+            "@xact_abort = @xact_abort;",
+            visible_at,
+            offer_sql,
+            id,
+            name,
+            element,
+        )
+
+    def sqlite() -> OfferStatement:
+        return lambda id, name, element, visible_at: sql(
+            "INSERT OR IGNORE INTO {} (id, queue_name, element, state, attempts, visible_at, "
+            "created_at, updated_at) VALUES ({}, {}, {}, 'pending', 0, {}, {}, {})",
+            table,
+            id,
+            name,
+            element,
+            visible_at,
+            now,
+            now,
+        )
+
+    return sql.on_dialect_or_else(pg=pg, mysql=mysql, mssql=mssql, or_else=sqlite)
+
+
+def poll_statement(dialect: Dialect, table_name: str, expires_at: Fragment) -> PollStatement:
+    """Claim up to ``size`` visible rows of queue ``name`` under ``lock``,
+    counting an attempt, oldest first."""
+    sql = dialect.sql
+    table = sql.identifier(table_name)
+    now = dialect.now
+
+    def pg() -> PollStatement:
+        return lambda name, max_attempts, size, lock: sql(
+            "WITH cte AS (UPDATE {table} SET acquired_at = {now}, acquired_by = {lock}, "
+            "attempts = attempts + 1 WHERE sequence IN (SELECT sequence FROM {table} "
+            "WHERE queue_name = {name} AND state = 'pending' AND attempts < {max_attempts} "
+            "AND visible_at <= {now} AND (acquired_at IS NULL OR acquired_at < {expires_at}) "
+            "ORDER BY visible_at ASC, sequence ASC FOR UPDATE SKIP LOCKED LIMIT {size}) "
+            "RETURNING sequence, id, element, attempts, visible_at) "
+            "SELECT sequence, id, element, attempts FROM cte ORDER BY visible_at ASC, sequence ASC",
+            table=table,
+            now=now,
+            lock=lock,
+            name=name,
+            max_attempts=max_attempts,
+            expires_at=expires_at,
+            size=sql.unsafe(str(size)),
+        )
+
+    def mysql() -> PollStatement:
+        def poll(name: str, max_attempts: int, size: int, lock: Fragment) -> Effect[Any, SqlError]:
+            def claim(rows: Sequence[Row]) -> Effect[object, SqlError]:
+                if not rows:
+                    return void
+                sequences = ",".join(str(row["sequence"]) for row in rows)
+                return sql(
+                    "UPDATE {} SET acquired_at = {}, acquired_by = {}, attempts = attempts + 1 "
+                    "WHERE sequence IN ({})",
+                    table,
+                    now,
+                    lock,
+                    sql.unsafe(sequences),
+                ).unprepared
+
+            def counted(rows: Sequence[Row]) -> list[Row]:
+                return [{**row, "attempts": column_int(row["attempts"]) + 1} for row in rows]
+
+            return sql.with_transaction(
+                sql(
+                    "SELECT sequence, id, element, attempts FROM {} q WHERE queue_name = {} "
+                    "AND state = 'pending' AND attempts < {} AND visible_at <= {} "
+                    "AND (acquired_at IS NULL OR acquired_at < {}) "
+                    "ORDER BY visible_at ASC, sequence ASC LIMIT {} FOR UPDATE SKIP LOCKED",
+                    table,
+                    name,
+                    max_attempts,
+                    now,
+                    expires_at,
+                    sql.unsafe(str(size)),
+                )
+                .tap(claim)
+                .map(counted)
+            )
+
+        return poll
+
+    def mssql() -> PollStatement:
+        # READPAST skips rows another claim or a settlement holds instead of
+        # deadlocking with them
+        return lambda name, max_attempts, size, lock: sql(
+            "WITH cte AS (SELECT TOP {size} sequence FROM {table} "
+            "WITH (UPDLOCK, READPAST, ROWLOCK) "
+            "WHERE queue_name = {name} AND state = 'pending' AND attempts < {max_attempts} "
+            "AND visible_at <= {now} AND (acquired_at IS NULL OR acquired_at < {expires_at}) "
+            "ORDER BY visible_at ASC, sequence ASC) "
+            "UPDATE q SET acquired_at = {now}, acquired_by = {lock}, attempts = q.attempts + 1 "
+            "OUTPUT inserted.sequence, inserted.id, inserted.element, inserted.attempts "
+            "FROM {table} AS q INNER JOIN cte ON q.sequence = cte.sequence",
+            table=table,
+            now=now,
+            lock=lock,
+            name=name,
+            max_attempts=max_attempts,
+            expires_at=expires_at,
+            size=sql.unsafe(str(size)),
+        )
+
+    def sqlite() -> PollStatement:
+        return lambda name, max_attempts, size, lock: sql(
+            "UPDATE {table} SET acquired_at = {now}, acquired_by = {lock}, "
+            "attempts = attempts + 1 WHERE sequence IN (SELECT sequence FROM {table} "
+            "WHERE queue_name = {name} AND state = 'pending' AND attempts < {max_attempts} "
+            "AND visible_at <= {now} AND (acquired_at IS NULL OR acquired_at < {expires_at}) "
+            "ORDER BY visible_at ASC, sequence ASC LIMIT {size}) "
+            "RETURNING sequence, id, element, attempts",
+            table=table,
+            now=now,
+            lock=lock,
+            name=name,
+            max_attempts=max_attempts,
+            expires_at=expires_at,
+            size=sql.unsafe(str(size)),
+        )
+
+    return sql.on_dialect_or_else(pg=pg, mysql=mysql, mssql=mssql, or_else=sqlite)
+
+
+def cleanup_statement(dialect: Dialect, table_name: str) -> CleanupBatch:
+    """Delete up to a batch of rows in ``state`` last updated more than
+    ``seconds`` ago; the number deleted."""
+    sql = dialect.sql
+    table = sql.identifier(table_name)
+    limit = sql.unsafe(_BATCH_LIMIT)
+
+    def pg() -> CleanupBatch:
+        return lambda state, seconds: sql(
+            "WITH deleted_entries AS (DELETE FROM {} WHERE sequence IN (SELECT sequence FROM {} "
+            "WHERE state = {} AND updated_at <= {} LIMIT {}) RETURNING 1) "
+            "SELECT COUNT(*)::INT AS count FROM deleted_entries",
+            table,
+            table,
+            state,
+            dialect.seconds_ago(seconds),
+            limit,
+        ).map(lambda rows: column_int(rows[0]["count"]))
+
+    def mysql() -> CleanupBatch:
+        def run(state: str, seconds: float) -> Effect[int, SqlError]:
+            statement, params = sql(
+                "DELETE FROM {} WHERE state = {} AND updated_at <= {} LIMIT {}",
+                table,
+                state,
+                dialect.seconds_ago(seconds),
+                limit,
+            ).compile()
+
+            def body() -> Generator[Effect[Any, SqlError, Scope], Any, int]:
+                connection = yield from sql.reserve
+                yield from connection.execute(statement, params, None)
+                rows = yield from connection.execute_values("SELECT ROW_COUNT()", ())
+                return column_int(rows[0][0])
+
+            return scoped(gen(body))
+
+        return run
+
+    def mssql() -> CleanupBatch:
+        return lambda state, seconds: sql(
+            "DELETE TOP ({}) FROM {} OUTPUT DELETED.sequence WHERE state = {} AND updated_at <= {}",
+            limit,
+            table,
+            state,
+            dialect.seconds_ago(seconds),
+        ).map(len)
+
+    def sqlite() -> CleanupBatch:
+        return lambda state, seconds: sql(
+            "DELETE FROM {} WHERE sequence IN (SELECT sequence FROM {} "
+            "WHERE state = {} AND updated_at <= {} LIMIT {}) RETURNING 1 AS deleted",
+            table,
+            table,
+            state,
+            dialect.seconds_ago(seconds),
+            limit,
+        ).map(len)
+
+    return sql.on_dialect_or_else(pg=pg, mysql=mysql, mssql=mssql, or_else=sqlite)
+
+
+class Settlements:
+    """The statements that settle or renew this store's claims. Each only
+    matches the claim it belongs to (its sequence and poll lock), so a
+    stale settlement never touches a newer claim of the same row."""
+
+    __slots__ = ("_ack_schedule", "_dialect", "_table", "held")
+
+    def __init__(
+        self, dialect: Dialect, table_name: str, ack_schedule: Schedule[object, object]
+    ) -> None:
+        self._dialect = dialect
+        self._table = dialect.sql.identifier(table_name)
+        self._ack_schedule = ack_schedule
+        self.held: dict[Element, None] = {}
+        """The claims this store holds, renewed by ``refresh_locks``."""
+
+    def refresh_locks(self) -> Effect[object, SqlError]:
+        if not self.held:
+            return void
+        sql = self._dialect.sql
+        sequences = dict.fromkeys(str(element.sequence) for element in self.held)
+        locks = dict.fromkeys(self._dialect.wrap_string(element.lock) for element in self.held)
+        # a row only carries the lock of the poll that claimed it, so matching
+        # every held sequence against every held lock renews just this
+        # store's own claims
+        return sql(
+            "UPDATE {} SET acquired_at = {} WHERE sequence IN ({}) AND acquired_by IN ({})",
+            self._table,
+            self._dialect.now,
+            sql.unsafe(",".join(sequences)),
+            sql.unsafe(",".join(locks)),
+        )
+
+    def _ack(self, element: Element, set_clause: Fragment) -> Effect[None]:
+        sql = self._dialect.sql
+        statement = sql(
+            "UPDATE {} SET acquired_at = NULL, acquired_by = NULL, {} "
+            "WHERE sequence = {} AND acquired_by = {}",
+            self._table,
+            set_clause,
+            element.sequence,
+            self._dialect.string_literal(element.lock),
+        )
+        return (
+            statement.retry(self._ack_schedule)
+            .or_die()
+            .ensuring(sync(lambda: self.held.pop(element, None)))
+            .as_void()
+        )
+
+    def complete(self, element: Element) -> Effect[None]:
+        sql = self._dialect.sql
+        return self._ack(element, sql("updated_at = {}, state = 'completed'", self._dialect.now))
+
+    def fail(self, element: Element, cause: Cause[Any]) -> Effect[None]:
+        sql = self._dialect.sql
+        return self._ack(
+            element,
+            sql(
+                "updated_at = {}, state = 'failed', last_failure = {}",
+                self._dialect.now,
+                cause.pretty(),
+            ),
+        )
+
+    def retry(self, element: Element, delay: Seconds, cause: Cause[Any]) -> Effect[None]:
+        sql = self._dialect.sql
+        return self._ack(
+            element,
+            sql(
+                "updated_at = {}, visible_at = {}, last_failure = {}",
+                self._dialect.now,
+                self._dialect.seconds_from_now(delay),
+                cause.pretty(),
+            ),
+        )
+
+    def interrupt(self, element: Element) -> Effect[None]:
+        """Release the claim without counting its attempt."""
+        return self._ack(element, self._dialect.sql.literal("attempts = attempts - 1"))

pyfect/persistence/persisted_queue/_store.py

@@ -0,0 +1,147 @@
+"""``PersistedQueueStore``: where a ``PersistedQueue`` keeps its elements,
+and what every store shares."""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Final, Protocol
+
+from pyfect._core import Effect
+from pyfect.context import Tag
+from pyfect.duration import Duration, Seconds, to_seconds
+from pyfect.latch import Latch
+from pyfect.persistence.persisted_queue._error import PersistedQueueError
+from pyfect.schedule import Schedule, exponential, min, spaced
+from pyfect.scope import Scope
+
+
+@dataclass(frozen=True, slots=True)
+class TakenElement:
+    """An element a store claimed: its ``attempts`` count this claim (from
+    1), and ``element`` is its stored JSON value."""
+
+    id: str
+    attempts: int
+    element: object
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class TakeOptions:
+    """What a store's ``take`` needs from the queue: an element failing on
+    attempt ``max_attempts`` is marked failed; before that it is retried
+    after ``retry_delay(attempts)``."""
+
+    name: str
+    max_attempts: int
+    retry_delay: Callable[[int], Effect[Seconds]]
+
+
+class Offer(Protocol):
+    """Store ``element`` under ``id`` unless the queue has that id. A
+    ``delay`` is finite and positive: the element is not taken before it
+    elapses."""
+
+    def __call__(
+        self,
+        *,
+        name: str,
+        id: str,
+        element: object,
+        is_custom_id: bool,
+        delay: Seconds | None = None,
+    ) -> Effect[None, PersistedQueueError]: ...
+
+
+class Cleanup(Protocol):
+    """Remove completed elements older than ``time_to_live`` with their
+    de-duplication records; failed ones only with ``failed_time_to_live``."""
+
+    def __call__(
+        self, *, time_to_live: Seconds, failed_time_to_live: Seconds | None
+    ) -> Effect[None, PersistedQueueError]: ...
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class PersistedQueueStoreService:
+    """The elements of every queue.
+
+    - ``offer``: store an element (see ``Offer``).
+    - ``take(options)``: claim the next visible element, counting an
+      attempt, waiting while there is none. When the scope closes, a
+      success marks it completed, an interruption releases it without the
+      attempt, a ``DeadLetter`` failure marks it failed, and any other
+      failure retries it or, after ``max_attempts``, marks it failed.
+    - ``cleanup``: see ``Cleanup``.
+    """
+
+    offer: Offer
+    take: Callable[[TakeOptions], Effect[TakenElement, PersistedQueueError, Scope]]
+    cleanup: Cleanup
+
+
+class PersistedQueueStore(
+    Tag[PersistedQueueStoreService], key="effect/persistence/PersistedQueue/PersistedQueueStore"
+):
+    """Where persisted queues keep their elements."""
+
+
+@dataclass(slots=True)
+class QueueState:
+    """A queue's state in one store, shared by its offers and takes:
+    ``take`` records ``max_attempts`` before the store's mailbox reads it,
+    and ``offer`` opens ``nudge`` so local pollers skip the poll interval."""
+
+    max_attempts: int
+    nudge: Latch
+
+
+_PLACEHOLDER_MAX_ATTEMPTS: Final = 2_147_483_647
+"""Overwritten by ``take`` before any mailbox reads it; int32-safe for SQL
+parameters."""
+
+
+class QueueStates:
+    __slots__ = ("_states",)
+
+    def __init__(self) -> None:
+        self._states: dict[str, QueueState] = {}
+
+    def peek(self, name: str) -> QueueState | None:
+        return self._states.get(name)
+
+    def get(self, name: str) -> QueueState:
+        state = self._states.get(name)
+        if state is None:
+            state = QueueState(_PLACEHOLDER_MAX_ATTEMPTS, Latch())
+            self._states[name] = state
+        return state
+
+
+def ack_retry_schedule(lock_expiration: Seconds) -> Schedule[object, object]:
+    """How a store retries settling an element: backing off from 200 ms to
+    5 s, for as long as the element's lock lasts."""
+    return min(exponential(0.2, 1.5), spaced(5)).up_to(duration=lock_expiration)
+
+
+def store_interval(duration: Duration, default: Seconds) -> Seconds:
+    """A store's interval option as Effect reads it (``options.x ? x :
+    default``): zero means ``default``; anything else is at least a
+    millisecond."""
+    seconds = to_seconds(duration)
+    if seconds == 0:
+        return default
+    return seconds if seconds >= 0.001 else Seconds(0.001)
+
+
+def positive_delay(delay: Duration | None) -> Seconds | None:
+    """A delay a store sees: ``None`` for none, zero or negative."""
+    if delay is None:
+        return None
+    seconds = to_seconds(delay)
+    return seconds if seconds > 0 else None
+
+
+def is_infinite(delay: Seconds | None) -> bool:
+    return delay is not None and math.isinf(delay)

pyfect/persistence/persistence/__init__.py

@@ -0,0 +1,84 @@
+"""Request outcomes stored outside the process (Effect's
+``effect/persistence/Persistence``)::
+
+    persistence = yield from Persistence()
+    store = yield from persistence.make(store_id="users", time_to_live=lambda _e, _r: 3600)
+    yield from store.set(GetUser(1), fx.exit.succeed(user))
+    stored = yield from store.get(GetUser(1))     # an Exit, or None
+
+``Persistence`` writes each outcome as JSON by the request's schemas
+(``pyfect.persistence.persistable``) into a ``BackingPersistence``:
+``layer_memory``, ``layer_kvs`` (a ``KeyValueStore``), ``layer_redis``
+(the ``Redis`` service), ``layer_sql`` (one SQL table) or
+``layer_sql_multi_table`` (a table per store), each also available as its
+backing layer for ``layer``.
+"""
+
+from typing import Never
+
+from pyfect.layer import Layer, provide
+from pyfect.persistence._error import PersistenceError
+from pyfect.persistence.key_value_store import KeyValueStore
+from pyfect.persistence.persistence._kvs import layer_backing_kvs
+from pyfect.persistence.persistence._memory import layer_backing_memory, make_backing_memory
+from pyfect.persistence.persistence._redis import layer_backing_redis
+from pyfect.persistence.persistence._service import (
+    BackingEntry,
+    BackingPersistence,
+    BackingPersistenceService,
+    BackingPersistenceStore,
+    Persistence,
+    PersistenceService,
+    PersistenceStore,
+    layer,
+    unsafe_ttl_to_expires,
+)
+from pyfect.persistence.persistence._sql import (
+    SQL_CLEANUP_BATCH_SIZE,
+    layer_backing_sql,
+    layer_backing_sql_multi_table,
+)
+from pyfect.persistence.redis import Redis
+from pyfect.sql.client import SqlClient
+
+layer_memory: Layer[Persistence] = layer.pipe(provide(layer_backing_memory))
+"""``Persistence`` in memory."""
+
+layer_kvs: Layer[Persistence, Never, KeyValueStore] = layer.pipe(provide(layer_backing_kvs))
+"""``Persistence`` in the ``KeyValueStore``."""
+
+layer_redis: Layer[Persistence, Never, Redis] = layer.pipe(provide(layer_backing_redis))
+"""``Persistence`` in Redis."""
+
+layer_sql: Layer[Persistence, Never, SqlClient] = layer.pipe(provide(layer_backing_sql))
+"""``Persistence`` in one SQL table."""
+
+layer_sql_multi_table: Layer[Persistence, Never, SqlClient] = layer.pipe(
+    provide(layer_backing_sql_multi_table)
+)
+"""``Persistence`` in a SQL table per store."""
+
+__all__ = [
+    "SQL_CLEANUP_BATCH_SIZE",
+    "BackingEntry",
+    "BackingPersistence",
+    "BackingPersistenceService",
+    "BackingPersistenceStore",
+    "Persistence",
+    "PersistenceError",
+    "PersistenceService",
+    "PersistenceStore",
+    "layer",
+    "layer_backing_kvs",
+    "layer_backing_memory",
+    "layer_backing_redis",
+    "layer_backing_sql",
+    "layer_backing_sql_multi_table",
+    "layer_kvs",
+    "layer_memory",
+    "layer_redis",
+    "layer_sql",
+    "layer_sql_multi_table",
+    "make_backing_memory",
+    "unsafe_ttl_to_expires",
+]