1use async_trait::async_trait;
8use migratrom::{
9 apply_migrations as core_apply, ApplyOptions, ApplyResult, Db, Migration, MigratromError, Row,
10 SqliteDialect,
11};
12use sqlx::pool::PoolConnection;
13use sqlx::sqlite::SqliteRow;
14use sqlx::{Row as SqlxRow, Sqlite, SqlitePool};
15use tokio::sync::Mutex;
16
17fn db_err(e: sqlx::Error) -> MigratromError {
18 MigratromError::Db(e.to_string())
19}
20
21struct Inner {
22 conn: PoolConnection<Sqlite>,
23 depth: u32,
24}
25
26pub struct SqliteAdapter {
28 inner: Mutex<Inner>,
29}
30
31impl SqliteAdapter {
32 pub fn new(conn: PoolConnection<Sqlite>) -> Self {
34 Self {
35 inner: Mutex::new(Inner { conn, depth: 0 }),
36 }
37 }
38}
39
40struct SqliteRowWrap(SqliteRow);
41
42impl Row for SqliteRowWrap {
43 fn i64_at(&self, idx: usize) -> Option<i64> {
44 self.0.try_get::<i64, _>(idx).ok()
45 }
46 fn str_at(&self, idx: usize) -> Option<String> {
47 self.0.try_get::<String, _>(idx).ok()
48 }
49}
50
51fn read_check(row: &SqliteRow) -> Result<bool, MigratromError> {
52 if let Ok(i) = row.try_get::<i64, _>(0) {
54 return Ok(i != 0);
55 }
56 match row.try_get::<bool, _>(0) {
57 Ok(b) => Ok(b),
58 Err(e) => Err(MigratromError::CheckShape {
59 message: format!("check must return a boolean: {e}"),
60 row_preview: None,
61 }),
62 }
63}
64
65#[async_trait]
66impl Db for SqliteAdapter {
67 async fn query_bool(&self, sql: &str) -> Result<bool, MigratromError> {
68 let mut g = self.inner.lock().await;
69 let row = sqlx::query(sql)
70 .fetch_one(&mut *g.conn)
71 .await
72 .map_err(db_err)?;
73 read_check(&row)
74 }
75
76 async fn execute(&self, sql: &str) -> Result<(), MigratromError> {
77 let mut g = self.inner.lock().await;
78 sqlx::query(sql)
79 .execute(&mut *g.conn)
80 .await
81 .map_err(db_err)?;
82 Ok(())
83 }
84
85 async fn query_rows(&self, sql: &str) -> Result<Vec<Box<dyn Row>>, MigratromError> {
86 let mut g = self.inner.lock().await;
87 let rows = sqlx::query(sql)
88 .fetch_all(&mut *g.conn)
89 .await
90 .map_err(db_err)?;
91 Ok(rows
92 .into_iter()
93 .map(|r| Box::new(SqliteRowWrap(r)) as Box<dyn Row>)
94 .collect())
95 }
96
97 async fn begin(&self) -> Result<(), MigratromError> {
98 let mut g = self.inner.lock().await;
99 if g.depth == 0 {
100 sqlx::query("BEGIN")
101 .execute(&mut *g.conn)
102 .await
103 .map_err(db_err)?;
104 }
105 g.depth += 1;
106 Ok(())
107 }
108
109 async fn commit(&self) -> Result<(), MigratromError> {
110 let mut g = self.inner.lock().await;
111 g.depth -= 1;
112 if g.depth == 0 {
113 sqlx::query("COMMIT")
114 .execute(&mut *g.conn)
115 .await
116 .map_err(db_err)?;
117 }
118 Ok(())
119 }
120
121 async fn rollback(&self) -> Result<(), MigratromError> {
122 let mut g = self.inner.lock().await;
123 g.depth -= 1;
124 if g.depth == 0 {
125 sqlx::query("ROLLBACK")
126 .execute(&mut *g.conn)
127 .await
128 .map_err(db_err)?;
129 }
130 Ok(())
131 }
132}
133
134pub async fn apply_migrations(
136 migrations: &[Migration],
137 pool: &SqlitePool,
138 options: &ApplyOptions,
139) -> Result<ApplyResult, MigratromError> {
140 let conn = pool.acquire().await.map_err(db_err)?;
141 let adapter = SqliteAdapter::new(conn);
142 core_apply(migrations, &adapter, &SqliteDialect, options).await
143}