This library contains an abstract implementation of PEP-249 which should make it easier to implement new databases in Python. These abstract implementations are fully typed and the docstrings contain some (plagiarised) information from the standard. There is a basic async implementation which could probably be improved upon.
To demonstrate usage of this library, I'm putting together a wrapper on top of the
excellent DuckDB library which adds full typing, context managers,
distinct cursors, and easier to manage error types. This wrapper is available here,
and is currently a bit rough around the edges. It contains a naive async implementation
which essentially just wraps every call with asyncio.to_thread.
Tested in Python 3.7, but not extensively. This library has not been condoned by the PEP authors, who might hate it.
If you're looking to implement a DB-API 2.0 interface for a database, this library should make it easier to do so. Inheriting from the appropriate abstract base classes will ensure that classes can't be instantiated without fully implementing the required behaviour. Implementations will be fully typed, and some functionality is provided 'for free' (e.g. context managers, cursor iteration).
python3 -mpip install pep249abcThis library's base classes define a protocol which requires implementation. If you inherit from these classes, your editor should whinge at you until you've implemented the rest of the specification (or if you deviate from it).
import pep249
class Cursor(pep249.Cursor):
...
class Connection(pep249.Connection):
...To use the mixin types (e.g. to implement extensions, or to implement execute*() for
the Connection), use multiple inheritance:
import pep249
class Connection(
pep249.CursorExecuteMixin, pep249.ConcreteErrorMixin, pep249.Connection
):
...The async implementation is contained in a separate subpackage:
from pep249 import aiopep249
class AsyncConnection(
aiopep249.AsyncCursorExecuteMixin,
aiopep249.ConcreteErrorMixin,
aiopep249.AsyncConnection,
):
...All of the core functionality, some 'common but slightly non-compliant' stuff (e.g.
TransactionalCursor, a Cursor with transaction support), and some select extensions:
- A mixin to add the error types to the
Connection. - A mixin to add a reference to the
Connectionto theCursor. - A mixin to add support for next and iteration.
There is now a very basic async implementation, which was made by copy and pasting the synchronous
implementation and sprinking the words async and await in some appropriate (and likely some
inappropriate) places.
Most of the optional extensions.
Cursor.rownumber.Cursor.scroll().Cursor.messages.Connection.messages.Cursor.lastrowid.Cursor/Connection.errorhandler.- Two phase commit extensions.
Most of these are missing simply because I haven't encountered them in the wild and they weren't supported by the reference implementation I had in mind. If you'd like to see these implemented, please raise an issue! If you have examples of the features in use, that would be helpful.
Probably a lot! In particular, I'm not happy with Cursor.description or the type
constructors. The spec is quite opaque on these and I haven't done much research on how
these work or how they should tie in.
General improvements, some further testing, some documentation, and maybe a more inspired async implementation which more commonly mirrors aiosqlite.