dqlite-dbapi 0.1.0__py3-none-any.whl

dqlite_dbapi-0.1.0.dist-info/METADATA

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: dqlite-dbapi
+Version: 0.1.0
+Summary: PEP 249 (DB-API 2.0) compliant interface for dqlite
+Project-URL: Homepage, https://github.com/letsdiscodev/python-dqlite-dbapi
+Project-URL: Repository, https://github.com/letsdiscodev/python-dqlite-dbapi
+Project-URL: Issues, https://github.com/letsdiscodev/python-dqlite-dbapi/issues
+Author-email: Antoine Leclair <antoineleclair@gmail.com>
+License-Expression: MIT
+License-File: LICENSE.md
+Keywords: database,dbapi,distributed,dqlite,pep249,sqlite
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Classifier: Topic :: Database :: Database Engines/Servers
+Classifier: Topic :: Database :: Front-Ends
+Classifier: Typing :: Typed
+Requires-Python: >=3.13
+Requires-Dist: dqlite-client>=0.1.0
+Provides-Extra: dev
+Requires-Dist: mypy>=1.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# dqlite-dbapi
+
+PEP 249 compliant interface for [dqlite](https://dqlite.io/).
+
+## Installation
+
+```bash
+pip install dqlite-dbapi
+```
+
+## Sync Usage
+
+```python
+import dqlitedbapi
+
+conn = dqlitedbapi.connect("localhost:9001")
+cursor = conn.cursor()
+cursor.execute("SELECT 1")
+print(cursor.fetchone())
+conn.close()
+```
+
+## Async Usage
+
+```python
+import asyncio
+from dqlitedbapi.aio import aconnect
+
+async def main():
+    conn = await aconnect("localhost:9001")
+    cursor = await conn.cursor()
+    await cursor.execute("SELECT 1")
+    print(await cursor.fetchone())
+    await conn.close()
+
+asyncio.run(main())
+```
+
+## PEP 249 Compliance
+
+- `apilevel = "2.0"`
+- `threadsafety = 1`
+- `paramstyle = "qmark"`
+
+## Development
+
+See [DEVELOPMENT.md](DEVELOPMENT.md) for setup and contribution guidelines.
+
+## License
+
+MIT

dqlite_dbapi-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+dqlitedbapi/__init__.py,sha256=mCP0ru8Xlor99Bxo7q_QUPWXuzy896Awx4ih0rKzB10,1955
+dqlitedbapi/connection.py,sha256=I_zTYxiuem-dX5DQhC0Fl1rQ9Hu9kcFef9DniKeAOi4,3515
+dqlitedbapi/cursor.py,sha256=AZALE886OfthknwsiG8agCaAWw8tPvd7wz6OELYimrw,5913
+dqlitedbapi/exceptions.py,sha256=u5y1xcDJudLKUdCFr-ZHBFk5QsJasRBZ8E6lBGTubTg,1016
+dqlitedbapi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dqlitedbapi/types.py,sha256=_8ZUOl0rWWxRGepOt7X7kfXgXxtrEA_fCPNIohY_dIY,2008
+dqlitedbapi/aio/__init__.py,sha256=UKkGUzN4ALSYEyHyNF7htxu_WPLcI12_NoLMpoUaadM,722
+dqlitedbapi/aio/connection.py,sha256=bJ3Nrk3ejk7bTZmqF_LkoS3b4EyO8myXpsYJW4sb3m8,2565
+dqlitedbapi/aio/cursor.py,sha256=N-8gsgrXAYoiEKLGurZJ1GpEO5fuMx7AJ7_BLPMYdoE,5131
+dqlite_dbapi-0.1.0.dist-info/METADATA,sha256=2PI3TjJriA2Obo8519fYKdnGLwTn-LONstwKFKUtPwU,2115
+dqlite_dbapi-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+dqlite_dbapi-0.1.0.dist-info/licenses/LICENSE.md,sha256=25ur0qy0m17OgHzc1Ve3NeLumyjGGgVBrN-JL3znfDg,1090
+dqlite_dbapi-0.1.0.dist-info/RECORD,,

dqlite_dbapi-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

dqlite_dbapi-0.1.0.dist-info/licenses/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Antoine Leclair and Greg Sadetsky
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dqlitedbapi/__init__.py

@@ -0,0 +1,98 @@
+"""PEP 249 compliant interface for dqlite."""
+
+from dqlitedbapi.connection import Connection
+from dqlitedbapi.cursor import Cursor
+from dqlitedbapi.exceptions import (
+    DatabaseError,
+    DataError,
+    Error,
+    IntegrityError,
+    InterfaceError,
+    InternalError,
+    NotSupportedError,
+    OperationalError,
+    ProgrammingError,
+    Warning,
+)
+from dqlitedbapi.types import (
+    BINARY,
+    DATETIME,
+    NUMBER,
+    ROWID,
+    STRING,
+    Binary,
+    Date,
+    DateFromTicks,
+    Time,
+    TimeFromTicks,
+    Timestamp,
+    TimestampFromTicks,
+)
+
+# PEP 249 module-level attributes
+apilevel = "2.0"
+threadsafety = 1  # Threads may share the module, but not connections
+paramstyle = "qmark"  # Question mark style: WHERE name=?
+
+# SQLite compatibility attributes (for SQLAlchemy)
+# dqlite uses SQLite 3.x internally
+sqlite_version_info = (3, 35, 0)
+sqlite_version = "3.35.0"
+
+__all__ = [
+    # Module attributes
+    "apilevel",
+    "threadsafety",
+    "paramstyle",
+    # Functions
+    "connect",
+    # Classes
+    "Connection",
+    "Cursor",
+    # Exceptions
+    "Warning",
+    "Error",
+    "InterfaceError",
+    "DatabaseError",
+    "DataError",
+    "OperationalError",
+    "IntegrityError",
+    "InternalError",
+    "ProgrammingError",
+    "NotSupportedError",
+    # Type constructors
+    "Date",
+    "Time",
+    "Timestamp",
+    "DateFromTicks",
+    "TimeFromTicks",
+    "TimestampFromTicks",
+    "Binary",
+    # Type objects
+    "STRING",
+    "BINARY",
+    "NUMBER",
+    "DATETIME",
+    "ROWID",
+]
+
+__version__ = "0.1.0"
+
+
+def connect(
+    address: str,
+    *,
+    database: str = "default",
+    timeout: float = 10.0,
+) -> Connection:
+    """Connect to a dqlite database.
+
+    Args:
+        address: Node address in "host:port" format
+        database: Database name to open
+        timeout: Connection timeout in seconds
+
+    Returns:
+        A Connection object
+    """
+    return Connection(address, database=database, timeout=timeout)

dqlitedbapi/aio/__init__.py

@@ -0,0 +1,31 @@
+"""Async PEP 249-style interface for dqlite."""
+
+from dqlitedbapi.aio.connection import AsyncConnection
+from dqlitedbapi.aio.cursor import AsyncCursor
+
+__all__ = [
+    "aconnect",
+    "AsyncConnection",
+    "AsyncCursor",
+]
+
+
+async def aconnect(
+    address: str,
+    *,
+    database: str = "default",
+    timeout: float = 10.0,
+) -> AsyncConnection:
+    """Connect to a dqlite database asynchronously.
+
+    Args:
+        address: Node address in "host:port" format
+        database: Database name to open
+        timeout: Connection timeout in seconds
+
+    Returns:
+        An AsyncConnection object
+    """
+    conn = AsyncConnection(address, database=database, timeout=timeout)
+    await conn.connect()
+    return conn

dqlitedbapi/aio/connection.py

@@ -0,0 +1,86 @@
+"""Async connection implementation for dqlite."""
+
+from typing import Any
+
+from dqliteclient import DqliteConnection
+from dqlitedbapi.aio.cursor import AsyncCursor
+from dqlitedbapi.exceptions import InterfaceError, OperationalError
+
+
+class AsyncConnection:
+    """Async database connection."""
+
+    def __init__(
+        self,
+        address: str,
+        *,
+        database: str = "default",
+        timeout: float = 10.0,
+    ) -> None:
+        """Initialize connection (does not connect yet).
+
+        Args:
+            address: Node address in "host:port" format
+            database: Database name to open
+            timeout: Connection timeout in seconds
+        """
+        self._address = address
+        self._database = database
+        self._timeout = timeout
+        self._async_conn: DqliteConnection | None = None
+        self._closed = False
+
+    async def connect(self) -> None:
+        """Establish the connection."""
+        if self._closed:
+            raise InterfaceError("Connection is closed")
+
+        if self._async_conn is not None:
+            return
+
+        self._async_conn = DqliteConnection(
+            self._address,
+            database=self._database,
+            timeout=self._timeout,
+        )
+        try:
+            await self._async_conn.connect()
+        except Exception as e:
+            self._async_conn = None
+            raise OperationalError(f"Failed to connect: {e}") from e
+
+    async def close(self) -> None:
+        """Close the connection."""
+        if self._async_conn is not None:
+            await self._async_conn.close()
+            self._async_conn = None
+        self._closed = True
+
+    async def commit(self) -> None:
+        """Commit any pending transaction."""
+        if self._closed:
+            raise InterfaceError("Connection is closed")
+
+        if self._async_conn is not None:
+            await self._async_conn.execute("COMMIT")
+
+    async def rollback(self) -> None:
+        """Roll back any pending transaction."""
+        if self._closed:
+            raise InterfaceError("Connection is closed")
+
+        if self._async_conn is not None:
+            await self._async_conn.execute("ROLLBACK")
+
+    async def cursor(self) -> AsyncCursor:
+        """Return a new AsyncCursor object."""
+        if self._closed:
+            raise InterfaceError("Connection is closed")
+        return AsyncCursor(self)
+
+    async def __aenter__(self) -> "AsyncConnection":
+        await self.connect()
+        return self
+
+    async def __aexit__(self, *args: Any) -> None:
+        await self.close()

dqlitedbapi/aio/cursor.py

@@ -0,0 +1,163 @@
+"""Async cursor implementation for dqlite."""
+
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, Any
+
+from dqlitedbapi.exceptions import InterfaceError
+
+if TYPE_CHECKING:
+    from dqlitedbapi.aio.connection import AsyncConnection
+
+
+class AsyncCursor:
+    """Async database cursor."""
+
+    def __init__(self, connection: "AsyncConnection") -> None:
+        self._connection = connection
+        self._description: list[tuple[str, None, None, None, None, None, None]] | None = None
+        self._rowcount = -1
+        self._arraysize = 1
+        self._rows: list[tuple[Any, ...]] = []
+        self._row_index = 0
+        self._closed = False
+        self._lastrowid: int | None = None
+
+    @property
+    def description(
+        self,
+    ) -> list[tuple[str, None, None, None, None, None, None]] | None:
+        """Column descriptions for the last query."""
+        return self._description
+
+    @property
+    def rowcount(self) -> int:
+        """Number of rows affected by the last execute."""
+        return self._rowcount
+
+    @property
+    def lastrowid(self) -> int | None:
+        """Row ID of the last inserted row."""
+        return self._lastrowid
+
+    @property
+    def arraysize(self) -> int:
+        """Number of rows to fetch at a time with fetchmany()."""
+        return self._arraysize
+
+    @arraysize.setter
+    def arraysize(self, value: int) -> None:
+        self._arraysize = value
+
+    def _check_closed(self) -> None:
+        if self._closed:
+            raise InterfaceError("Cursor is closed")
+
+    async def execute(
+        self, operation: str, parameters: Sequence[Any] | None = None
+    ) -> "AsyncCursor":
+        """Execute a database operation (query or command)."""
+        self._check_closed()
+
+        conn = self._connection._async_conn
+        if conn is None:
+            raise InterfaceError("Connection is not open")
+
+        params = list(parameters) if parameters else None
+
+        # Determine if this is a SELECT query
+        is_query = operation.strip().upper().startswith(("SELECT", "PRAGMA", "EXPLAIN"))
+
+        if is_query:
+            assert conn._protocol is not None and conn._db_id is not None
+            columns, rows = await conn._protocol.query_sql(conn._db_id, operation, params)
+            self._description = [(name, None, None, None, None, None, None) for name in columns]
+            self._rows = [tuple(row) for row in rows]
+            self._row_index = 0
+            self._rowcount = len(rows)
+        else:
+            assert conn._protocol is not None and conn._db_id is not None
+            last_id, affected = await conn._protocol.exec_sql(conn._db_id, operation, params)
+            self._lastrowid = last_id
+            self._rowcount = affected
+            self._description = None
+            self._rows = []
+
+        return self
+
+    async def executemany(
+        self, operation: str, seq_of_parameters: Sequence[Sequence[Any]]
+    ) -> "AsyncCursor":
+        """Execute a database operation multiple times."""
+        self._check_closed()
+
+        total_affected = 0
+        for params in seq_of_parameters:
+            await self.execute(operation, params)
+            if self._rowcount >= 0:
+                total_affected += self._rowcount
+        self._rowcount = total_affected
+        return self
+
+    async def fetchone(self) -> tuple[Any, ...] | None:
+        """Fetch the next row of a query result set."""
+        self._check_closed()
+
+        if not self._rows or self._row_index >= len(self._rows):
+            return None
+
+        row = self._rows[self._row_index]
+        self._row_index += 1
+        return row
+
+    async def fetchmany(self, size: int | None = None) -> list[tuple[Any, ...]]:
+        """Fetch the next set of rows of a query result."""
+        self._check_closed()
+
+        if size is None:
+            size = self._arraysize
+
+        result: list[tuple[Any, ...]] = []
+        for _ in range(size):
+            row = await self.fetchone()
+            if row is None:
+                break
+            result.append(row)
+
+        return result
+
+    async def fetchall(self) -> list[tuple[Any, ...]]:
+        """Fetch all remaining rows of a query result."""
+        self._check_closed()
+
+        result = self._rows[self._row_index :]
+        self._row_index = len(self._rows)
+        return result
+
+    async def close(self) -> None:
+        """Close the cursor."""
+        self._closed = True
+        self._rows = []
+        self._description = None
+
+    def setinputsizes(self, sizes: Sequence[int | None]) -> None:
+        """Set input sizes (no-op for dqlite)."""
+        pass
+
+    def setoutputsize(self, size: int, column: int | None = None) -> None:
+        """Set output size (no-op for dqlite)."""
+        pass
+
+    def __aiter__(self) -> "AsyncCursor":
+        return self
+
+    async def __anext__(self) -> tuple[Any, ...]:
+        row = await self.fetchone()
+        if row is None:
+            raise StopAsyncIteration
+        return row
+
+    async def __aenter__(self) -> "AsyncCursor":
+        return self
+
+    async def __aexit__(self, *args: Any) -> None:
+        await self.close()

dqlitedbapi/connection.py

@@ -0,0 +1,110 @@
+"""PEP 249 Connection implementation for dqlite."""
+
+import asyncio
+from typing import Any
+
+from dqliteclient import DqliteConnection
+from dqlitedbapi.cursor import Cursor
+from dqlitedbapi.exceptions import InterfaceError, OperationalError
+
+
+class Connection:
+    """PEP 249 compliant database connection."""
+
+    def __init__(
+        self,
+        address: str,
+        *,
+        database: str = "default",
+        timeout: float = 10.0,
+    ) -> None:
+        """Initialize connection (does not connect yet).
+
+        Args:
+            address: Node address in "host:port" format
+            database: Database name to open
+            timeout: Connection timeout in seconds
+        """
+        self._address = address
+        self._database = database
+        self._timeout = timeout
+        self._async_conn: DqliteConnection | None = None
+        self._closed = False
+        self._loop: asyncio.AbstractEventLoop | None = None
+
+    def _get_loop(self) -> asyncio.AbstractEventLoop:
+        if self._loop is None:
+            try:
+                self._loop = asyncio.get_running_loop()
+            except RuntimeError:
+                # No running loop, create a new one
+                self._loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(self._loop)
+        return self._loop
+
+    async def _get_async_connection(self) -> DqliteConnection:
+        """Get or create the underlying async connection."""
+        if self._closed:
+            raise InterfaceError("Connection is closed")
+
+        if self._async_conn is None:
+            self._async_conn = DqliteConnection(
+                self._address,
+                database=self._database,
+                timeout=self._timeout,
+            )
+            try:
+                await self._async_conn.connect()
+            except Exception as e:
+                self._async_conn = None
+                raise OperationalError(f"Failed to connect: {e}") from e
+
+        return self._async_conn
+
+    def close(self) -> None:
+        """Close the connection."""
+        if self._async_conn is not None:
+            loop = self._get_loop()
+            loop.run_until_complete(self._async_conn.close())
+            self._async_conn = None
+        self._closed = True
+
+    def commit(self) -> None:
+        """Commit any pending transaction."""
+        if self._closed:
+            raise InterfaceError("Connection is closed")
+
+        if self._async_conn is not None:
+            loop = self._get_loop()
+            loop.run_until_complete(self._commit_async())
+
+    async def _commit_async(self) -> None:
+        """Async implementation of commit."""
+        conn = await self._get_async_connection()
+        await conn.execute("COMMIT")
+
+    def rollback(self) -> None:
+        """Roll back any pending transaction."""
+        if self._closed:
+            raise InterfaceError("Connection is closed")
+
+        if self._async_conn is not None:
+            loop = self._get_loop()
+            loop.run_until_complete(self._rollback_async())
+
+    async def _rollback_async(self) -> None:
+        """Async implementation of rollback."""
+        conn = await self._get_async_connection()
+        await conn.execute("ROLLBACK")
+
+    def cursor(self) -> Cursor:
+        """Return a new Cursor object."""
+        if self._closed:
+            raise InterfaceError("Connection is closed")
+        return Cursor(self)
+
+    def __enter__(self) -> "Connection":
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        self.close()

dqlitedbapi/cursor.py

@@ -0,0 +1,181 @@
+"""PEP 249 Cursor implementation for dqlite."""
+
+import asyncio
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, Any
+
+from dqlitedbapi.exceptions import InterfaceError
+
+if TYPE_CHECKING:
+    from dqlitedbapi.connection import Connection
+
+
+class Cursor:
+    """PEP 249 compliant database cursor."""
+
+    def __init__(self, connection: "Connection") -> None:
+        self._connection = connection
+        self._description: list[tuple[str, None, None, None, None, None, None]] | None = None
+        self._rowcount = -1
+        self._arraysize = 1
+        self._rows: list[tuple[Any, ...]] = []
+        self._row_index = 0
+        self._closed = False
+        self._lastrowid: int | None = None
+
+    @property
+    def description(
+        self,
+    ) -> list[tuple[str, None, None, None, None, None, None]] | None:
+        """Column descriptions for the last query.
+
+        Returns a list of 7-tuples:
+        (name, type_code, display_size, internal_size, precision, scale, null_ok)
+
+        Only name is populated; others are None for compatibility.
+        """
+        return self._description
+
+    @property
+    def rowcount(self) -> int:
+        """Number of rows affected by the last execute.
+
+        Returns -1 if not applicable or unknown.
+        """
+        return self._rowcount
+
+    @property
+    def lastrowid(self) -> int | None:
+        """Row ID of the last inserted row."""
+        return self._lastrowid
+
+    @property
+    def arraysize(self) -> int:
+        """Number of rows to fetch at a time with fetchmany()."""
+        return self._arraysize
+
+    @arraysize.setter
+    def arraysize(self, value: int) -> None:
+        self._arraysize = value
+
+    def _check_closed(self) -> None:
+        if self._closed:
+            raise InterfaceError("Cursor is closed")
+
+    def _get_loop(self) -> asyncio.AbstractEventLoop:
+        # Use the connection's event loop for consistency
+        return self._connection._get_loop()
+
+    def execute(self, operation: str, parameters: Sequence[Any] | None = None) -> "Cursor":
+        """Execute a database operation (query or command)."""
+        self._check_closed()
+
+        loop = self._get_loop()
+        loop.run_until_complete(self._execute_async(operation, parameters))
+        return self
+
+    async def _execute_async(self, operation: str, parameters: Sequence[Any] | None = None) -> None:
+        """Async implementation of execute."""
+        conn = await self._connection._get_async_connection()
+        params = list(parameters) if parameters else None
+
+        # Determine if this is a SELECT query
+        is_query = operation.strip().upper().startswith(("SELECT", "PRAGMA", "EXPLAIN"))
+
+        if is_query:
+            assert conn._protocol is not None and conn._db_id is not None
+            columns, rows = await conn._protocol.query_sql(conn._db_id, operation, params)
+            self._description = [(name, None, None, None, None, None, None) for name in columns]
+            self._rows = [tuple(row) for row in rows]
+            self._row_index = 0
+            self._rowcount = len(rows)
+        else:
+            assert conn._protocol is not None and conn._db_id is not None
+            last_id, affected = await conn._protocol.exec_sql(conn._db_id, operation, params)
+            self._lastrowid = last_id
+            self._rowcount = affected
+            self._description = None
+            self._rows = []
+
+    def executemany(self, operation: str, seq_of_parameters: Sequence[Sequence[Any]]) -> "Cursor":
+        """Execute a database operation multiple times."""
+        self._check_closed()
+
+        loop = self._get_loop()
+        loop.run_until_complete(self._executemany_async(operation, seq_of_parameters))
+        return self
+
+    async def _executemany_async(
+        self, operation: str, seq_of_parameters: Sequence[Sequence[Any]]
+    ) -> None:
+        """Async implementation of executemany."""
+        total_affected = 0
+        for params in seq_of_parameters:
+            await self._execute_async(operation, params)
+            if self._rowcount >= 0:
+                total_affected += self._rowcount
+        self._rowcount = total_affected
+
+    def fetchone(self) -> tuple[Any, ...] | None:
+        """Fetch the next row of a query result set."""
+        self._check_closed()
+
+        if not self._rows or self._row_index >= len(self._rows):
+            return None
+
+        row = self._rows[self._row_index]
+        self._row_index += 1
+        return row
+
+    def fetchmany(self, size: int | None = None) -> list[tuple[Any, ...]]:
+        """Fetch the next set of rows of a query result."""
+        self._check_closed()
+
+        if size is None:
+            size = self._arraysize
+
+        result: list[tuple[Any, ...]] = []
+        for _ in range(size):
+            row = self.fetchone()
+            if row is None:
+                break
+            result.append(row)
+
+        return result
+
+    def fetchall(self) -> list[tuple[Any, ...]]:
+        """Fetch all remaining rows of a query result."""
+        self._check_closed()
+
+        result = self._rows[self._row_index :]
+        self._row_index = len(self._rows)
+        return result
+
+    def close(self) -> None:
+        """Close the cursor."""
+        self._closed = True
+        self._rows = []
+        self._description = None
+
+    def setinputsizes(self, sizes: Sequence[int | None]) -> None:
+        """Set input sizes (no-op for dqlite)."""
+        pass
+
+    def setoutputsize(self, size: int, column: int | None = None) -> None:
+        """Set output size (no-op for dqlite)."""
+        pass
+
+    def __iter__(self) -> "Cursor":
+        return self
+
+    def __next__(self) -> tuple[Any, ...]:
+        row = self.fetchone()
+        if row is None:
+            raise StopIteration
+        return row
+
+    def __enter__(self) -> "Cursor":
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        self.close()

dqlitedbapi/exceptions.py

@@ -0,0 +1,61 @@
+"""PEP 249 exception hierarchy for dqlite."""
+
+
+class Warning(Exception):  # noqa: A001
+    """Exception raised for important warnings."""
+
+    pass
+
+
+class Error(Exception):
+    """Base class for all database errors."""
+
+    pass
+
+
+class InterfaceError(Error):
+    """Error related to the database interface."""
+
+    pass
+
+
+class DatabaseError(Error):
+    """Error related to the database."""
+
+    pass
+
+
+class DataError(DatabaseError):
+    """Error due to problems with the processed data."""
+
+    pass
+
+
+class OperationalError(DatabaseError):
+    """Error related to database operation."""
+
+    pass
+
+
+class IntegrityError(DatabaseError):
+    """Error related to database integrity."""
+
+    pass
+
+
+class InternalError(DatabaseError):
+    """Internal database error."""
+
+    pass
+
+
+class ProgrammingError(DatabaseError):
+    """Programming error (e.g., table not found, SQL syntax error)."""
+
+    pass
+
+
+class NotSupportedError(DatabaseError):
+    """Method or database API not supported by database."""
+
+    pass

dqlitedbapi/types.py

@@ -0,0 +1,64 @@
+"""PEP 249 type objects and constructors for dqlite."""
+
+import datetime
+
+
+# Type constructors
+def Date(year: int, month: int, day: int) -> datetime.date:  # noqa: N802
+    """Construct a date value."""
+    return datetime.date(year, month, day)
+
+
+def Time(hour: int, minute: int, second: int) -> datetime.time:  # noqa: N802
+    """Construct a time value."""
+    return datetime.time(hour, minute, second)
+
+
+def Timestamp(  # noqa: N802
+    year: int, month: int, day: int, hour: int, minute: int, second: int
+) -> datetime.datetime:
+    """Construct a timestamp value."""
+    return datetime.datetime(year, month, day, hour, minute, second)
+
+
+def DateFromTicks(ticks: float) -> datetime.date:  # noqa: N802
+    """Construct a date from a Unix timestamp."""
+    return datetime.date.fromtimestamp(ticks)
+
+
+def TimeFromTicks(ticks: float) -> datetime.time:  # noqa: N802
+    """Construct a time from a Unix timestamp."""
+    return datetime.datetime.fromtimestamp(ticks).time()
+
+
+def TimestampFromTicks(ticks: float) -> datetime.datetime:  # noqa: N802
+    """Construct a timestamp from a Unix timestamp."""
+    return datetime.datetime.fromtimestamp(ticks)
+
+
+def Binary(data: bytes) -> bytes:  # noqa: N802
+    """Construct a binary value."""
+    return bytes(data)
+
+
+# Type objects for column type checking
+class _DBAPIType:
+    """Base type for DB-API type objects."""
+
+    def __init__(self, *values: str) -> None:
+        self.values = set(values)
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, str):
+            return other.upper() in self.values
+        return NotImplemented
+
+    def __hash__(self) -> int:
+        return hash(frozenset(self.values))
+
+
+STRING = _DBAPIType("TEXT", "VARCHAR", "CHAR", "CLOB")
+BINARY = _DBAPIType("BLOB", "BINARY", "VARBINARY")
+NUMBER = _DBAPIType("INTEGER", "INT", "SMALLINT", "BIGINT", "REAL", "FLOAT", "DOUBLE", "NUMERIC")
+DATETIME = _DBAPIType("DATE", "TIME", "TIMESTAMP", "DATETIME")
+ROWID = _DBAPIType("ROWID", "INTEGER PRIMARY KEY")