migratrom_postgres/
lib.rs1#![deny(missing_docs)]
58
59use async_trait::async_trait;
60use migratrom::{
61 apply_migrations as core_apply, ApplyOptions, ApplyResult, Db, Migration, MigratromError,
62 PostgresDialect, Row,
63};
64use sqlx::pool::PoolConnection;
65use sqlx::postgres::PgRow;
66use sqlx::{PgPool, Postgres, Row as SqlxRow};
67use tokio::sync::Mutex;
68
69fn db_err(e: sqlx::Error) -> MigratromError {
70 MigratromError::Db(e.to_string())
71}
72
73struct Inner {
74 conn: PoolConnection<Postgres>,
75 depth: u32,
77}
78
79pub struct PostgresAdapter {
81 inner: Mutex<Inner>,
82}
83
84impl PostgresAdapter {
85 pub fn new(conn: PoolConnection<Postgres>) -> Self {
87 Self {
88 inner: Mutex::new(Inner { conn, depth: 0 }),
89 }
90 }
91}
92
93struct PgRowWrap(PgRow);
94
95impl Row for PgRowWrap {
96 fn i64_at(&self, idx: usize) -> Option<i64> {
97 self.0.try_get::<i64, _>(idx).ok()
98 }
99 fn str_at(&self, idx: usize) -> Option<String> {
100 self.0.try_get::<String, _>(idx).ok()
101 }
102}
103
104fn read_check(row: &PgRow) -> Result<bool, MigratromError> {
105 if let Ok(b) = row.try_get::<bool, _>(0) {
106 return Ok(b);
107 }
108 match row.try_get::<i64, _>(0) {
109 Ok(i) => Ok(i != 0),
110 Err(e) => Err(MigratromError::CheckShape {
111 message: format!("check must return a boolean: {e}"),
112 row_preview: None,
113 }),
114 }
115}
116
117#[async_trait]
118impl Db for PostgresAdapter {
119 async fn query_bool(&self, sql: &str) -> Result<bool, MigratromError> {
120 let mut g = self.inner.lock().await;
121 let row = sqlx::query(sql)
122 .fetch_one(&mut *g.conn)
123 .await
124 .map_err(db_err)?;
125 read_check(&row)
126 }
127
128 async fn execute(&self, sql: &str) -> Result<(), MigratromError> {
129 let mut g = self.inner.lock().await;
130 sqlx::query(sql)
131 .execute(&mut *g.conn)
132 .await
133 .map_err(db_err)?;
134 Ok(())
135 }
136
137 async fn query_rows(&self, sql: &str) -> Result<Vec<Box<dyn Row>>, MigratromError> {
138 let mut g = self.inner.lock().await;
139 let rows = sqlx::query(sql)
140 .fetch_all(&mut *g.conn)
141 .await
142 .map_err(db_err)?;
143 Ok(rows
144 .into_iter()
145 .map(|r| Box::new(PgRowWrap(r)) as Box<dyn Row>)
146 .collect())
147 }
148
149 async fn begin(&self) -> Result<(), MigratromError> {
150 let mut g = self.inner.lock().await;
151 if g.depth == 0 {
152 sqlx::query("BEGIN")
153 .execute(&mut *g.conn)
154 .await
155 .map_err(db_err)?;
156 }
157 g.depth += 1;
158 Ok(())
159 }
160
161 async fn commit(&self) -> Result<(), MigratromError> {
162 let mut g = self.inner.lock().await;
163 g.depth -= 1;
164 if g.depth == 0 {
165 sqlx::query("COMMIT")
166 .execute(&mut *g.conn)
167 .await
168 .map_err(db_err)?;
169 }
170 Ok(())
171 }
172
173 async fn rollback(&self) -> Result<(), MigratromError> {
174 let mut g = self.inner.lock().await;
175 g.depth -= 1;
176 if g.depth == 0 {
177 sqlx::query("ROLLBACK")
178 .execute(&mut *g.conn)
179 .await
180 .map_err(db_err)?;
181 }
182 Ok(())
183 }
184}
185
186pub async fn apply_migrations(
191 migrations: &[Migration],
192 pool: &PgPool,
193 options: &ApplyOptions,
194) -> Result<ApplyResult, MigratromError> {
195 let conn = pool.acquire().await.map_err(db_err)?;
196 let adapter = PostgresAdapter::new(conn);
197 core_apply(migrations, &adapter, &PostgresDialect, options).await
198}