pyfect-dev 0.1.0__py3-none-any.whl

pyfect/sql/clickhouse/params.py

@@ -0,0 +1,168 @@
+"""Values as ClickHouse's HTTP interface reads them: query parameters
+(``param_<name>`` URL entries, as ``@clickhouse/client``'s
+``formatQueryParams`` writes them), settings, and the type a value is
+bound as when no type is given.
+
+A parameter is text the server parses as its placeholder's type
+(``{p1: Int64}``):
+
+- ``None`` is ``\\N`` (``NULL`` inside an array, tuple or map)
+- ``bool`` is ``1`` / ``0`` (``TRUE`` / ``FALSE`` inside a container)
+- ``int``, ``float`` (``nan``, ``+inf``, ``-inf``), ``Decimal`` as numbers
+- ``str`` and ``UUID`` with tabs, newlines, quotes and backslashes escaped
+  (quoted inside a container)
+- an aware ``datetime`` as Unix seconds, with microseconds when it has
+  them (inside a container, its UTC date ``'YYYY-MM-DD'``, which every date
+  and time type accepts); a ``date`` as ``YYYY-MM-DD``
+- a ``list`` or ``tuple`` as an array, ``TupleParam`` as a tuple, a
+  ``Mapping`` as a map
+
+Any other value, and a naive ``datetime``, is a ``TypeError``.
+"""
+
+from __future__ import annotations
+
+import math
+import uuid
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from datetime import UTC, date, datetime, timedelta
+from decimal import Decimal
+from typing import cast
+
+from pyfect._js import js_number
+
+type Setting = bool | int | float | str | Mapping[str, str]
+"""A ClickHouse setting's value; a mapping is a map setting
+(``{'system.numbers':'number != 3'}``)."""
+
+type Settings = Mapping[str, Setting]
+"""ClickHouse settings by name (``{"max_threads": 4}``)."""
+
+_EPOCH = datetime(1970, 1, 1, tzinfo=UTC)
+_MICROSECOND = timedelta(microseconds=1)
+_ESCAPES = str.maketrans({"\t": "\\t", "\n": "\\n", "\r": "\\r", "'": "\\'", "\\": "\\\\"})
+_INT64 = 1 << 63
+_UINT64 = 1 << 64
+
+
+@dataclass(frozen=True, slots=True)
+class TupleParam:
+    """A ``Tuple(...)`` parameter: ``TupleParam((42, "foo", None))`` is
+    ``(42,'foo',NULL)`` (``@clickhouse/client``'s ``TupleParam``)."""
+
+    values: Sequence[object]
+
+
+def _unix_seconds(value: datetime) -> str:
+    if value.tzinfo is None:
+        raise TypeError(f"A naive datetime cannot be a query parameter: [{value!r}].")
+    # The server reads ``-2.5`` as minus 2.5 seconds, so a time before the
+    # epoch is its magnitude, signed (``@clickhouse/client`` floors the
+    # seconds and adds the fraction: a second early).
+    micros = (value - _EPOCH) // _MICROSECOND
+    seconds, fraction = divmod(abs(micros), 1_000_000)
+    text = f"-{seconds}" if micros < 0 else f"{seconds:010d}"
+    return text if fraction == 0 else f"{text}.{fraction:06d}"
+
+
+def _in_container(value: object) -> str:
+    match value:
+        case None:
+            return "NULL"
+        case bool():
+            return "TRUE" if value else "FALSE"
+        case str() | uuid.UUID():
+            return f"'{str(value).translate(_ESCAPES)}'"
+        case datetime():
+            _unix_seconds(value)  # rejects a naive datetime
+            return f"'{value.astimezone(UTC).date().isoformat()}'"
+        case date():
+            return f"'{value.isoformat()}'"
+        case _:
+            return format_query_param(value)
+
+
+def format_query_param(value: object) -> str:  # noqa: PLR0911, PLR0912
+    """``value`` as the text of a query parameter (see the module)."""
+    match value:
+        case None:
+            return "\\N"
+        case bool():
+            return "1" if value else "0"
+        case int():
+            return str(value)
+        case float():
+            if math.isnan(value):
+                return "nan"
+            if math.isinf(value):
+                return "+inf" if value > 0 else "-inf"
+            return js_number(value)
+        case Decimal():
+            return str(value)
+        case str() | uuid.UUID():
+            return str(value).translate(_ESCAPES)
+        case datetime():
+            return _unix_seconds(value)
+        case date():
+            return value.isoformat()
+        case list() | tuple():
+            items = cast("Sequence[object]", value)
+            return "[" + ",".join(_in_container(item) for item in items) + "]"
+        case TupleParam():
+            return "(" + ",".join(_in_container(item) for item in value.values) + ")"
+        case Mapping():
+            entries = cast("Mapping[object, object]", value)
+            return (
+                "{"
+                + ",".join(f"{_in_container(k)}:{_in_container(v)}" for k, v in entries.items())
+                + "}"
+            )
+        case _:
+            raise TypeError(f"Unsupported value in query parameters: [{value!r}].")
+
+
+def format_setting(value: Setting) -> str:
+    """``value`` as the text of a setting (``@clickhouse/client``'s
+    ``formatQuerySettings``)."""
+    match value:
+        case bool():
+            return "1" if value else "0"
+        case int() | float():
+            return js_number(value)
+        case str():
+            return value
+        case _:
+            return "{" + ",".join(f"'{k}':'{v}'" for k, v in value.items()) + "}"
+
+
+def type_of(value: object) -> str:  # noqa: PLR0911
+    """The ClickHouse type a value is bound as when no type is given (Effect's
+    ``typeFromUnknown``): ``Bool``, ``Int64`` (``UInt64`` or ``Int256`` past it),
+    ``Float64``, ``DateTime`` (``DateTime64(6)`` with microseconds),
+    ``Date``, ``Array(<type of the first item>)``, else ``String``."""
+    match value:
+        case bool():
+            return "Bool"
+        case int():
+            return (
+                "Int64"
+                if -_INT64 <= value < _INT64
+                else "UInt64"
+                if 0 <= value < _UINT64
+                else "Int256"
+            )
+        case float():
+            return "Float64"
+        case datetime():
+            return "DateTime" if value.microsecond == 0 else "DateTime64(6)"
+        case date():
+            return "Date"
+        case list() | tuple():
+            items = cast("Sequence[object]", value)
+            return f"Array({type_of(items[0] if items else None)})"
+        case _:
+            return "String"
+
+
+__all__ = ["Setting", "Settings", "TupleParam", "format_query_param", "format_setting", "type_of"]

pyfect/sql/client/__init__.py

@@ -0,0 +1,35 @@
+"""The SQL client (Effect's ``effect/sql/SqlClient``): ``SqlClient`` is the
+service, ``make`` builds one from a driver's connections."""
+
+from pyfect.sql.client._client import ClientFields, ReactiveQueue, SqlClient, SqlClientService, make
+from pyfect.sql.client._sqlite_acquirers import SqliteAcquirers, make_sqlite_acquirers
+from pyfect.sql.client._transaction import (
+    BeginTransaction,
+    SafeIntegers,
+    TransactionConnection,
+    TransactionLevel,
+    TransactionOptions,
+    WithTransaction,
+    make_after_commit,
+    make_with_transaction,
+    transaction_connection,
+)
+
+__all__ = [
+    "BeginTransaction",
+    "ClientFields",
+    "ReactiveQueue",
+    "SafeIntegers",
+    "SqlClient",
+    "SqlClientService",
+    "SqliteAcquirers",
+    "TransactionConnection",
+    "TransactionLevel",
+    "TransactionOptions",
+    "WithTransaction",
+    "make",
+    "make_after_commit",
+    "make_sqlite_acquirers",
+    "make_with_transaction",
+    "transaction_connection",
+]

pyfect/sql/client/_client.py

@@ -0,0 +1,309 @@
+"""The ``SqlClient`` service (Effect's ``effect/sql/SqlClient``)."""
+# pyright: reportPrivateUsage=false
+
+from __future__ import annotations
+
+import copy as copy_module
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, Never, Protocol, Self, TypedDict, cast
+
+from pyfect._core import Effect, _Succeed, _WithFiber
+from pyfect._effect_args import require_effect
+from pyfect.context import Tag
+from pyfect.errors import Done
+from pyfect.queue import Dequeue
+from pyfect.reactivity import Keys, Reactivity, ReactivityService
+from pyfect.scope import Scope
+from pyfect.sql.client._transaction import (
+    TransactionConnection,
+    TransactionOptions,
+    WithTransaction,
+    make_after_commit,
+    transaction_connection,
+)
+from pyfect.sql.connection import Acquirer, Borrower, Connection, TransformRows
+from pyfect.sql.error import SqlError
+from pyfect.sql.statement import Compiler, Constructor, SpanAttributes
+
+if TYPE_CHECKING:
+    from pyfect._fiber import Fiber
+    from pyfect.stream import Stream
+
+
+class ReactiveQueue(Protocol):
+    """A driver's own ``reactive_mailbox``."""
+
+    def __call__[A, E, R](
+        self, keys: Keys, effect: Effect[A, E, R], /
+    ) -> Effect[Dequeue[A, E | Done], Never, R | Scope]: ...
+
+
+class ClientFields(TypedDict):
+    """The arguments of ``SqlClientService``."""
+
+    acquirer: Acquirer
+    compiler: Compiler
+    span_attributes: SpanAttributes
+    transform_rows: TransformRows | None
+    borrower: Borrower | None
+    driver: str
+    reserve: Acquirer
+    transaction_service: type[TransactionConnection]
+    with_transaction: WithTransaction
+    after_commit: Callable[[Effect[None, Never, Any]], Effect[None]]
+    reactivity: ReactivityService
+    reactive_queue: ReactiveQueue | None
+
+
+class SqlClientService(Constructor):
+    """A database client: a statement constructor (call it with SQL; see
+    ``Constructor``) with transactions and reactive queries."""
+
+    __slots__ = (
+        "_after_commit",
+        "_reactive_queue",
+        "_reactivity",
+        "_with_transaction",
+        "driver",
+        "reserve",
+        "transaction_service",
+    )
+
+    driver: str
+    """The driver that made the client, such as ``"sqlite"``. Unlike the
+    dialect, it tells apart drivers of the same SQL."""
+
+    reserve: Acquirer
+    """Leases a connection (outside any transaction) until the scope
+    closes."""
+
+    transaction_service: type[TransactionConnection]
+    """The tag of this client's open transaction."""
+
+    def __init__(
+        self,
+        *,
+        acquirer: Acquirer,
+        compiler: Compiler,
+        span_attributes: SpanAttributes,
+        transform_rows: TransformRows | None,
+        borrower: Borrower | None,
+        driver: str,
+        reserve: Acquirer,
+        transaction_service: type[TransactionConnection],
+        with_transaction: WithTransaction,
+        after_commit: Callable[[Effect[None, Never, Any]], Effect[None]],
+        reactivity: ReactivityService,
+        reactive_queue: ReactiveQueue | None,
+    ) -> None:
+        super().__init__(acquirer, compiler, span_attributes, transform_rows, borrower)
+        self.driver = driver
+        self.reserve = reserve
+        self.transaction_service = transaction_service
+        self._with_transaction = with_transaction
+        self._after_commit = after_commit
+        self._reactivity = reactivity
+        self._reactive_queue = reactive_queue
+
+    @property
+    def safe(self) -> SqlClientService:
+        """The client itself (Effect's copy for SafeQL)."""
+        return self
+
+    def fields(self) -> ClientFields:
+        """What the client was built from, to build a driver's own client
+        class on it: ``Driver(extra=..., **client.fields())``."""
+        return {
+            "acquirer": self.acquirer,
+            "compiler": self.compiler,
+            "span_attributes": self.span_attributes,
+            "transform_rows": self.transform_rows,
+            "borrower": self.borrower,
+            "driver": self.driver,
+            "reserve": self.reserve,
+            "transaction_service": self.transaction_service,
+            "with_transaction": self._with_transaction,
+            "after_commit": self._after_commit,
+            "reactivity": self._reactivity,
+            "reactive_queue": self._reactive_queue,
+        }
+
+    def without_transforms(self) -> Self:
+        """This client, without renaming identifiers or result columns."""
+        if self.transform_rows is None:
+            return self
+        copy = copy_module.copy(self)
+        copy.compiler = self.compiler.without_transform
+        copy.transform_rows = None
+        return copy
+
+    def with_transaction[A, E, R](self, effect: Effect[A, E, R]) -> Effect[A, E | SqlError, R]:
+        """Run ``effect`` in a transaction: it commits if ``effect``
+        succeeds and rolls back otherwise (also when interrupted). Nested,
+        it is a savepoint.
+
+        Inside, ``Reactivity`` invalidations wait for the outermost commit
+        (and are dropped on rollback). ``BeginTransaction`` replaces the
+        client's ``BEGIN``."""
+        require_effect(effect, "effect")
+        return self._with_transaction(effect)
+
+    def after_commit[R](self, effect: Effect[None, Never, R]) -> Effect[None, Never, R]:
+        """Run ``effect`` once the outermost transaction commits, or now
+        outside a transaction.
+
+        Callbacks are dropped if the transaction (or their savepoint) rolls
+        back or its ``COMMIT`` fails. They run in registration order, after
+        the connection is released and before ``with_transaction`` returns,
+        uninterruptibly, with the services in scope when registered minus
+        the transaction. A callback that dies is logged at
+        ``UnhandledLogLevel``. Registering after the transaction ended is a
+        defect."""
+        require_effect(effect, "effect")
+        return self._after_commit(effect)
+
+    def reactive[A, E, R](self, keys: Keys, effect: Effect[A, E, R]) -> Stream[A, E, R]:
+        """``effect``'s results, again each time ``keys`` are
+        invalidated."""
+        from pyfect import stream
+
+        require_effect(effect, "effect")
+        if self._reactive_queue is None:
+            return self._reactivity.stream(keys, effect)
+        queues = self._reactive_queue(keys, effect).map(stream.from_queue)
+        return stream.unwrap(cast("Effect[Stream[A, E, R], E, Scope | R]", queues))
+
+    def reactive_mailbox[A, E, R](
+        self, keys: Keys, effect: Effect[A, E, R]
+    ) -> Effect[Dequeue[A, E | Done], Never, R | Scope]:
+        """A queue of ``effect``'s results, refreshed when ``keys`` are
+        invalidated."""
+        require_effect(effect, "effect")
+        if self._reactive_queue is None:
+            return self._reactivity.query(keys, effect)
+        return self._reactive_queue(keys, effect)
+
+
+class SqlClient(Tag[SqlClientService], key="effect/sql/SqlClient"):
+    """The SQL client service."""
+
+
+def make(
+    *,
+    acquirer: Acquirer,
+    compiler: Compiler,
+    driver: str,
+    span_attributes: SpanAttributes = (),
+    borrower: Borrower | None = None,
+    transaction_acquirer: Acquirer | None = None,
+    transaction_service: type[TransactionConnection] | None = None,
+    prepare_transaction_controls: bool = False,
+    begin_transaction: str = "BEGIN",
+    rollback: str = "ROLLBACK",
+    commit: str | Callable[[Connection], Effect[None, SqlError]] = "COMMIT",
+    on_commit_failure: Callable[[Connection], Effect[None, SqlError]] | None = None,
+    is_transaction: Callable[[Connection], bool] | None = None,
+    savepoint: Callable[[str], str] = lambda name: f"SAVEPOINT {name}",
+    release_savepoint: Callable[[str], str] | None = None,
+    rollback_savepoint: Callable[[str], str] = lambda name: f"ROLLBACK TO SAVEPOINT {name}",
+    transform_rows: TransformRows | None = None,
+    reactive_queue: ReactiveQueue | None = None,
+) -> Effect[SqlClientService, Never, Reactivity]:
+    """A client on a driver's connections (Effect's ``SqlClient.make``).
+
+    - ``acquirer`` leases connections; ``borrower`` lends one for a single
+      statement outside transactions; ``transaction_acquirer`` (default:
+      ``acquirer``) leases those of transactions and ``reserve``
+    - ``prepare_transaction_controls``: run ``BEGIN``, ``COMMIT`` and the
+      rest prepared (off by default: several databases refuse)
+    - ``commit``: its SQL, or an effect committing on the connection;
+      ``on_commit_failure`` cleans up when it fails
+    - ``is_transaction``: whether a transaction is open; when it says no,
+      rollbacks and savepoint releases are skipped
+    - ``savepoint`` / ``release_savepoint`` / ``rollback_savepoint``: SQL
+      for a savepoint name (``effect_sql_<depth>``)
+    """
+    service = transaction_service or transaction_connection()
+
+    def control(conn: Connection, sql: str) -> Effect[None, SqlError]:
+        if prepare_transaction_controls:
+            return conn.execute(sql, (), None).as_void()
+        return conn.execute_unprepared(sql, (), None).as_void()
+
+    def cleanup(conn: Connection, sql: str) -> Effect[None, SqlError]:
+        if is_transaction is not None and not is_transaction(conn):
+            return _Succeed(None)
+        return control(conn, sql)
+
+    def begin(conn: Connection, statement: str | None) -> Effect[None, SqlError]:
+        # Unlike the client's own, a provided statement isn't fixed, so it
+        # isn't prepared.
+        if statement is None:
+            return control(conn, begin_transaction)
+        return conn.execute_unprepared(statement, (), None).as_void()
+
+    def name(depth: int) -> str:
+        return f"effect_sql_{depth}"
+
+    release = release_savepoint
+    tx_acquirer = transaction_acquirer or acquirer
+    with_transaction = WithTransaction(
+        TransactionOptions(
+            transaction_service=service,
+            span_attributes=tuple(span_attributes),
+            acquire_connection=lambda restore: restore(tx_acquirer),
+            begin=begin,
+            savepoint=lambda conn, depth: control(conn, savepoint(name(depth))),
+            release_savepoint=None
+            if release is None
+            else lambda conn, depth: cleanup(conn, release(name(depth))),
+            commit=(lambda conn: control(conn, commit)) if isinstance(commit, str) else commit,
+            on_commit_failure=on_commit_failure,
+            rollback=lambda conn: cleanup(conn, rollback),
+            rollback_savepoint=lambda conn, depth: cleanup(conn, rollback_savepoint(name(depth))),
+        )
+    )
+
+    def in_transaction(fiber: Fiber[Any, Any]) -> Effect[Connection, SqlError, Scope]:
+        found, level = fiber._context.lookup(service)
+        return _Succeed(level.connection) if found else acquirer
+
+    get_connection: Acquirer = _WithFiber(in_transaction)
+
+    client_borrower: Borrower | None = None
+    if borrower is not None:
+        lend = borrower
+
+        # A statement in a transaction runs on its connection, so only
+        # statements outside one borrow.
+        def borrow[A, E, R](
+            f: Callable[[Connection], Effect[A, E, R]],
+        ) -> Effect[A, E | SqlError, R]:
+            def body(fiber: Fiber[Any, Any]) -> Effect[A, E | SqlError, R]:
+                found, level = fiber._context.lookup(service)
+                return f(level.connection) if found else lend(f)
+
+            return _WithFiber(body)
+
+        client_borrower = borrow
+
+    def build(reactivity: ReactivityService) -> SqlClientService:
+        return SqlClientService(
+            acquirer=get_connection,
+            compiler=compiler,
+            span_attributes=span_attributes,
+            transform_rows=transform_rows,
+            borrower=client_borrower,
+            driver=driver,
+            reserve=tx_acquirer,
+            transaction_service=service,
+            with_transaction=with_transaction,
+            after_commit=make_after_commit(service),
+            reactivity=reactivity,
+            reactive_queue=reactive_queue,
+        )
+
+    return Reactivity().map(build)
+
+
+__all__ = ["ClientFields", "ReactiveQueue", "SqlClient", "SqlClientService", "make"]

pyfect/sql/client/_sqlite_acquirers.py

@@ -0,0 +1,130 @@
+"""Sharing one SQLite connection between fibers (Effect's
+``SqlClient.makeSqliteAcquirers``)."""
+# pyright: reportPrivateUsage=false
+
+from __future__ import annotations
+
+import re
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+from pyfect._core import Effect, _FailCause, _MatchCause, _Succeed, _Sync, _WithFiber
+from pyfect._effect_args import require_effect
+from pyfect._primitives import uninterruptible_mask
+from pyfect.cause import Cause
+from pyfect.cause import fail as fail_cause
+from pyfect.scope import CloseableScope, Scope
+from pyfect.semaphore import Semaphore
+from pyfect.sql.connection import Acquirer, Borrower, Connection
+from pyfect.sql.error import ConnectionError, SqlError
+
+_NO_TRANSACTION = re.compile(r"no transaction is active", re.IGNORECASE)
+
+
+def _is_no_transaction_error(error: SqlError) -> bool:
+    cause = error.reason.cause
+    message = cause if isinstance(cause, str) else getattr(cause, "message", None)
+    if not isinstance(message, str):
+        message = str(cause) if isinstance(cause, BaseException) else ""
+    return _NO_TRANSACTION.search(message) is not None
+
+
+@dataclass(frozen=True, slots=True)
+class SqliteAcquirers:
+    """What ``SqlClient.make`` needs to share one connection: leases and a
+    borrower that hold the semaphore, and the cleanup of a failed
+    ``COMMIT``."""
+
+    acquirer: Acquirer
+    borrower: Borrower
+    transaction_acquirer: Acquirer
+    on_commit_failure: Callable[[Connection], Effect[None, SqlError]]
+    is_transaction: Callable[[Connection], bool] | None
+
+
+def make_sqlite_acquirers[C: Connection](
+    *,
+    connection: Effect[C, SqlError],
+    semaphore: Semaphore,
+    is_transaction: Callable[[C], bool] | None = None,
+) -> SqliteAcquirers:
+    """Leases of ``connection`` that hold ``semaphore`` until their scope
+    closes, and a borrower that holds it for one statement.
+
+    SQLite can keep a transaction open after ``COMMIT`` fails (a deferred
+    foreign key violation), so ``on_commit_failure`` rolls it back. If that
+    fails too, the connection is rejected until a ``ROLLBACK`` retried on
+    each later acquisition succeeds. Without ``is_transaction``,
+    ``ROLLBACK`` always runs and "no transaction is active" counts as
+    clean."""
+    require_effect(connection, "connection")
+    poisoned: list[SqlError] = []
+
+    def poison(cause: Cause[SqlError]) -> SqlError:
+        error = SqlError(
+            reason=ConnectionError(
+                message="SQLite connection cannot be reused after failed COMMIT cleanup",
+                operation="rollback",
+                cause=cause,
+            )
+        )
+        poisoned[:] = [error]
+        return error
+
+    def rollback(conn: C) -> Effect[None, SqlError]:
+        if is_transaction is not None:
+            if is_transaction(conn):
+                return conn.execute_unprepared("ROLLBACK", [], None).as_void()
+            return _Succeed(None)
+        return (
+            conn.execute_unprepared("ROLLBACK", [], None)
+            .as_void()
+            .catch_if(_is_no_transaction_error, lambda _: _Succeed(None))
+        )
+
+    def check(conn: C) -> Effect[C, SqlError]:
+        if not poisoned:
+            return _Succeed(conn)
+
+        def recovered(_: object) -> Effect[C]:
+            poisoned.clear()
+            return _Succeed(conn)
+
+        return _MatchCause(rollback(conn), lambda c: _FailCause(fail_cause(poison(c))), recovered)
+
+    available = connection.flat_map(check)
+
+    def lease_body(fiber: Any) -> Effect[C, SqlError, Scope]:
+        scope: CloseableScope = fiber._context.get_unsafe(Scope)
+        return uninterruptible_mask(
+            lambda restore: (
+                restore(semaphore.take(1))
+                .and_then(scope.add_finalizer(lambda _: semaphore.release(1)))
+                .and_then(available)
+            )
+        )
+
+    lease: Effect[C, SqlError, Scope] = _WithFiber(lease_body)
+
+    def borrow[A, E, R](f: Callable[[Connection], Effect[A, E, R]]) -> Effect[A, E | SqlError, R]:
+        return semaphore.with_permits(available.flat_map(f))
+
+    def on_commit_failure(conn: Connection) -> Effect[None, SqlError]:
+        conn_c: Any = conn
+        return rollback(conn_c).tap_cause(lambda cause: _Sync(lambda: poison(cause)))
+
+    def is_open(conn: Connection) -> bool:
+        conn_c: Any = conn
+        return is_transaction is not None and is_transaction(conn_c)
+
+    return SqliteAcquirers(
+        acquirer=lease,
+        borrower=borrow,
+        transaction_acquirer=lease,
+        on_commit_failure=on_commit_failure,
+        is_transaction=None if is_transaction is None else is_open,
+    )
+
+
+__all__ = ["SqliteAcquirers", "make_sqlite_acquirers"]