Enum SQLRiteError 

pub enum SQLRiteError {
    NotImplemented(String),
    General(String),
    Internal(String),
    UnknownCommand(String),
    SqlError(ParserError),
    Io(Error),
    Busy(String),
    BusySnapshot(String),
}

SQLRiteError is an enum with all the standardized errors available for returning

Variants

NotImplemented(String)

General(String)

Internal(String)

UnknownCommand(String)

SqlError(ParserError)

Io(Error)

Busy(String)

Phase 11.4 — BEGIN CONCURRENT commit hit a write-write conflict. Some other transaction committed a newer version of a row in this transaction’s write-set after this transaction’s begin_ts. Caller should ROLLBACK (already implicitly performed) and retry the transaction with a fresh begin_ts.

BusySnapshot(String)

Phase 11.4 — same shape as SQLRiteError::Busy but surfaces the snapshot-isolation specific case: a row in the read-set changed under us. Distinguished from Busy so SDKs can map it to a per-language exception that the caller’s retry helper recognizes (mirrors Turso / libSQL’s BUSY vs BUSY_SNAPSHOT split). v0 only emits Busy from the write-write validation loop; the read-anomaly variant is reserved for the snapshot-read integration that follows.

Implementations

impl SQLRiteError

pub fn is_retryable(&self) -> bool

Phase 11.4 — true for Busy and BusySnapshot. SDK retry helpers branch on this rather than matching the variants individually so adding a third “retryable” variant later doesn’t break callers.

Examples found in repository

examples/rust/concurrent_writers.rs (line 60)

fn main() -> Result<()> {
    let mut a = Connection::open_in_memory()?;
    a.execute("PRAGMA journal_mode = mvcc")?;
    a.execute(
        "CREATE TABLE accounts (
             id      INTEGER PRIMARY KEY,
             holder  TEXT NOT NULL,
             balance INTEGER NOT NULL
         )",
    )?;
    a.execute("INSERT INTO accounts (id, holder, balance) VALUES (1, 'alice', 100)")?;
    a.execute("INSERT INTO accounts (id, holder, balance) VALUES (2, 'bob',   100)")?;

    // Sibling handle on the same Arc<Mutex<Database>>. In real apps
    // you'd hand this to a worker thread; we keep it on the main
    // thread to keep the demo readable.
    let mut b = a.connect();

    println!("=== Disjoint-row commits both succeed ===");
    a.execute("BEGIN CONCURRENT")?;
    b.execute("BEGIN CONCURRENT")?;
    a.execute("UPDATE accounts SET balance = balance + 10 WHERE id = 1")?;
    b.execute("UPDATE accounts SET balance = balance + 20 WHERE id = 2")?;
    a.execute("COMMIT")?;
    b.execute("COMMIT")?; // write-sets don't intersect — no conflict.
    print_balances(&mut a)?;

    println!("\n=== Same-row commits: A wins, B retries ===");
    // Interleave BEGINs so A.begin_ts < B.begin_ts and both see the
    // same pre-update value.
    a.execute("BEGIN CONCURRENT")?;
    b.execute("BEGIN CONCURRENT")?;
    a.execute("UPDATE accounts SET balance = balance + 5 WHERE id = 1")?;
    b.execute("UPDATE accounts SET balance = balance + 50 WHERE id = 1")?;
    a.execute("COMMIT")?;
    // B's commit sees a version newer than its own `begin_ts` → Busy.
    // The transaction is already dropped on the failed COMMIT;
    // there's no ROLLBACK to run. Start a fresh BEGIN CONCURRENT.
    match b.execute("COMMIT") {
        Err(e) if e.is_retryable() => {
            eprintln!("  B lost the race: {e}");
            b.execute("BEGIN CONCURRENT")?;
            b.execute("UPDATE accounts SET balance = balance + 50 WHERE id = 1")?;
            b.execute("COMMIT")?;
        }
        other => {
            other?;
        }
    }
    print_balances(&mut a)?;

    Ok(())
}

Trait Implementations

impl Debug for SQLRiteError

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

Formats the value using the given formatter.

impl Display for SQLRiteError

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

Formats the value using the given formatter.

impl Error for SQLRiteError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<Error> for SQLRiteError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<ParserError> for SQLRiteError

fn from(source: ParserError) -> Self

Converts to this type from the input type.

impl PartialEq for SQLRiteError

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.