drizzle_sqlite/
lib.rs

1//! SQLite implementation for Drizzle
2//!
3//! This crate provides SQLite-specific functionality for Drizzle.
4
5//------------------------------------------------------------------------------
6// Module Declarations
7//------------------------------------------------------------------------------
8
9pub mod builder;
10pub mod common;
11pub mod conditions;
12pub mod expression;
13pub mod helpers;
14pub mod pragma;
15pub mod traits;
16pub mod values;
17
18//------------------------------------------------------------------------------
19// Prelude
20//------------------------------------------------------------------------------
21
22/// A prelude module that re-exports commonly used types and traits
23pub mod prelude {
24    pub use crate::SQLiteTransactionType;
25    pub use crate::pragma::Pragma;
26    pub use crate::traits::SQLiteColumn;
27    pub use crate::traits::{DrizzleRow, FromSQLiteValue};
28    pub use crate::values::SQLiteValue;
29
30    // Re-export rusqlite trait implementations when the feature is enabled
31    #[cfg(feature = "rusqlite")]
32    pub use ::rusqlite::types::ToSql;
33}
34
35pub use self::values::{OwnedSQLiteValue, SQLiteInsertValue, SQLiteValue};
36
37// Re-export ParamBind for use in macros
38pub use drizzle_core::ParamBind;
39use drizzle_core::SQL;
40
41#[cfg(not(any(feature = "libsql", feature = "rusqlite", feature = "turso")))]
42use std::marker::PhantomData;
43
44/// Reference to different SQLite driver connection types
45#[derive(Debug)]
46pub enum ConnectionRef<'a> {
47    #[cfg(feature = "libsql")]
48    LibSql(&'a libsql::Connection),
49    #[cfg(feature = "rusqlite")]
50    Rusqlite(&'a rusqlite::Connection),
51    #[cfg(feature = "turso")]
52    Turso(&'a turso::Connection),
53    #[cfg(not(any(feature = "libsql", feature = "rusqlite", feature = "turso")))]
54    _Phantom(PhantomData<&'a ()>),
55}
56
57// Implement Into trait for each connection type
58#[cfg(feature = "libsql")]
59impl<'a> From<&'a libsql::Connection> for ConnectionRef<'a> {
60    fn from(conn: &'a libsql::Connection) -> Self {
61        ConnectionRef::LibSql(conn)
62    }
63}
64
65#[cfg(feature = "rusqlite")]
66impl<'a> From<&'a rusqlite::Connection> for ConnectionRef<'a> {
67    fn from(conn: &'a rusqlite::Connection) -> Self {
68        ConnectionRef::Rusqlite(conn)
69    }
70}
71
72#[cfg(feature = "turso")]
73impl<'a> From<&'a turso::Connection> for ConnectionRef<'a> {
74    fn from(conn: &'a turso::Connection) -> Self {
75        ConnectionRef::Turso(conn)
76    }
77}
78
79/// SQLite transaction types
80#[derive(Default, Debug, Clone, Copy)]
81pub enum SQLiteTransactionType {
82    #[default]
83    /// A deferred transaction is the default - it does not acquire locks until needed
84    Deferred,
85    /// An immediate transaction acquires a RESERVED lock immediately
86    Immediate,
87    /// An exclusive transaction acquires an EXCLUSIVE lock immediately
88    Exclusive,
89}
90
91#[cfg(feature = "rusqlite")]
92impl From<SQLiteTransactionType> for ::rusqlite::TransactionBehavior {
93    fn from(tx_type: SQLiteTransactionType) -> Self {
94        match tx_type {
95            SQLiteTransactionType::Deferred => ::rusqlite::TransactionBehavior::Deferred,
96            SQLiteTransactionType::Immediate => ::rusqlite::TransactionBehavior::Immediate,
97            SQLiteTransactionType::Exclusive => ::rusqlite::TransactionBehavior::Exclusive,
98        }
99    }
100}
101
102#[cfg(feature = "rusqlite")]
103impl From<::rusqlite::TransactionBehavior> for SQLiteTransactionType {
104    fn from(behavior: ::rusqlite::TransactionBehavior) -> Self {
105        match behavior {
106            ::rusqlite::TransactionBehavior::Deferred => SQLiteTransactionType::Deferred,
107            ::rusqlite::TransactionBehavior::Immediate => SQLiteTransactionType::Immediate,
108            ::rusqlite::TransactionBehavior::Exclusive => SQLiteTransactionType::Exclusive,
109            _ => SQLiteTransactionType::Deferred, // Default for any future variants
110        }
111    }
112}
113
114// Convert to libsql::TransactionBehavior
115#[cfg(feature = "libsql")]
116impl From<SQLiteTransactionType> for libsql::TransactionBehavior {
117    fn from(tx_type: SQLiteTransactionType) -> Self {
118        match tx_type {
119            SQLiteTransactionType::Deferred => libsql::TransactionBehavior::Deferred,
120            SQLiteTransactionType::Immediate => libsql::TransactionBehavior::Immediate,
121            SQLiteTransactionType::Exclusive => libsql::TransactionBehavior::Exclusive,
122        }
123    }
124}
125
126// Convert from libsql::TransactionBehavior
127#[cfg(feature = "libsql")]
128impl From<libsql::TransactionBehavior> for SQLiteTransactionType {
129    fn from(behavior: libsql::TransactionBehavior) -> Self {
130        match behavior {
131            libsql::TransactionBehavior::Deferred => SQLiteTransactionType::Deferred,
132            libsql::TransactionBehavior::Immediate => SQLiteTransactionType::Immediate,
133            libsql::TransactionBehavior::Exclusive => SQLiteTransactionType::Exclusive,
134            libsql::TransactionBehavior::ReadOnly => SQLiteTransactionType::Deferred, // Map ReadOnly to Deferred as closest equivalent
135        }
136    }
137}
138// Convert to turso::TransactionBehavior
139#[cfg(feature = "turso")]
140impl From<SQLiteTransactionType> for turso::transaction::TransactionBehavior {
141    fn from(tx_type: SQLiteTransactionType) -> Self {
142        match tx_type {
143            SQLiteTransactionType::Deferred => turso::transaction::TransactionBehavior::Deferred,
144            SQLiteTransactionType::Immediate => turso::transaction::TransactionBehavior::Immediate,
145            SQLiteTransactionType::Exclusive => turso::transaction::TransactionBehavior::Exclusive,
146        }
147    }
148}
149
150// Convert from turso::TransactionBehavior
151#[cfg(feature = "turso")]
152impl From<turso::transaction::TransactionBehavior> for SQLiteTransactionType {
153    fn from(behavior: turso::transaction::TransactionBehavior) -> Self {
154        match behavior {
155            turso::transaction::TransactionBehavior::Deferred => SQLiteTransactionType::Deferred,
156            turso::transaction::TransactionBehavior::Immediate => SQLiteTransactionType::Immediate,
157            turso::transaction::TransactionBehavior::Exclusive => SQLiteTransactionType::Exclusive,
158            _ => SQLiteTransactionType::Deferred,
159        }
160    }
161}
162
163/// Creates an array of SQL parameters for binding values to placeholders.
164///
165/// # Syntax
166/// - `{ name: value }` - Colon parameter (creates :name placeholder)
167///
168/// # Examples
169///
170/// ```
171/// use drizzle_sqlite::params;
172///
173/// let params = params![{ name: "alice" }, { active: true }];
174/// ```
175#[macro_export]
176macro_rules! params {
177    // Multiple parameters - creates a fixed-size array of Param structs
178    [$($param:tt),+ $(,)?] => {
179        [
180            $(
181                $crate::params_internal!($param)
182            ),+
183        ]
184    };
185}
186
187/// Internal helper macro for params! - converts individual items to Param structs
188#[macro_export]
189macro_rules! params_internal {
190    // Colon-style named parameter
191    ({ $key:ident: $value:expr }) => {
192        $crate::ParamBind::new(stringify!($key), $crate::SQLiteValue::from($value))
193    };
194    // Positional parameter
195    ($value:expr) => {
196        $crate::ParamBind::new("", $crate::SQLiteValue::from($value))
197    };
198}
199
200pub type SQLiteSQL<'a> = SQL<'a, SQLiteValue<'a>>;
drizzle_sqlite/lib.rs

drizzle_sqlite/
lib.rs
