sqlalchemy-dqlite 0.1.0__tar.gz → 0.1.2__tar.gz

{sqlalchemy_dqlite-0.1.0 → sqlalchemy_dqlite-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlalchemy-dqlite
-Version: 0.1.0
+Version: 0.1.2
 Summary: SQLAlchemy 2.0 dialect for dqlite distributed SQLite
 Project-URL: Homepage, https://github.com/antoineleclair/sqlalchemy-dqlite
 Project-URL: Repository, https://github.com/antoineleclair/sqlalchemy-dqlite

{sqlalchemy_dqlite-0.1.0 → sqlalchemy_dqlite-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sqlalchemy-dqlite"
-version = "0.1.0"
+version = "0.1.2"
 description = "SQLAlchemy 2.0 dialect for dqlite distributed SQLite"
 readme = "README.md"
 requires-python = ">=3.13"

{sqlalchemy_dqlite-0.1.0 → sqlalchemy_dqlite-0.1.2}/src/sqlalchemydqlite/__init__.py

@@ -4,4 +4,4 @@ from sqlalchemydqlite.base import DqliteDialect
 
 __all__ = ["DqliteDialect"]
 
-__version__ = "0.1.0"
+__version__ = "0.1.2"

sqlalchemy_dqlite-0.1.2/src/sqlalchemydqlite/aio.py

@@ -0,0 +1,199 @@
+"""Async dqlite dialect for SQLAlchemy."""
+
+from collections import deque
+from collections.abc import Sequence
+from typing import Any
+
+from sqlalchemy import pool
+from sqlalchemy.engine import URL, AdaptedConnection
+from sqlalchemy.engine.interfaces import DBAPIConnection
+from sqlalchemy.pool import AsyncAdaptedQueuePool
+from sqlalchemy.util import await_only
+
+from sqlalchemydqlite.base import DqliteDialect
+
+
+class AsyncAdaptedCursor:
+    """Adapts an AsyncCursor for SQLAlchemy's greenlet-based async engine.
+
+    Eagerly fetches all rows during execute() within the greenlet context,
+    then serves fetch* calls synchronously from the buffer. This matches
+    the pattern used by SQLAlchemy's aiosqlite dialect.
+    """
+
+    server_side = False
+
+    def __init__(self, adapt_connection: "AsyncAdaptedConnection") -> None:
+        self._adapt_connection = adapt_connection
+        self._connection = adapt_connection._connection
+        self.description: Any = None
+        self.rowcount: int = -1
+        self.lastrowid: int | None = None
+        self.arraysize: int = 1
+        self._rows: deque[Any] = deque()
+
+    async def _async_soft_close(self) -> None:
+        return
+
+    def close(self) -> None:
+        self._rows.clear()
+
+    def execute(self, operation: str, parameters: Any = None) -> Any:
+        cursor = self._connection.cursor()
+        if parameters is not None:
+            await_only(cursor.execute(operation, parameters))
+        else:
+            await_only(cursor.execute(operation))
+
+        if cursor.description:
+            self.description = cursor.description
+            self.lastrowid = self.rowcount = -1
+            self._rows = deque(await_only(cursor.fetchall()))
+        else:
+            self.description = None
+            self.lastrowid = cursor.lastrowid
+            self.rowcount = cursor.rowcount
+
+        await_only(cursor.close())
+
+    def executemany(self, operation: str, seq_of_parameters: Any) -> Any:
+        cursor = self._connection.cursor()
+        await_only(cursor.executemany(operation, seq_of_parameters))
+        self.description = None
+        self.lastrowid = cursor.lastrowid
+        self.rowcount = cursor.rowcount
+        await_only(cursor.close())
+
+    def fetchone(self) -> Any:
+        if self._rows:
+            return self._rows.popleft()
+        return None
+
+    def fetchmany(self, size: int | None = None) -> Sequence[Any]:
+        if size is None:
+            size = self.arraysize
+        return [self._rows.popleft() for _ in range(min(size, len(self._rows)))]
+
+    def fetchall(self) -> Sequence[Any]:
+        retval = list(self._rows)
+        self._rows.clear()
+        return retval
+
+    def setinputsizes(self, *inputsizes: Any) -> None:
+        pass
+
+    def setoutputsize(self, size: int, column: int | None = None) -> None:
+        pass
+
+    def __iter__(self) -> Any:
+        while self._rows:
+            yield self._rows.popleft()
+
+    def __next__(self) -> Any:
+        row = self.fetchone()
+        if row is None:
+            raise StopIteration
+        return row
+
+
+class AsyncAdaptedConnection(AdaptedConnection):
+    """Adapts an AsyncConnection for SQLAlchemy's greenlet-based async engine.
+
+    Provides sync-looking methods that internally use await_only() to
+    bridge to the underlying async connection within SQLAlchemy's
+    greenlet context.
+    """
+
+    def __init__(self, connection: Any) -> None:
+        self._connection = connection
+
+    def cursor(self) -> AsyncAdaptedCursor:
+        return AsyncAdaptedCursor(self)
+
+    def commit(self) -> None:
+        await_only(self._connection.commit())
+
+    def rollback(self) -> None:
+        await_only(self._connection.rollback())
+
+    def close(self) -> None:
+        await_only(self._connection.close())
+
+
+class DqliteDialect_aio(DqliteDialect):  # noqa: N801
+    """Async SQLAlchemy dialect for dqlite.
+
+    Use with SQLAlchemy's async engine:
+        create_async_engine("dqlite+aio://host:port/database")
+    """
+
+    driver = "dqlitedbapi_aio"
+    is_async = True
+    supports_statement_cache = True
+
+    @classmethod
+    def get_pool_class(cls, url: URL) -> type[pool.Pool]:
+        return AsyncAdaptedQueuePool
+
+    @classmethod
+    def import_dbapi(cls) -> Any:
+        from dqlitedbapi import aio
+
+        return aio
+
+    def connect(self, *cargs: Any, **cparams: Any) -> Any:
+        """Create and wrap an async connection."""
+        raw_conn = self.loaded_dbapi.connect(*cargs, **cparams)
+        return AsyncAdaptedConnection(raw_conn)
+
+    def create_connect_args(self, url: URL) -> tuple[list[Any], dict[str, Any]]:
+        """Create connection arguments from URL.
+
+        URL format: dqlite+aio://host:port/database
+        """
+        host = url.host or "localhost"
+        port = url.port or 9001
+        database = url.database or "default"
+
+        address = f"{host}:{port}"
+
+        return [], {
+            "address": address,
+            "database": database,
+        }
+
+    def do_rollback(self, dbapi_connection: DBAPIConnection) -> None:
+        """Rollback the current transaction."""
+        try:
+            dbapi_connection.rollback()
+        except Exception as e:
+            if "no transaction is active" not in str(e):
+                raise
+
+    def do_commit(self, dbapi_connection: DBAPIConnection) -> None:
+        """Commit the current transaction."""
+        try:
+            dbapi_connection.commit()
+        except Exception as e:
+            if "no transaction is active" not in str(e):
+                raise
+
+    def _get_server_version_info(self, connection: Any) -> tuple[int, ...]:
+        """Return the server version as a tuple."""
+        cursor = connection.connection.dbapi_connection.cursor()
+        cursor.execute("SELECT sqlite_version()")
+        row = cursor.fetchone()
+        cursor.close()
+
+        if row:
+            version_str = row[0]
+            return tuple(int(x) for x in version_str.split("."))
+        return (3, 0, 0)
+
+    def get_driver_connection(self, connection: Any) -> Any:
+        """Return the driver-level connection."""
+        return connection
+
+
+# Register the dialect
+dialect = DqliteDialect_aio

sqlalchemy_dqlite-0.1.2/tests/integration/test_async_context.py

@@ -0,0 +1,28 @@
+"""Integration tests for sync engine used inside an async context."""
+
+import asyncio
+
+import pytest
+from sqlalchemy import create_engine, text
+
+
+@pytest.mark.integration
+class TestSyncEngineInAsyncContext:
+    def test_sync_engine_inside_running_loop(self, engine_url: str) -> None:
+        """Sync engine must work when called from inside a running event loop.
+
+        This simulates the scenario where a sync SQLAlchemy engine is used
+        during app startup inside an async server like uvicorn.
+        """
+
+        async def _run_inside_loop() -> str:
+            engine = create_engine(engine_url)
+            with engine.connect() as conn:
+                result = conn.execute(text("SELECT 'ok'"))
+                row = result.fetchone()
+            engine.dispose()
+            assert row is not None
+            return str(row[0])
+
+        result = asyncio.run(_run_inside_loop())
+        assert result == "ok"

{sqlalchemy_dqlite-0.1.0 → sqlalchemy_dqlite-0.1.2}/tests/test_dialect.py

@@ -58,6 +58,25 @@ class TestDqliteDialectAio:
         dbapi = DqliteDialect_aio.import_dbapi()
         assert hasattr(dbapi, "aconnect")
 
+    def test_import_dbapi_has_paramstyle(self) -> None:
+        """Async dbapi module must expose paramstyle for SQLAlchemy dialect init."""
+        dbapi = DqliteDialect_aio.import_dbapi()
+        assert dbapi.paramstyle == "qmark"
+
+    def test_import_dbapi_has_module_attributes(self) -> None:
+        """Async dbapi module must expose PEP 249 attributes for SQLAlchemy."""
+        dbapi = DqliteDialect_aio.import_dbapi()
+        assert dbapi.apilevel == "2.0"
+        assert dbapi.threadsafety == 1
+
+    def test_create_async_engine(self) -> None:
+        """create_async_engine must not raise during dialect initialization."""
+        from sqlalchemy.ext.asyncio import create_async_engine
+
+        engine = create_async_engine("dqlite+aio://localhost:19001/test")
+        assert engine.dialect.name == "dqlite"
+        assert engine.dialect.driver == "dqlitedbapi_aio"
+
 
 class TestURLParsing:
     def test_parse_basic_url(self) -> None:

sqlalchemy_dqlite-0.1.0/src/sqlalchemydqlite/aio.py

@@ -1,57 +0,0 @@
-"""Async dqlite dialect for SQLAlchemy."""
-
-from typing import Any
-
-from sqlalchemy import pool
-from sqlalchemy.dialects.sqlite.base import SQLiteDialect
-from sqlalchemy.engine import URL
-from sqlalchemy.pool import AsyncAdaptedQueuePool
-
-
-class DqliteDialect_aio(SQLiteDialect):  # noqa: N801
-    """Async SQLAlchemy dialect for dqlite.
-
-    Use with SQLAlchemy's async engine:
-        create_async_engine("dqlite+aio://host:port/database")
-    """
-
-    name = "dqlite"
-    driver = "dqlitedbapi_aio"
-    is_async = True
-
-    # dqlite uses qmark parameter style
-    paramstyle = "qmark"
-
-    @classmethod
-    def get_pool_class(cls, url: URL) -> type[pool.Pool]:
-        return AsyncAdaptedQueuePool
-
-    @classmethod
-    def import_dbapi(cls) -> Any:
-        from dqlitedbapi import aio
-
-        return aio
-
-    def create_connect_args(self, url: URL) -> tuple[list[Any], dict[str, Any]]:
-        """Create connection arguments from URL.
-
-        URL format: dqlite+aio://host:port/database
-        """
-        host = url.host or "localhost"
-        port = url.port or 9001
-        database = url.database or "default"
-
-        address = f"{host}:{port}"
-
-        return [], {
-            "address": address,
-            "database": database,
-        }
-
-    def get_driver_connection(self, connection: Any) -> Any:
-        """Return the driver-level connection."""
-        return connection
-
-
-# Register the dialect
-dialect = DqliteDialect_aio