Skip to main content

datasources_sqlite/
lib.rs

1mod alter_table_statement_renderer;
2mod command;
3mod connection;
4mod connection_string;
5mod converters;
6mod create_table_statement_renderer;
7mod create_trigger_statement_renderer;
8mod driver;
9mod pool;
10mod reader;
11mod select_inserted_id_statement_text_renderer;
12mod sqlite_path;
13mod default_value_converter;
14mod default_value_options;
15mod sql_generate;
16mod sql_seed_statement_renderer;
17mod type_map;
18mod quoted_renderers;
19mod statement_renderer;
20mod transaction;
21
22pub use driver::SqliteDriver;
23
24#[cfg(test)]
25pub(crate) fn boolean_schema() -> datasources::Schema {
26    use datasources::SchemaColumn;
27    use std::collections::HashMap;
28    datasources::Schema::new(HashMap::from([
29        ("IsEnabled".into(), SchemaColumn::new("boolean")),
30        ("is_enabled".into(), SchemaColumn::new("boolean")),
31        ("Active".into(), SchemaColumn::new("boolean")),
32    ]))
33}
34
35#[cfg(test)]
36pub(crate) fn env_lock() -> std::sync::MutexGuard<'static, ()> {
37    static LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
38    let guard = LOCK.lock().unwrap_or_else(|error| error.into_inner());
39    std::env::remove_var("INSTALLED_PROVIDERS");
40    std::env::remove_var("DATASOURCE_URL");
41    std::env::set_var("PROVIDER", "sqlite");
42    datasources::reset();
43    datasources::register("sqlite", std::sync::Arc::new(crate::SqliteDriver));
44    guard
45}
46
47#[cfg(test)]
48#[path = "../tests/command.rs"]
49mod command_tests;
50#[cfg(test)]
51#[path = "../tests/concurrency.rs"]
52mod concurrency;
53#[cfg(test)]
54#[path = "../tests/contacts.rs"]
55mod contacts;
56#[cfg(test)]
57#[path = "../tests/create_from_driver.rs"]
58mod create_from_driver;
59#[cfg(test)]
60#[path = "../tests/datasource_plural.rs"]
61mod datasource_plural;
62#[cfg(test)]
63#[path = "../tests/integration.rs"]
64mod integration;
65#[cfg(test)]
66#[path = "../tests/null_write.rs"]
67mod null_write;
68#[cfg(test)]
69#[path = "../tests/read_pipeline.rs"]
70mod read_pipeline;
71#[cfg(test)]
72#[path = "../tests/readonly_repository.rs"]
73mod readonly_repository;
74#[cfg(test)]
75#[path = "../tests/repository_spec.rs"]
76mod repository_spec;
77#[cfg(test)]
78#[path = "../tests/foreign_key_type.rs"]
79mod foreign_key_type;
80#[cfg(test)]
81#[path = "../tests/generate_sql.rs"]
82mod generate_sql;
83#[cfg(test)]
84#[path = "../tests/driver_converters.rs"]
85mod driver_converters;
86#[cfg(test)]
87#[path = "../tests/typed_list_enrichment.rs"]
88mod typed_list_enrichment;
89#[cfg(test)]
90#[path = "../tests/bulk_write_enrichment.rs"]
91mod bulk_write_enrichment;
92#[cfg(test)]
93#[path = "../tests/tree_graph_enrichment.rs"]
94mod tree_graph_enrichment;
95
96#[cfg(test)]
97mod tests {
98    use crate::command::SqliteCommand;
99    use crate::connection::SqliteConnection;
100    use crate::transaction::SqliteTransaction;
101    use datasources::{
102        Row, create, downcast_connection, register, reset, BuiltDatasource, Command,
103        Connection, Datasource, Driver, IsolationLevel, Transaction,
104    };
105    use std::collections::HashMap;
106    use std::sync::Arc;
107
108    struct With(Option<String>);
109
110    impl Driver for With {
111        fn connection(&self, _: Option<&HashMap<String, String>>) -> Arc<dyn Connection> {
112            Arc::new(SqliteConnection::new(self.0.clone()))
113        }
114
115        fn command(&self, connection: Arc<dyn Connection>) -> Arc<dyn Command> {
116            connection.create_command()
117        }
118
119        fn transaction(
120            &self,
121            connection: Arc<dyn Connection>,
122            isolation: IsolationLevel,
123        ) -> Arc<dyn Transaction> {
124            let conn = downcast_connection::<SqliteConnection>(connection).expect("sqlite");
125            Arc::new(SqliteTransaction::new(conn.share_pinned(), isolation))
126        }
127
128        fn row_type_converters(
129            &self,
130        ) -> HashMap<
131            String,
132            Box<
133                dyn datasources::TypeConverter<datasources::Value, datasources::Value>
134                    + Send
135                    + Sync,
136            >,
137        > {
138            crate::converters::row_type_converters()
139        }
140    }
141
142    #[tokio::test]
143    async fn sqlite_command_and_repository() {
144        let conn = Arc::new(SqliteConnection::new(Some(":memory:".into())));
145        conn.open().await.unwrap();
146        let command = SqliteCommand::new(conn.clone());
147        command
148            .execute_native(&datasources::Native::new(""), None)
149            .await
150            .unwrap();
151        command
152            .execute_native(
153                &datasources::Native::new("CREATE TABLE t (id INTEGER)"),
154                None,
155            )
156            .await
157            .unwrap();
158        command
159            .execute_native(
160                &datasources::Native::new("INSERT INTO t (id) VALUES (1) RETURNING id"),
161                None,
162            )
163            .await
164            .unwrap();
165        command
166            .execute_reader_native(&datasources::Native::new("SELECT 1"), None)
167            .await
168            .unwrap();
169        let sets = command
170            .execute_reader_native(
171                &datasources::Native::new("SELECT 1 AS id; SELECT 2 AS id"),
172                None,
173            )
174            .await
175            .unwrap();
176        let mut first = Vec::new();
177        while sets.next().await.unwrap() {
178            first.push(sets.current());
179        }
180        let moved = sets.next_result().await.unwrap();
181        let mut second = Vec::new();
182        while sets.next().await.unwrap() {
183            second.push(sets.current());
184        }
185        assert!(moved);
186        assert_eq!(
187            first[0].as_ref().unwrap().get("id"),
188            Some(&datasources::Value::Int(1))
189        );
190        assert_eq!(
191            second[0].as_ref().unwrap().get("id"),
192            Some(&datasources::Value::Int(2))
193        );
194        assert!(!sets.next_result().await.unwrap());
195        drop(sets);
196        command
197            .execute_reader_native(&datasources::Native::new(""), None)
198            .await
199            .unwrap();
200        let txn = conn.start_transaction(None).await.unwrap();
201        assert_eq!(
202            datasources::Transaction::isolation(&*txn),
203            IsolationLevel::ReadCommitted
204        );
205        txn.commit().await.unwrap();
206        let txn = conn
207            .start_transaction(Some(IsolationLevel::ReadUncommitted))
208            .await
209            .unwrap();
210        assert_eq!(
211            datasources::Transaction::isolation(&*txn),
212            IsolationLevel::ReadUncommitted
213        );
214        txn.abort().await.unwrap();
215        conn.close().await.unwrap();
216        assert!(conn.ensure_open().is_err());
217        assert!(conn.start_transaction(None).await.is_err());
218
219        let shared = Arc::new(SqliteConnection::new(Some(
220            "file:iso?mode=memory&cache=shared".into(),
221        )));
222        shared.open().await.unwrap();
223        let read_committed = shared
224            .start_transaction(Some(IsolationLevel::ReadCommitted))
225            .await
226            .unwrap();
227        assert_eq!(
228            datasources::Transaction::isolation(&*read_committed),
229            IsolationLevel::ReadCommitted
230        );
231        read_committed.abort().await.unwrap();
232        shared.close().await.unwrap();
233
234        let defaulted = SqliteConnection::new(None);
235        assert_eq!(defaulted.filename, ":memory:");
236        reset();
237        register("sqlite", Arc::new(With(Some(":memory:".into()))));
238        let ds = create(Some(&HashMap::from([("PROVIDER".into(), "sqlite".into())]))).unwrap();
239        assert_eq!(ds.provider(), "sqlite");
240        ds.create_connection().await.unwrap();
241        let command = ds.create_command(None).await.unwrap();
242        assert!(command.execute("DELETE FROM items", None).await.is_err());
243        command
244            .execute_reader_native(&datasources::Native::new("SELECT 1"), None)
245            .await
246            .unwrap();
247        ds.create_repository::<Row>(None, None);
248        let factory = BuiltDatasource::new("sqlite", Arc::new(With(None)), None);
249        factory.create_connection().await.unwrap();
250        let bound = factory
251            .create_command(Some(factory.create_connection().await.unwrap()))
252            .await
253            .unwrap();
254        assert!(bound.execute("DELETE FROM items", None).await.is_err());
255        assert!(bound
256            .execute_reader_native(&datasources::Native::new("SELECT 1"), None)
257            .await
258            .is_err());
259        (&factory as &dyn Datasource)
260            .create_repository::<Row>(Some(factory.create_connection().await.unwrap()), None);
261
262        let closed = Arc::new(SqliteConnection::new(None));
263        assert!(SqliteCommand::new(closed)
264            .execute_native(&datasources::Native::new("x"), None)
265            .await
266            .is_err());
267    }
268
269    #[tokio::test]
270    async fn return_statement_selects_scalar() {
271        use datasources::{Parameter, ReturnStatement};
272        let conn = Arc::new(SqliteConnection::new(Some(":memory:".into())));
273        conn.open().await.unwrap();
274        let command = SqliteCommand::new(conn);
275        let parameters = [Parameter::new("x", -3_i64)];
276        let response = command
277            .execute_statement(&ReturnStatement::new("abs", &parameters), Some(&parameters))
278            .await
279            .unwrap();
280        assert_eq!(response.result, datasources::Value::Int(3));
281    }
282}