An executor-based async sqlite wrapper
Project description
easqlite
A simple Executor-based async sqlite wrapper.
This is used very similarly to the standard sqlite3
module.
By default, ThreadPoolExecutor(max_workers=1)
is used as the executor. If you
pass your own executor, you are responsible for shutting it down and ensuring it
only uses one thread.
Differences from sqlite3
:
connect
check_same_thread
defaults to__debug__
instead ofTrue
connect
is not a function, but just an alias to theConnection
class.Connection
's constructor takes an optionalexecutor
argument.- defaults to
__debug__
instead ofTrue
- Every method, function, context manager, property accessor, and iterator is
asynchronous, except for
Connection.interrupt
, andconnect
. - Every call that takes a factory uses the factory for the internal calls, and defers to a statically defined wrapper class. The internal calls will still use the factories.
- All objects with a
close
method are async context managers. - All methods that implicitly return a cursor return
easqlite.Cursor
instead. - All properties are now methods with an optional setter parameter, so they
can be properly set and gotten on the same thread (primarily so that the
properties can't be changed while they are being used).
- An exception to this is
Cursor.connection
, which is still a property.
- An exception to this is
Blob.__getitem__
is async, butBlob.__setitem__
can not be.Blob.set
is provided instead, with the exact same semantics (it can be passed aslice
). You can useBlob.__setitem__
, but it doesn't actually directly set the blob, but rather queues a set to be run on flush. Any other coroutine flushes the blob, or you can use an explicitBlob.flush
, or just let the blob exit its context manager.Blob.__len__
andBlob.__bool__
do not work.Blob.len
andblob.bool
are async replacements for these.
This can be used effectively identically to the regular sqlite module, but it is preferred to use the async context managers everywhere possible.
Constants are not re-exported, so this library should usually be used in conjunction with the core sqlite3 library.
This is very similar in spirit to the aiosqlite project, but this one takes a more earnest attempt at deferring responsibility to other components. This one also should be more responsive on close, because it doesn't rely on a timeout to shut itself off.
This one also pushes much more extremely on async use, and defers everything it can to the executor thread, even properties.
If you want a more mature and battle-tested module, use aiosqlite
.
Project details
Download files
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.