datasources_sqlite/
lib.rs1mod 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
93#[cfg(test)]
94mod tests {
95 use crate::command::SqliteCommand;
96 use crate::connection::SqliteConnection;
97 use crate::transaction::SqliteTransaction;
98 use datasources::{
99 Row, create, downcast_connection, register, reset, BuiltDatasource, Command,
100 Connection, Datasource, Driver, IsolationLevel, Transaction,
101 };
102 use std::collections::HashMap;
103 use std::sync::Arc;
104
105 struct With(Option<String>);
106
107 impl Driver for With {
108 fn connection(&self, _: Option<&HashMap<String, String>>) -> Arc<dyn Connection> {
109 Arc::new(SqliteConnection::new(self.0.clone()))
110 }
111
112 fn command(&self, connection: Arc<dyn Connection>) -> Arc<dyn Command> {
113 connection.create_command()
114 }
115
116 fn transaction(
117 &self,
118 connection: Arc<dyn Connection>,
119 isolation: IsolationLevel,
120 ) -> Arc<dyn Transaction> {
121 let conn = downcast_connection::<SqliteConnection>(connection).expect("sqlite");
122 Arc::new(SqliteTransaction::new(conn.share_pinned(), isolation))
123 }
124
125 fn row_type_converters(
126 &self,
127 ) -> HashMap<
128 String,
129 Box<
130 dyn datasources::TypeConverter<datasources::Value, datasources::Value>
131 + Send
132 + Sync,
133 >,
134 > {
135 crate::converters::row_type_converters()
136 }
137 }
138
139 #[tokio::test]
140 async fn sqlite_command_and_repository() {
141 let conn = Arc::new(SqliteConnection::new(Some(":memory:".into())));
142 conn.open().await.unwrap();
143 let command = SqliteCommand::new(conn.clone());
144 command
145 .execute_native(&datasources::Native::new(""), None)
146 .await
147 .unwrap();
148 command
149 .execute_native(
150 &datasources::Native::new("CREATE TABLE t (id INTEGER)"),
151 None,
152 )
153 .await
154 .unwrap();
155 command
156 .execute_native(
157 &datasources::Native::new("INSERT INTO t (id) VALUES (1) RETURNING id"),
158 None,
159 )
160 .await
161 .unwrap();
162 command
163 .execute_reader_native(&datasources::Native::new("SELECT 1"), None)
164 .await
165 .unwrap();
166 let sets = command
167 .execute_reader_native(
168 &datasources::Native::new("SELECT 1 AS id; SELECT 2 AS id"),
169 None,
170 )
171 .await
172 .unwrap();
173 let mut first = Vec::new();
174 while sets.next().await.unwrap() {
175 first.push(sets.current());
176 }
177 let moved = sets.next_result().await.unwrap();
178 let mut second = Vec::new();
179 while sets.next().await.unwrap() {
180 second.push(sets.current());
181 }
182 assert!(moved);
183 assert_eq!(
184 first[0].as_ref().unwrap().get("id"),
185 Some(&datasources::Value::Int(1))
186 );
187 assert_eq!(
188 second[0].as_ref().unwrap().get("id"),
189 Some(&datasources::Value::Int(2))
190 );
191 assert!(!sets.next_result().await.unwrap());
192 drop(sets);
193 command
194 .execute_reader_native(&datasources::Native::new(""), None)
195 .await
196 .unwrap();
197 let txn = conn.start_transaction(None).await.unwrap();
198 assert_eq!(
199 datasources::Transaction::isolation(&*txn),
200 IsolationLevel::ReadCommitted
201 );
202 txn.commit().await.unwrap();
203 let txn = conn
204 .start_transaction(Some(IsolationLevel::ReadUncommitted))
205 .await
206 .unwrap();
207 assert_eq!(
208 datasources::Transaction::isolation(&*txn),
209 IsolationLevel::ReadUncommitted
210 );
211 txn.abort().await.unwrap();
212 conn.close().await.unwrap();
213 assert!(conn.ensure_open().is_err());
214 assert!(conn.start_transaction(None).await.is_err());
215
216 let shared = Arc::new(SqliteConnection::new(Some(
217 "file:iso?mode=memory&cache=shared".into(),
218 )));
219 shared.open().await.unwrap();
220 let read_committed = shared
221 .start_transaction(Some(IsolationLevel::ReadCommitted))
222 .await
223 .unwrap();
224 assert_eq!(
225 datasources::Transaction::isolation(&*read_committed),
226 IsolationLevel::ReadCommitted
227 );
228 read_committed.abort().await.unwrap();
229 shared.close().await.unwrap();
230
231 let defaulted = SqliteConnection::new(None);
232 assert_eq!(defaulted.filename, ":memory:");
233 reset();
234 register("sqlite", Arc::new(With(Some(":memory:".into()))));
235 let ds = create(Some(&HashMap::from([("PROVIDER".into(), "sqlite".into())]))).unwrap();
236 assert_eq!(ds.provider(), "sqlite");
237 ds.create_connection().await.unwrap();
238 let command = ds.create_command(None).await.unwrap();
239 assert!(command.execute("DELETE FROM items", None).await.is_err());
240 command
241 .execute_reader_native(&datasources::Native::new("SELECT 1"), None)
242 .await
243 .unwrap();
244 ds.create_repository::<Row>(None, None);
245 let factory = BuiltDatasource::new("sqlite", Arc::new(With(None)), None);
246 factory.create_connection().await.unwrap();
247 let bound = factory
248 .create_command(Some(factory.create_connection().await.unwrap()))
249 .await
250 .unwrap();
251 assert!(bound.execute("DELETE FROM items", None).await.is_err());
252 assert!(bound
253 .execute_reader_native(&datasources::Native::new("SELECT 1"), None)
254 .await
255 .is_err());
256 (&factory as &dyn Datasource)
257 .create_repository::<Row>(Some(factory.create_connection().await.unwrap()), None);
258
259 let closed = Arc::new(SqliteConnection::new(None));
260 assert!(SqliteCommand::new(closed)
261 .execute_native(&datasources::Native::new("x"), None)
262 .await
263 .is_err());
264 }
265
266 #[tokio::test]
267 async fn return_statement_selects_scalar() {
268 use datasources::{Parameter, ReturnStatement};
269 let conn = Arc::new(SqliteConnection::new(Some(":memory:".into())));
270 conn.open().await.unwrap();
271 let command = SqliteCommand::new(conn);
272 let parameters = [Parameter::new("x", -3_i64)];
273 let response = command
274 .execute_statement(&ReturnStatement::new("abs", ¶meters), Some(¶meters))
275 .await
276 .unwrap();
277 assert_eq!(response.result, datasources::Value::Int(3));
278 }
279}