Enum Mode 

#[non_exhaustive]
pub enum Mode {
    Deferred,
    Immediate,
    Exclusive,
}

How a SQLite transaction takes the database’s write lock.

SQLite runs every transaction serializable, with one writer at a time, so a table on it names the moment its transactions take the write lock (TableSpec::mode) instead of a level.

Examples

A dialect for a database that takes SQLite’s modes opens its transactions in them:

use ruststream_sqlx_dialect::{
    Dialect, Mode, Opening, Opens, Statement, StatementError, TableSpec, level,
};

/// libSQL, a fork of SQLite served over the network, a database without a built-in dialect.
#[derive(Debug)]
pub struct Libsql;

impl Dialect for Libsql {
    fn name(&self) -> &'static str {
        "libsql"
    }

    fn begin(&self, opening: Opening) -> Result<Option<&'static str>, StatementError> {
        match opening {
            Opening::Default => Ok(None),
            Opening::Mode(Mode::Deferred) => Ok(Some("BEGIN DEFERRED")),
            Opening::Mode(Mode::Immediate) => Ok(Some("BEGIN IMMEDIATE")),
            Opening::Mode(Mode::Exclusive) => Ok(Some("BEGIN EXCLUSIVE")),
            // libSQL runs every transaction serializable, as SQLite does: it names no level.
            other => Err(StatementError::UnsupportedOpening {
                dialect: self.name(),
                opening: other.name(),
            }),
        }
    }
}

// A table with `mode = deferred`, `immediate` or `exclusive` mounts on `Libsql`.
impl Opens<level::Deferred> for Libsql {}
impl Opens<level::Immediate> for Libsql {}
impl Opens<level::Exclusive> for Libsql {}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Deferred

The transaction takes no lock until it first reads or writes, as a plain BEGIN does.

Immediate

The transaction takes the write lock when it begins, so no other writer comes between its reads and its writes.

Exclusive

The transaction takes the write lock when it begins and, outside WAL mode, keeps every other connection from reading until it ends.

Implementations

impl Mode

pub const fn sql(self) -> &'static str

The mode as SQL names it: IMMEDIATE.

Examples

use ruststream_sqlx_dialect::{Dialect, Mode, Opening, Sqlite};

// A dialect's test: each mode opens a transaction in that mode.
for mode in [Mode::Deferred, Mode::Immediate, Mode::Exclusive] {
    let begin = Sqlite.begin(Opening::Mode(mode))?;
    assert_eq!(begin, Some(format!("BEGIN {}", mode.sql())).as_deref());
}

Trait Implementations

impl Clone for Mode

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Mode

impl Debug for Mode

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

Formats the value using the given formatter.

impl Eq for Mode

impl Hash for Mode

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Mode

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Mode