mirror of
https://github.com/launchbadge/sqlx.git
synced 2026-03-22 01:54:09 +00:00
393b731d5e
* feat: Implement `get_transaction_depth` for drivers
* test: Verify `get_transaction_depth()` on postgres
* Refactor: `TransactionManager` delegation without BC
SQLite implementation is currently WIP
* Fix: Avoid breaking changes on `AnyConnectionBackend`
* Refactor: Remove verbose `SqliteConnection` typing
* Feat: Implementation for SQLite
I have included `AtomicUsize` in `WorkerSharedState`. Ideally, it is not desirable to execute `load` and `fetch_add` in two separate steps, but we decided to allow it here since there is only one thread writing. To prevent writing from other threads, the field itself was made private, and a getter method was provided with `pub(crate)`.
* Refactor: Same approach for `cached_statements_size`
ref: a66787d36d
* Fix: Add missing `is_in_transaction` for backend
* Doc: Remove verbose "synchronously" word
* Fix: Remove useless `mut` qualifier
* feat: add Connection::begin_with
This patch completes the plumbing of an optional statement from these methods to
`TransactionManager::begin` without any validation of the provided statement.
There is a new `Error::InvalidSavePoint` which is triggered by any attempt to
call `Connection::begin_with` when we are already inside of a transaction.
* feat: add Pool::begin_with and Pool::try_begin_with
* feat: add Error::BeginFailed and validate that custom "begin" statements are successful
* chore: add tests of Error::BeginFailed
* chore: add tests of Error::InvalidSavePointStatement
* chore: test begin_with works for all SQLite "BEGIN" statements
* chore: improve comment on Connection::begin_with
* feat: add default impl of `Connection::begin_with`
This makes the new method a non-breaking change.
* refactor: combine if statement + unwrap_or_else into one match
* feat: use in-memory SQLite DB to avoid conflicts across tests run in parallel
* feedback: remove public wrapper for sqlite3_txn_state
Move the wrapper directly into the test that uses it instead.
* fix: cache Status on MySqlConnection
* fix: compilation errors
* fix: format
* fix: postgres test
* refactor: delete `Connection::get_transaction_depth`
* fix: tests
---------
Co-authored-by: mpyw <ryosuke_i_628@yahoo.co.jp>
Co-authored-by: Duncan Fairbanks <duncanfairbanks6@gmail.com>
111 lines
3.1 KiB
Rust
111 lines
3.1 KiB
Rust
use futures_core::future::BoxFuture;
|
|
use sqlx_core::database::Database;
|
|
use std::borrow::Cow;
|
|
|
|
use crate::error::Error;
|
|
use crate::executor::Executor;
|
|
|
|
use crate::{PgConnection, Postgres};
|
|
|
|
pub(crate) use sqlx_core::transaction::*;
|
|
|
|
/// Implementation of [`TransactionManager`] for PostgreSQL.
|
|
pub struct PgTransactionManager;
|
|
|
|
impl TransactionManager for PgTransactionManager {
|
|
type Database = Postgres;
|
|
|
|
fn begin<'conn>(
|
|
conn: &'conn mut PgConnection,
|
|
statement: Option<Cow<'static, str>>,
|
|
) -> BoxFuture<'conn, Result<(), Error>> {
|
|
Box::pin(async move {
|
|
let depth = conn.inner.transaction_depth;
|
|
let statement = match statement {
|
|
// custom `BEGIN` statements are not allowed if we're already in
|
|
// a transaction (we need to issue a `SAVEPOINT` instead)
|
|
Some(_) if depth > 0 => return Err(Error::InvalidSavePointStatement),
|
|
Some(statement) => statement,
|
|
None => begin_ansi_transaction_sql(depth),
|
|
};
|
|
|
|
let rollback = Rollback::new(conn);
|
|
rollback.conn.queue_simple_query(&statement)?;
|
|
rollback.conn.wait_until_ready().await?;
|
|
if !rollback.conn.in_transaction() {
|
|
return Err(Error::BeginFailed);
|
|
}
|
|
rollback.conn.inner.transaction_depth += 1;
|
|
rollback.defuse();
|
|
|
|
Ok(())
|
|
})
|
|
}
|
|
|
|
fn commit(conn: &mut PgConnection) -> BoxFuture<'_, Result<(), Error>> {
|
|
Box::pin(async move {
|
|
if conn.inner.transaction_depth > 0 {
|
|
conn.execute(&*commit_ansi_transaction_sql(conn.inner.transaction_depth))
|
|
.await?;
|
|
|
|
conn.inner.transaction_depth -= 1;
|
|
}
|
|
|
|
Ok(())
|
|
})
|
|
}
|
|
|
|
fn rollback(conn: &mut PgConnection) -> BoxFuture<'_, Result<(), Error>> {
|
|
Box::pin(async move {
|
|
if conn.inner.transaction_depth > 0 {
|
|
conn.execute(&*rollback_ansi_transaction_sql(
|
|
conn.inner.transaction_depth,
|
|
))
|
|
.await?;
|
|
|
|
conn.inner.transaction_depth -= 1;
|
|
}
|
|
|
|
Ok(())
|
|
})
|
|
}
|
|
|
|
fn start_rollback(conn: &mut PgConnection) {
|
|
if conn.inner.transaction_depth > 0 {
|
|
conn.queue_simple_query(&rollback_ansi_transaction_sql(conn.inner.transaction_depth))
|
|
.expect("BUG: Rollback query somehow too large for protocol");
|
|
|
|
conn.inner.transaction_depth -= 1;
|
|
}
|
|
}
|
|
|
|
fn get_transaction_depth(conn: &<Self::Database as Database>::Connection) -> usize {
|
|
conn.inner.transaction_depth
|
|
}
|
|
}
|
|
|
|
struct Rollback<'c> {
|
|
conn: &'c mut PgConnection,
|
|
defuse: bool,
|
|
}
|
|
|
|
impl Drop for Rollback<'_> {
|
|
fn drop(&mut self) {
|
|
if !self.defuse {
|
|
PgTransactionManager::start_rollback(self.conn)
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'c> Rollback<'c> {
|
|
fn new(conn: &'c mut PgConnection) -> Self {
|
|
Self {
|
|
conn,
|
|
defuse: false,
|
|
}
|
|
}
|
|
fn defuse(mut self) {
|
|
self.defuse = true;
|
|
}
|
|
}
|