Struct cdbc_sqlite::SqliteConnectOptions

pub struct SqliteConnectOptions {
    pub filename: Cow<'static, Path>,
    pub in_memory: bool,
    pub read_only: bool,
    pub create_if_missing: bool,
    pub shared_cache: bool,
    pub statement_cache_capacity: usize,
    pub busy_timeout: Duration,
    pub immutable: bool,
    pub pragmas: IndexMap<Cow<'static, str>, Cow<'static, str>>,
    pub serialized: bool,
}

Options and flags which can be used to configure a SQLite connection.

A value of SqliteConnectOptions can be parsed from a connection URI, as described by SQLite.

URI	Description
sqlite::memory:	Open an in-memory database.
sqlite:data.db	Open the file data.db in the current directory.
sqlite://data.db	Open the file data.db in the current directory.
sqlite:///data.db	Open the file data.db from the root (/) directory.
sqlite://data.db?mode=ro	Open the file data.db for read-only access.

Example

use sqlx::sqlite::{SqliteConnectOptions, SqliteJournalMode};
use std::str::FromStr;

let conn = SqliteConnectOptions::from_str("sqlite://data.db")?
    .journal_mode(SqliteJournalMode::Wal)
    .read_only(true)
    .connect()?;

Fields

filename: Cow<'static, Path>

in_memory: bool

read_only: bool

create_if_missing: bool

shared_cache: bool

statement_cache_capacity: usize

busy_timeout: Duration

immutable: bool

pragmas: IndexMap<Cow<'static, str>, Cow<'static, str>>

serialized: bool

Implementations

impl SqliteConnectOptions

pub fn new() -> Self

pub fn filename(self, filename: impl AsRef<Path>) -> Self

Sets the name of the database file.

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

Set the enforcement of foreign key constriants.

By default, this is enabled.

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

Set the SQLITE_OPEN_SHAREDCACHE flag.

By default, this is disabled.

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

Sets the journal mode for the database connection.

The default journal mode is WAL. For most use cases this can be significantly faster but there are disadvantages.

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

Sets the locking mode for the database connection.

The default locking mode is NORMAL.

pub fn read_only(self, read_only: bool) -> Self

Sets the access mode to open the database for read-only access.

pub fn create_if_missing(self, create: bool) -> Self

Sets the access mode to create the database file if the file does not exist.

By default, a new file will not be created if one is not found.

pub fn statement_cache_capacity(self, capacity: usize) -> Self

Sets the capacity of the connection’s statement cache in a number of stored distinct statements. Caching is handled using LRU, meaning when the amount of queries hits the defined limit, the oldest statement will get dropped.

The default cache capacity is 100 statements.

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

Sets a timeout value to wait when the database is locked, before returning a busy timeout error.

The default busy timeout is 5 seconds.

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

Sets the synchronous setting for the database connection.

The default synchronous settings is FULL. However, if durability is not a concern, then NORMAL is normally all one needs in WAL mode.

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

Sets the auto_vacuum setting for the database connection.

The default auto_vacuum setting is NONE.

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

Sets the page_size setting for the database connection.

The default page_size setting is 4096.

pub fn pragma<K, V>(self, key: K, value: V) -> Self where
    K: Into<Cow<'static, str>>,
    V: Into<Cow<'static, str>>, 

Sets custom initial pragma for the database connection.

pub fn immutable(self, immutable: bool) -> Self

pub fn serialized(self, serialized: bool) -> Self

Sets the threading mode for the database connection.

The default setting is false corersponding to using OPEN_NOMUTEX, if true then OPEN_FULLMUTEX.

See open for more details.

Trait Implementations

impl Clone for SqliteConnectOptions

fn clone(&self) -> SqliteConnectOptions

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl ConnectOptions for SqliteConnectOptions

type Connection = SqliteConnection

fn connect(&self) -> Result<Self::Connection, Error> where
    Self::Connection: Sized, 

Establish a new database connection with the options specified by self.

impl Debug for SqliteConnectOptions

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

Formats the value using the given formatter.

impl Default for SqliteConnectOptions

fn default() -> Self

Returns the “default value” for a type.

impl FromStr for SqliteConnectOptions

type Err = Error

The associated error which can be returned from parsing.

fn from_str(uri: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.