Struct sqlx::sqlite::SqliteConnection [−][src]
pub struct SqliteConnection { /* fields omitted */ }
sqlite
only.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.
Implementations
π Deprecated: Unsynchronized access is unsafe. See documentation for details.
Unsynchronized access is unsafe. See documentation for details.
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.
pub 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>
Completes asynchronously. See documentation for details.
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,
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.
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
type Connection = &'c mut <Sqlite as Database>::Connection
Ensure the background worker thread is alive and accepting commands.
type Options = SqliteConnectOptions
Explicitly close this database connection. Read more
pub fn begin(
&mut self
) -> Pin<Box<dyn Future<Output = Result<Transaction<'_, <SqliteConnection as Connection>::Database>, Error>> + Send, Global>> where
SqliteConnection: Sized,
pub fn begin(
&mut self
) -> Pin<Box<dyn Future<Output = Result<Transaction<'_, <SqliteConnection as Connection>::Database>, Error>> + Send, Global>> where
SqliteConnection: Sized,
Begin a new transaction or establish a savepoint within the active transaction. Read more
The number of statements currently cached in the connection.
Removes all statements from the cache, closing them on the server if needed. Read more
fn transaction<'a, F, R, E>(
&'a mut self,
callback: F
) -> Pin<Box<dyn Future<Output = Result<R, E>> + Send + 'a, Global>> where
F: 'a + for<'c> FnOnce(&'c mut Transaction<'_, Self::Database>) -> Pin<Box<dyn Future<Output = Result<R, E>> + Send + 'c, Global>> + Send + Sync,
R: Send,
E: From<Error> + Send,
fn transaction<'a, F, R, E>(
&'a mut self,
callback: F
) -> Pin<Box<dyn Future<Output = Result<R, E>> + Send + 'a, Global>> where
F: 'a + for<'c> FnOnce(&'c mut Transaction<'_, Self::Database>) -> Pin<Box<dyn Future<Output = Result<R, E>> + Send + 'c, Global>> + Send + Sync,
R: Send,
E: From<Error> + Send,
Execute the function inside a transaction. Read more
Establish a new database connection. Read more
pub fn fetch_many<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<SqliteQueryResult, SqliteRow>, Error>> + Send + 'e, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, <&'c mut SqliteConnection as Executor<'c>>::Database>,
pub fn fetch_many<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<SqliteQueryResult, SqliteRow>, Error>> + Send + 'e, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, <&'c mut SqliteConnection as Executor<'c>>::Database>,
Execute multiple queries and return the generated results as a stream from each query, in a stream. Read more
Execute the query and returns at most one row.
pub fn prepare_with<'e, 'q>(
self,
sql: &'q str,
_parameters: &[SqliteTypeInfo]
) -> Pin<Box<dyn Future<Output = Result<SqliteStatement<'q>, Error>> + Send + 'e, Global>> where
'q: 'e,
'c: 'e,
pub fn prepare_with<'e, 'q>(
self,
sql: &'q str,
_parameters: &[SqliteTypeInfo]
) -> Pin<Box<dyn Future<Output = Result<SqliteStatement<'q>, Error>> + Send + 'e, Global>> where
'q: 'e,
'c: 'e,
Prepare the SQL query, with parameter type information, to inspect the type information about its parameters and results. Read more
Execute the query and return the total number of rows affected.
Execute multiple queries and return the rows affected from each query, in a stream.
Execute the query and return the generated results as a stream.
Execute the query and return all the generated results, collected into a Vec
.
Execute the query and returns exactly one row.