Struct SqliteConnection

pub struct SqliteConnection { /* private fields */ }

A connection to an open [Sqlite] database.

Because SQLite is an in-process database accessed by blocking API calls, rbdc 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()][Self::close] to ensure the database is closed successfully or get an error otherwise.

Implementations

impl SqliteConnection

pub fn fetch_many( &mut self, query: SqliteQuery, ) -> BoxStream<'_, Result<Either<SqliteQueryResult, SqliteRow>, Error>>

pub fn fetch_optional( &mut self, query: SqliteQuery, ) -> BoxFuture<'_, Result<Option<SqliteRow>, Error>>

pub fn prepare_with<'a>( &'a mut self, sql: &'a str, _parameters: &[SqliteTypeInfo], ) -> BoxFuture<'a, Result<SqliteStatement, Error>>

impl SqliteConnection

pub unsafe fn as_raw_handle(&mut self) -> *mut sqlite3

👎Deprecated: 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.

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::from("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.

pub async 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.

impl SqliteConnection

pub async fn do_close(&mut self) -> Result<(), Error>

pub fn ping(&mut self) -> BoxFuture<'_, Result<(), Error>>

Ensure the background worker thread is alive and accepting commands.

pub fn cached_statements_size(&self) -> usize

pub fn clear_cached_statements(&mut self) -> BoxFuture<'_, Result<(), Error>>

Trait Implementations

impl Connection for SqliteConnection

fn get_rows( &mut self, sql: &str, params: Vec<Value>, ) -> BoxFuture<'_, Result<Vec<Box<dyn Row>>, Error>>

Execute a query that is expected to return a result set, such as a SELECT statement

fn exec( &mut self, sql: &str, params: Vec<Value>, ) -> BoxFuture<'_, Result<ExecResult, Error>>

Execute a query that is expected to update some rows.

fn close(&mut self) -> BoxFuture<'_, Result<(), Error>>

close connection Normally conn is dropped when the link is dropped, but it is recommended to actively close this function so that the database does not report errors. If &mut self is not satisfied close, when you need mut self, It is recommended to use Option and then call take to take ownership and then if let Some(v) = self.inner.take() {v.lose ().await; }

fn ping(&mut self) -> BoxFuture<'_, Result<(), Error>>

ping

fn get_values( &mut self, sql: &str, params: Vec<Value>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Value>, Error>> + Send + '_>>

Execute a query that is expected to return a result set, such as a SELECT statement

fn begin( &mut self, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + '_>>

an translation impl begin

fn commit( &mut self, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + '_>>

an translation impl commit

fn rollback( &mut self, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + '_>>

an translation impl rollback

impl Debug for SqliteConnection

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Sync for SqliteConnection