pub struct SqliteConnection {
pub worker: ConnectionWorker,
pub row_channel_size: usize,
}
Expand description
A connection to an open Sqlite database.
Because SQLite is an in-process database accessed by blocking API calls, SQLx uses a background thread and communicates with it via channels to allow non-blocking access to the database.
Dropping this struct will signal the worker thread to quit and close the database, though if an error occurs there is no way to pass it back to the user this way.
You can explicitly call .close()
to ensure the database is closed successfully
or get an error otherwise.
Fields§
§worker: ConnectionWorker
§row_channel_size: usize
Implementations§
Source§impl SqliteConnection
impl SqliteConnection
pub fn establish(options: &SqliteConnectOptions) -> Result<Self, Error>
Sourcepub fn as_raw_handle(&mut self) -> *mut sqlite3
👎Deprecated: Unsynchronized access is unsafe. See documentation for details.
pub fn as_raw_handle(&mut self) -> *mut sqlite3
Returns the underlying sqlite3* connection handle.
§Note
There is no synchronization using this method, beware that the background thread could be making SQLite API calls concurrent to use of this method.
You probably want to use .lock_handle()
to ensure that the worker thread is not using
the database concurrently.
Sourcepub fn create_collation(
&mut self,
name: &str,
compare: impl Fn(&str, &str) -> Ordering + Send + Sync + 'static,
) -> Result<(), Error>
👎Deprecated: Completes asynchronously. See documentation for details.
pub fn create_collation( &mut self, name: &str, compare: impl Fn(&str, &str) -> Ordering + Send + Sync + 'static, ) -> Result<(), Error>
Apply a collation to the open database.
See SqliteConnectOptions::collation()
for details.
§Deprecated
Due to the rearchitecting of the SQLite driver, this method cannot actually function
synchronously and return the result directly from sqlite3_create_collation_v2()
, so
it instead sends a message to the worker create the collation asynchronously.
If an error occurs it will simply be logged.
Instead, you should specify the collation during the initial configuration with
SqliteConnectOptions::collation()
. Then, if the collation fails to apply it will
return an error during the connection creation. When used with a [Pool][crate::pool::Pool],
this also ensures that the collation is applied to all connections automatically.
Or if necessary, you can call .lock_handle()
and create the collation directly with [LockedSqliteHandle::create_collation()
].
Error::WorkerCrashed
may still be returned if we could not communicate with the worker.
Note that this may also block if the worker command channel is currently applying backpressure.
Sourcepub fn lock_handle(&mut self) -> Result<LockedSqliteHandle<'_>, Error>
pub fn lock_handle(&mut self) -> Result<LockedSqliteHandle<'_>, Error>
Lock the SQLite database handle out from the worker thread so direct SQLite API calls can be made safely.
Returns an error if the worker thread crashed.
Trait Implementations§
Source§impl Connection for SqliteConnection
impl Connection for SqliteConnection
Source§fn ping(&mut self) -> Result<(), Error>
fn ping(&mut self) -> Result<(), Error>
Ensure the background worker thread is alive and accepting commands.
type Options = SqliteConnectOptions
Source§fn begin(&mut self) -> Result<Transaction<'_, Self::Database>, Error>where
Self: Sized,
fn begin(&mut self) -> Result<Transaction<'_, Self::Database>, Error>where
Self: Sized,
Source§fn cached_statements_size(&self) -> usize
fn cached_statements_size(&self) -> usize
Source§fn clear_cached_statements(&mut self) -> Result<(), Error>
fn clear_cached_statements(&mut self) -> Result<(), Error>
Source§fn transaction<'a, F, R, E>(&'a mut self, callback: F) -> Result<R, E>
fn transaction<'a, F, R, E>(&'a mut self, callback: F) -> Result<R, E>
Source§impl Debug for SqliteConnection
impl Debug for SqliteConnection
Source§impl Executor for &mut SqliteConnection
impl Executor for &mut SqliteConnection
type Database = Sqlite
Source§fn fetch_many<'q, E>(
&mut self,
query: E,
) -> ChanStream<Either<SqliteQueryResult, SqliteRow>>
fn fetch_many<'q, E>( &mut self, query: E, ) -> ChanStream<Either<SqliteQueryResult, SqliteRow>>
Source§fn fetch_optional<'q, E>(
&mut self,
query: E,
) -> Result<Option<SqliteRow>, Error>
fn fetch_optional<'q, E>( &mut self, query: E, ) -> Result<Option<SqliteRow>, Error>
Source§fn prepare_with<'q>(
&mut self,
sql: &'q str,
_parameters: &[SqliteTypeInfo],
) -> Result<SqliteStatement, Error>
fn prepare_with<'q>( &mut self, sql: &'q str, _parameters: &[SqliteTypeInfo], ) -> Result<SqliteStatement, Error>
Source§fn execute<'q, E>(
&mut self,
query: E,
) -> Result<<Self::Database as Database>::QueryResult, Error>
fn execute<'q, E>( &mut self, query: E, ) -> Result<<Self::Database as Database>::QueryResult, Error>
Source§fn execute_many<'q, E>(
&mut self,
query: E,
) -> ChanStream<<Self::Database as Database>::QueryResult>
fn execute_many<'q, E>( &mut self, query: E, ) -> ChanStream<<Self::Database as Database>::QueryResult>
Source§fn fetch<'q, E>(
&mut self,
query: E,
) -> ChanStream<<Self::Database as Database>::Row>
fn fetch<'q, E>( &mut self, query: E, ) -> ChanStream<<Self::Database as Database>::Row>
Source§fn fetch_all<'q, E>(
&mut self,
query: E,
) -> Result<Vec<<Self::Database as Database>::Row>, Error>
fn fetch_all<'q, E>( &mut self, query: E, ) -> Result<Vec<<Self::Database as Database>::Row>, Error>
Vec
.Source§impl Executor for SqliteConnection
impl Executor for SqliteConnection
type Database = Sqlite
Source§fn fetch_many<'q, E>(
&mut self,
query: E,
) -> ChanStream<Either<SqliteQueryResult, SqliteRow>>
fn fetch_many<'q, E>( &mut self, query: E, ) -> ChanStream<Either<SqliteQueryResult, SqliteRow>>
Source§fn fetch_optional<'q, E>(
&mut self,
query: E,
) -> Result<Option<SqliteRow>, Error>
fn fetch_optional<'q, E>( &mut self, query: E, ) -> Result<Option<SqliteRow>, Error>
Source§fn prepare_with<'q>(
&mut self,
sql: &'q str,
_parameters: &[SqliteTypeInfo],
) -> Result<SqliteStatement, Error>
fn prepare_with<'q>( &mut self, sql: &'q str, _parameters: &[SqliteTypeInfo], ) -> Result<SqliteStatement, Error>
Source§fn execute<'q, E>(
&mut self,
query: E,
) -> Result<<Self::Database as Database>::QueryResult, Error>
fn execute<'q, E>( &mut self, query: E, ) -> Result<<Self::Database as Database>::QueryResult, Error>
Source§fn execute_many<'q, E>(
&mut self,
query: E,
) -> ChanStream<<Self::Database as Database>::QueryResult>
fn execute_many<'q, E>( &mut self, query: E, ) -> ChanStream<<Self::Database as Database>::QueryResult>
Source§fn fetch<'q, E>(
&mut self,
query: E,
) -> ChanStream<<Self::Database as Database>::Row>
fn fetch<'q, E>( &mut self, query: E, ) -> ChanStream<<Self::Database as Database>::Row>
Source§fn fetch_all<'q, E>(
&mut self,
query: E,
) -> Result<Vec<<Self::Database as Database>::Row>, Error>
fn fetch_all<'q, E>( &mut self, query: E, ) -> Result<Vec<<Self::Database as Database>::Row>, Error>
Vec
.Source§impl<'c> From<&'c mut SqliteConnection> for MaybePoolConnection<'c, Sqlite>
impl<'c> From<&'c mut SqliteConnection> for MaybePoolConnection<'c, Sqlite>
Source§fn from(v: &'c mut SqliteConnection) -> Self
fn from(v: &'c mut SqliteConnection) -> Self
Auto Trait Implementations§
impl Freeze for SqliteConnection
impl !RefUnwindSafe for SqliteConnection
impl Send for SqliteConnection
impl !Sync for SqliteConnection
impl Unpin for SqliteConnection
impl !UnwindSafe for SqliteConnection
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Source§impl<T> IntoEither for T
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self>
fn into_either(self, into_left: bool) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left
is true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left(&self)
returns true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read more