switchy_database/simulator/
mod.rs

1use async_trait::async_trait;
2
3use crate::{
4    Database, DatabaseError, Row,
5    query::{
6        DeleteStatement, InsertStatement, SelectQuery, UpdateStatement, UpsertMultiStatement,
7        UpsertStatement,
8    },
9    rusqlite::RusqliteDatabase,
10};
11
12#[allow(clippy::module_name_repetitions)]
13#[derive(Debug)]
14pub struct SimulationDatabase {
15    inner: RusqliteDatabase,
16}
17
18impl SimulationDatabase {
19    /// # Errors
20    ///
21    /// * If the database connection fails to open in memory
22    pub fn new() -> Result<Self, DatabaseError> {
23        let library = ::rusqlite::Connection::open_in_memory()
24            .map_err(|e| DatabaseError::Rusqlite(e.into()))?;
25        library
26            .busy_timeout(std::time::Duration::from_millis(10))
27            .map_err(|e| DatabaseError::Rusqlite(e.into()))?;
28        let library = std::sync::Arc::new(tokio::sync::Mutex::new(library));
29        Ok(Self {
30            inner: RusqliteDatabase::new(library),
31        })
32    }
33}
34
35#[async_trait]
36impl Database for SimulationDatabase {
37    async fn query(&self, query: &SelectQuery<'_>) -> Result<Vec<Row>, DatabaseError> {
38        self.inner.query(query).await
39    }
40
41    async fn query_first(&self, query: &SelectQuery<'_>) -> Result<Option<Row>, DatabaseError> {
42        self.inner.query_first(query).await
43    }
44
45    async fn exec_update(
46        &self,
47        statement: &UpdateStatement<'_>,
48    ) -> Result<Vec<Row>, DatabaseError> {
49        self.inner.exec_update(statement).await
50    }
51
52    async fn exec_update_first(
53        &self,
54        statement: &UpdateStatement<'_>,
55    ) -> Result<Option<Row>, DatabaseError> {
56        self.inner.exec_update_first(statement).await
57    }
58
59    async fn exec_insert(&self, statement: &InsertStatement<'_>) -> Result<Row, DatabaseError> {
60        self.inner.exec_insert(statement).await
61    }
62
63    async fn exec_upsert(
64        &self,
65        statement: &UpsertStatement<'_>,
66    ) -> Result<Vec<Row>, DatabaseError> {
67        self.inner.exec_upsert(statement).await
68    }
69
70    async fn exec_upsert_first(
71        &self,
72        statement: &UpsertStatement<'_>,
73    ) -> Result<Row, DatabaseError> {
74        self.inner.exec_upsert_first(statement).await
75    }
76
77    async fn exec_upsert_multi(
78        &self,
79        statement: &UpsertMultiStatement<'_>,
80    ) -> Result<Vec<Row>, DatabaseError> {
81        self.inner.exec_upsert_multi(statement).await
82    }
83
84    async fn exec_delete(
85        &self,
86        statement: &DeleteStatement<'_>,
87    ) -> Result<Vec<Row>, DatabaseError> {
88        self.inner.exec_delete(statement).await
89    }
90
91    async fn exec_delete_first(
92        &self,
93        statement: &DeleteStatement<'_>,
94    ) -> Result<Option<Row>, DatabaseError> {
95        self.inner.exec_delete_first(statement).await
96    }
97
98    async fn exec_raw(&self, statement: &str) -> Result<(), DatabaseError> {
99        self.inner.exec_raw(statement).await
100    }
101
102    #[cfg(feature = "schema")]
103    async fn exec_create_table(
104        &self,
105        statement: &crate::schema::CreateTableStatement<'_>,
106    ) -> Result<(), DatabaseError> {
107        self.inner.exec_create_table(statement).await
108    }
109}