Skip to main content

migratrom_sqlite/
lib.rs

1//! SQLite adapter for [`migratrom`], built on `sqlx`.
2//!
3//! Pins a single pooled connection so the manual `BEGIN`/`COMMIT`/`ROLLBACK`
4//! statements act on one session. SQLite has no advisory locks, so the dialect
5//! reports `advisory_locks: false` and locking is a no-op.
6
7use 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
26/// A [`Db`] over one pinned SQLite connection.
27pub struct SqliteAdapter {
28    inner: Mutex<Inner>,
29}
30
31impl SqliteAdapter {
32    /// Wrap an acquired pooled connection.
33    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    // SQLite returns 0/1 integers for our boolean probes.
53    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
134/// Apply migrations against a SQLite pool using [`SqliteDialect`].
135pub 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}