drizzle-sqlite 0.1.9

A type-safe SQL query builder for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

//! Transaction-type marker and per-driver behavior conversions for `SQLite` drivers.

/// `SQLite` transaction types
#[derive(Default, Debug, Clone, Copy)]
pub enum SQLiteTransactionType {
    #[default]
    /// A deferred transaction is the default - it does not acquire locks until needed
    Deferred,
    /// An immediate transaction acquires a RESERVED lock immediately
    Immediate,
    /// An exclusive transaction acquires an EXCLUSIVE lock immediately
    Exclusive,
}

#[cfg(feature = "rusqlite")]
impl From<SQLiteTransactionType> for ::rusqlite::TransactionBehavior {
    fn from(tx_type: SQLiteTransactionType) -> Self {
        match tx_type {
            SQLiteTransactionType::Deferred => Self::Deferred,
            SQLiteTransactionType::Immediate => Self::Immediate,
            SQLiteTransactionType::Exclusive => Self::Exclusive,
        }
    }
}

#[cfg(feature = "rusqlite")]
impl From<::rusqlite::TransactionBehavior> for SQLiteTransactionType {
    fn from(behavior: ::rusqlite::TransactionBehavior) -> Self {
        match behavior {
            ::rusqlite::TransactionBehavior::Immediate => Self::Immediate,
            ::rusqlite::TransactionBehavior::Exclusive => Self::Exclusive,
            // Deferred and any future variants default to Deferred.
            _ => Self::Deferred,
        }
    }
}

// Convert to libsql::TransactionBehavior
#[cfg(feature = "libsql")]
impl From<SQLiteTransactionType> for libsql::TransactionBehavior {
    fn from(tx_type: SQLiteTransactionType) -> Self {
        match tx_type {
            SQLiteTransactionType::Deferred => Self::Deferred,
            SQLiteTransactionType::Immediate => Self::Immediate,
            SQLiteTransactionType::Exclusive => Self::Exclusive,
        }
    }
}

// Convert from libsql::TransactionBehavior
#[cfg(feature = "libsql")]
impl From<libsql::TransactionBehavior> for SQLiteTransactionType {
    fn from(behavior: libsql::TransactionBehavior) -> Self {
        match behavior {
            libsql::TransactionBehavior::Immediate => Self::Immediate,
            libsql::TransactionBehavior::Exclusive => Self::Exclusive,
            // Deferred and ReadOnly (mapped as closest equivalent) both fall through to Deferred.
            libsql::TransactionBehavior::Deferred | libsql::TransactionBehavior::ReadOnly => {
                Self::Deferred
            }
        }
    }
}

// Convert to turso::TransactionBehavior
#[cfg(feature = "turso")]
impl From<SQLiteTransactionType> for turso::transaction::TransactionBehavior {
    fn from(tx_type: SQLiteTransactionType) -> Self {
        match tx_type {
            SQLiteTransactionType::Deferred => Self::Deferred,
            SQLiteTransactionType::Immediate => Self::Immediate,
            SQLiteTransactionType::Exclusive => Self::Exclusive,
        }
    }
}

// Convert from turso::TransactionBehavior
#[cfg(feature = "turso")]
impl From<turso::transaction::TransactionBehavior> for SQLiteTransactionType {
    fn from(behavior: turso::transaction::TransactionBehavior) -> Self {
        match behavior {
            turso::transaction::TransactionBehavior::Immediate => Self::Immediate,
            turso::transaction::TransactionBehavior::Exclusive => Self::Exclusive,
            // Deferred and any future variants default to Deferred.
            _ => Self::Deferred,
        }
    }
}