Struct Sqlite 

pub struct Sqlite { /* private fields */ }

A SQLite [Driver] that opens connections to a file or in-memory database.

Examples

use toasty_driver_sqlite::Sqlite;

let driver = Sqlite::in_memory();

Implementations

impl Sqlite

pub fn new(url: impl Into<String>) -> Result<Self>

Create a new SQLite driver with an arbitrary connection URL

pub fn in_memory() -> Self

Create an in-memory SQLite database

pub fn open<P: AsRef<Path>>(path: P) -> Self

Open a SQLite database at the specified file path

pub fn foreign_keys(self, on: bool) -> Self

Set the enforcement of foreign key constraints.

Enabled by default.

pub fn busy_timeout(self, timeout: Duration) -> Self

Set how long a connection waits for a lock held by another connection before failing with database is locked.

Set through sqlite3_busy_timeout as soon as each connection opens, before any pragma runs. The default is 5 seconds.

pub fn journal_mode(self, mode: JournalMode) -> Self

Set the journal mode.

Journal modes are per connection, except for WAL, which the database file keeps. Opening a WAL database with a different journal mode takes an exclusive lock and converts the file.

Not set by default, so an existing database keeps its mode.

Examples

use toasty_driver_sqlite::{JournalMode, Sqlite};

let driver = Sqlite::open("app.db").journal_mode(JournalMode::Wal);

pub fn synchronous(self, synchronous: Synchronous) -> Self

Set the synchronous setting.

Not set by default; SQLite’s default is FULL. NORMAL is usually enough in WAL mode.

pub fn locking_mode(self, mode: LockingMode) -> Self

Set the locking mode.

Not set by default; SQLite’s default is NORMAL.

pub fn auto_vacuum(self, auto_vacuum: AutoVacuum) -> Self

Set the auto-vacuum setting.

Not set by default; SQLite’s default is NONE. On an existing database the change takes effect only after a VACUUM.

pub fn page_size(self, page_size: u32) -> Self

Set the page size in bytes.

Not set by default; SQLite’s default is 4096. On an existing database the change takes effect only after a VACUUM, and never in WAL mode.

pub fn pragma<K, V>(self, key: K, value: V) -> Self

where K: Into<Cow<'static, str>>, V: Into<Cow<'static, str>>,

Set a PRAGMA applied to every connection this driver opens.

Use this for pragmas without a dedicated method. The driver writes PRAGMA {key} = {value} with both arguments as given, so the caller supplies any quoting the value needs. Do not pass untrusted input: the value is SQL text.

Pragmas run in a fixed order rather than the order they are set, because SQLite and SQLCipher constrain it: key and the other SQLCipher settings come first, then page_size, locking_mode, auto_vacuum, journal_mode, foreign_keys, synchronous, and then every other pragma in the order first set. Setting the same pragma twice keeps the last value. Names match exactly.

Examples

use toasty_driver_sqlite::Sqlite;

let driver = Sqlite::open("app.db")
    .pragma("cache_size", "-64000")
    .pragma("temp_store", "MEMORY");

Values of key and other secret SQLCipher pragmas are kept out of query logs, error messages, and Debug output.

Trait Implementations

impl Debug for Sqlite

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

Formats the value using the given formatter.

impl Driver for Sqlite

fn url(&self) -> Cow<'_, str>

Returns the URL this driver is connecting to.

fn capability(&self) -> &'static Capability

Describes the driver’s capability, which informs the query planner.

fn connect<'life0, 'life1, 'async_trait>( &'life0 self, cx: &'life1 ConnectContext, ) -> Pin<Box<dyn Future<Output = Result<Box<dyn Connection>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Creates a new connection to the database.

fn max_connections(&self) -> Option<usize>

Returns the maximum number of simultaneous database connections supported. For example, this is Some(1) for the in-memory SQLite driver which cannot be pooled.

fn generate_migration(&self, schema_diff: &Schema<'_>) -> Migration

Generates a migration from a [diff::Schema].

fn reset_db<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Drops the entire database and recreates an empty one without applying migrations.