SQLAlchemy 2.1.0rc1__cp315-cp315-win_arm64.whl

sqlalchemy/dialects/sqlite/aiosqlite.py

@@ -0,0 +1,375 @@
+# dialects/sqlite/aiosqlite.py
+# Copyright (C) 2005-2026 the SQLAlchemy authors and contributors
+# <see AUTHORS file>
+#
+# This module is part of SQLAlchemy and is released under
+# the MIT License: https://www.opensource.org/licenses/mit-license.php
+
+
+r"""
+
+.. dialect:: sqlite+aiosqlite
+    :name: aiosqlite
+    :dbapi: aiosqlite
+    :connectstring: sqlite+aiosqlite:///file_path
+    :url: https://pypi.org/project/aiosqlite/
+
+The aiosqlite dialect provides support for the SQLAlchemy asyncio interface
+running on top of pysqlite.
+
+aiosqlite is a wrapper around pysqlite that uses a background thread for
+each connection.   It does not actually use non-blocking IO, as SQLite
+databases are not socket-based.  However it does provide a working asyncio
+interface that's useful for testing and prototyping purposes.
+
+Using a special asyncio mediation layer, the aiosqlite dialect is usable
+as the backend for the :ref:`SQLAlchemy asyncio <asyncio_toplevel>`
+extension package.
+
+This dialect should normally be used only with the
+:func:`_asyncio.create_async_engine` engine creation function::
+
+    from sqlalchemy.ext.asyncio import create_async_engine
+
+    engine = create_async_engine("sqlite+aiosqlite:///filename")
+
+The URL passes through all arguments to the ``pysqlite`` driver, so all
+connection arguments are the same as they are for that of :ref:`pysqlite`.
+
+.. _aiosqlite_udfs:
+
+User-Defined Functions
+----------------------
+
+aiosqlite extends pysqlite to support async, so we can create our own user-defined functions (UDFs)
+in Python and use them directly in SQLite queries as described here: :ref:`pysqlite_udfs`.
+
+.. _aiosqlite_serializable:
+
+Serializable isolation / Savepoints / Transactional DDL (asyncio version)
+-------------------------------------------------------------------------
+
+A newly revised version of this important section is now available
+at the top level of the SQLAlchemy SQLite documentation, in the section
+:ref:`sqlite_transactions`.
+
+
+.. _aiosqlite_pooling:
+
+Pooling Behavior
+----------------
+
+The SQLAlchemy ``aiosqlite`` DBAPI establishes the connection pool differently
+based on the kind of SQLite database that's requested:
+
+* When a ``:memory:`` SQLite database is specified, the dialect by default
+  will use :class:`.StaticPool`. This pool maintains a single
+  connection, so that all access to the engine
+  use the same ``:memory:`` database.
+* When a file-based database is specified, the dialect will use
+  :class:`.AsyncAdaptedQueuePool` as the source of connections.
+
+  .. versionchanged:: 2.0.38
+
+    SQLite file database engines now use :class:`.AsyncAdaptedQueuePool` by default.
+    Previously, :class:`.NullPool` were used.  The :class:`.NullPool` class
+    may be used by specifying it via the
+    :paramref:`_sa.create_engine.poolclass` parameter.
+
+As with the pysqlite dialect, this selection is made based on the database
+name alone, and the ``mode=memory`` query string argument is deprecated as
+a means of influencing it; see :ref:`pysqlite_threading_pooling` for
+background.
+
+.. _aiosqlite_memory:
+
+Using a Memory Database with Multiple Coroutines
+-------------------------------------------------
+
+The default :class:`.StaticPool` used for ``:memory:`` databases forces all
+coroutines to share a single DBAPI connection.  Because SQLite maintains only
+one transaction state per connection, concurrent coroutines can interfere
+with each other — a ``ROLLBACK`` in one coroutine will also discard
+uncommitted work from any other coroutine using the same engine.
+
+For async workloads where multiple :class:`.AsyncSession` or
+:class:`.AsyncConnection` objects may be active simultaneously, use SQLite's
+shared-cache URI mode instead.  This gives each checkout its own DBAPI
+connection with independent transaction state while still sharing one
+in-memory database::
+
+    engine = create_async_engine(
+        "sqlite+aiosqlite:///file::memory:?cache=shared&uri=true"
+    )
+
+Because this URL form is treated as a file-based database by the dialect,
+:class:`.AsyncAdaptedQueuePool` is used automatically and no additional
+configuration is needed.
+
+Note that a shared-cache database is discarded once its last connection is
+closed, so that operations such as :meth:`_asyncio.AsyncEngine.dispose` or
+the use of :paramref:`_sa.create_engine.pool_recycle` will destroy its
+contents; see :ref:`pysqlite_shared_cache_lifespan` for background and for
+how to hold such a database open.
+
+See the pysqlite documentation at
+:ref:`pysqlite_uri_shared_cache` for full details on shared-cache memory
+databases, including how to use named databases to maintain multiple
+independent in-memory databases within the same process.
+
+"""  # noqa
+
+from __future__ import annotations
+
+import asyncio
+from functools import partial
+from threading import Thread
+from types import ModuleType
+from typing import Any
+from typing import cast
+from typing import NoReturn
+from typing import Optional
+from typing import TYPE_CHECKING
+from typing import Union
+
+from .base import SQLiteExecutionContext
+from .pysqlite import SQLiteDialect_pysqlite
+from ... import pool
+from ... import util
+from ...connectors.asyncio import AsyncAdapt_dbapi_connection
+from ...connectors.asyncio import AsyncAdapt_dbapi_cursor
+from ...connectors.asyncio import AsyncAdapt_dbapi_module
+from ...connectors.asyncio import AsyncAdapt_dbapi_ss_cursor
+from ...connectors.asyncio import AsyncAdapt_terminate
+from ...util.concurrency import await_
+
+if TYPE_CHECKING:
+    from ...connectors.asyncio import AsyncIODBAPIConnection
+    from ...engine.interfaces import DBAPIConnection
+    from ...engine.interfaces import DBAPICursor
+    from ...engine.interfaces import DBAPIModule
+    from ...engine.url import URL
+    from ...pool.base import PoolProxiedConnection
+
+
+class AsyncAdapt_aiosqlite_cursor(AsyncAdapt_dbapi_cursor):
+    __slots__ = ()
+
+
+class AsyncAdapt_aiosqlite_ss_cursor(AsyncAdapt_dbapi_ss_cursor):
+    __slots__ = ()
+
+
+class AsyncAdapt_aiosqlite_connection(
+    AsyncAdapt_terminate, AsyncAdapt_dbapi_connection
+):
+    __slots__ = ()
+
+    _cursor_cls = AsyncAdapt_aiosqlite_cursor
+    _ss_cursor_cls = AsyncAdapt_aiosqlite_ss_cursor
+
+    @property
+    def isolation_level(self) -> Optional[str]:
+        return cast(str, self._connection.isolation_level)
+
+    @isolation_level.setter
+    def isolation_level(self, value: Optional[str]) -> None:
+        # aiosqlite's isolation_level setter works outside the Thread
+        # that it's supposed to, necessitating setting check_same_thread=False.
+        # for improved stability, we instead invent our own awaitable version
+        # using aiosqlite's async queue directly.
+
+        def set_iso(
+            connection: AsyncAdapt_aiosqlite_connection, value: Optional[str]
+        ) -> None:
+            connection.isolation_level = value
+
+        function = partial(set_iso, self._connection._conn, value)
+        future = asyncio.get_event_loop().create_future()
+
+        self._connection._tx.put_nowait((future, function))
+
+        try:
+            await_(future)
+        except Exception as error:
+            self._handle_exception(error)
+
+    def create_function(self, *args: Any, **kw: Any) -> None:
+        try:
+            await_(self._connection.create_function(*args, **kw))
+        except Exception as error:
+            self._handle_exception(error)
+
+    def rollback(self) -> None:
+        if self._connection._connection:
+            super().rollback()
+
+    def commit(self) -> None:
+        if self._connection._connection:
+            super().commit()
+
+    def close(self) -> None:
+        try:
+            await_(self._connection.close())
+        except ValueError:
+            # this is undocumented for aiosqlite, that ValueError
+            # was raised if .close() was called more than once, which is
+            # both not customary for DBAPI and is also not a DBAPI.Error
+            # exception. This is now fixed in aiosqlite via my PR
+            # https://github.com/omnilib/aiosqlite/pull/238, so we can be
+            # assured this will not become some other kind of exception,
+            # since it doesn't raise anymore.
+
+            pass
+        except Exception as error:
+            self._handle_exception(error)
+
+    @classmethod
+    def _handle_exception_no_connection(
+        cls, dbapi: Any, error: Exception
+    ) -> NoReturn:
+        if isinstance(error, ValueError) and error.args[0].lower() in (
+            "no active connection",
+            "connection closed",
+        ):
+            raise dbapi.sqlite.OperationalError(error.args[0]) from error
+        else:
+            super()._handle_exception_no_connection(dbapi, error)
+
+    async def _terminate_graceful_close(self) -> None:
+        """Try to close connection gracefully"""
+        await self._connection.close()
+
+    def _terminate_force_close(self) -> None:
+        """Terminate the connection"""
+
+        # this was added in aiosqlite 0.22.1.  if stop() is not present,
+        # the dialect should indicate has_terminate=False
+        try:
+            meth = self._connection.stop
+        except AttributeError as ae:
+            raise NotImplementedError(
+                "terminate_force_close() not implemented by this DBAPI shim"
+            ) from ae
+        else:
+            meth()
+
+
+class AsyncAdapt_aiosqlite_dbapi(AsyncAdapt_dbapi_module):
+    def __init__(self, aiosqlite: ModuleType, sqlite: ModuleType):
+        super().__init__(aiosqlite, dbapi_module=sqlite)
+        self.aiosqlite = aiosqlite
+        self.sqlite = sqlite
+        self.paramstyle = "qmark"
+        self.has_stop = hasattr(aiosqlite.Connection, "stop")
+        self._init_dbapi_attributes()
+
+    def _init_dbapi_attributes(self) -> None:
+        for name in (
+            "DatabaseError",
+            "Error",
+            "IntegrityError",
+            "NotSupportedError",
+            "OperationalError",
+            "ProgrammingError",
+            "sqlite_version",
+            "sqlite_version_info",
+        ):
+            setattr(self, name, getattr(self.aiosqlite, name))
+
+        for name in ("PARSE_COLNAMES", "PARSE_DECLTYPES"):
+            setattr(self, name, getattr(self.sqlite, name))
+
+        for name in ("Binary",):
+            setattr(self, name, getattr(self.sqlite, name))
+
+    def connect(self, *arg: Any, **kw: Any) -> AsyncAdapt_aiosqlite_connection:
+        creator_fn = kw.pop("async_creator_fn", None)
+        if creator_fn:
+            connection = creator_fn(*arg, **kw)
+        else:
+            connection = self.aiosqlite.connect(*arg, **kw)
+
+            # aiosqlite uses a Thread.   you'll thank us later
+            if isinstance(connection, Thread):
+                # Connection itself was a thread in version prior to 0.22
+                connection.daemon = True
+            else:
+                # in 0.22+ instead it contains a thread.
+                connection._thread.daemon = True
+
+        return AsyncAdapt_aiosqlite_connection(self, await_(connection))
+
+
+class SQLiteExecutionContext_aiosqlite(SQLiteExecutionContext):
+    def create_server_side_cursor(self) -> DBAPICursor:
+        return self._dbapi_connection.cursor(server_side=True)
+
+
+class SQLiteDialect_aiosqlite(SQLiteDialect_pysqlite):
+    driver = "aiosqlite"
+    supports_statement_cache = True
+
+    is_async = True
+    has_terminate = True
+
+    supports_server_side_cursors = True
+
+    execution_ctx_cls = SQLiteExecutionContext_aiosqlite
+
+    def __init__(self, **kwargs: Any):
+        super().__init__(**kwargs)
+        if self.dbapi and not self.dbapi.has_stop:
+            self.has_terminate = False
+
+    @classmethod
+    def import_dbapi(cls) -> AsyncAdapt_aiosqlite_dbapi:
+        return AsyncAdapt_aiosqlite_dbapi(
+            __import__("aiosqlite"), __import__("sqlite3")
+        )
+
+    def retrieve_dbapi_version(self, dbapi: DBAPIModule) -> util.VersionInfo:
+        # the version of aiosqlite, rather than the Python version
+        # reported by the pysqlite dialect
+        aiosqlite = getattr(dbapi, "aiosqlite", None)
+        return util.parse_version_string(
+            getattr(aiosqlite, "__version__", None)
+        )
+
+    @classmethod
+    def get_pool_class(cls, url: URL) -> type[pool.Pool]:
+        if cls._is_url_file_db(url):
+            return pool.AsyncAdaptedQueuePool
+        else:
+            cls._warn_memory_mode_pool_selection(
+                url, pool.StaticPool, pool.AsyncAdaptedQueuePool
+            )
+            return pool.StaticPool
+
+    def is_disconnect(
+        self,
+        e: DBAPIModule.Error,
+        connection: Optional[Union[PoolProxiedConnection, DBAPIConnection]],
+        cursor: Optional[DBAPICursor],
+    ) -> bool:
+        self.dbapi = cast("DBAPIModule", self.dbapi)
+        if isinstance(e, self.dbapi.OperationalError):
+            err_lower = str(e).lower()
+            if (
+                "no active connection" in err_lower
+                or "connection closed" in err_lower
+            ):
+                return True
+
+        return super().is_disconnect(e, connection, cursor)
+
+    def get_driver_connection(
+        self, connection: DBAPIConnection
+    ) -> AsyncIODBAPIConnection:
+        return connection._connection  # type: ignore[no-any-return]
+
+    def do_terminate(self, dbapi_connection: DBAPIConnection) -> None:
+        dbapi_connection.terminate()
+
+
+dialect = SQLiteDialect_aiosqlite