sqlx-firebirdsql 0.1.0

Firebird SQL driver for SQLx
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

use crate::connection::AssertSend;
use crate::error::{firebird_err, Error};
use crate::{Firebird, FirebirdConnection};

use sqlx_core::sql_str::SqlStr;
use sqlx_core::transaction::TransactionManager;

/// Implementation of [`TransactionManager`] for Firebird.
pub struct FirebirdTransactionManager;

impl TransactionManager for FirebirdTransactionManager {
    type Database = Firebird;

    fn begin(
        conn: &mut FirebirdConnection,
        statement: Option<SqlStr>,
    ) -> impl std::future::Future<Output = Result<(), Error>> + Send + '_ {
        let inner = conn.inner.clone();
        let depth = conn.transaction_depth;
        AssertSend(async move {
            if depth == 0 {
                if let Some(statement) = statement {
                    let mut guard = inner.lock().await;
                    guard
                        .execute_batch(statement.as_str())
                        .await
                        .map_err(firebird_err)?;
                }
                // Firebird auto-starts transactions; just track depth.
            } else {
                if statement.is_some() {
                    return Err(Error::InvalidSavePointStatement);
                }
                let sql = format!("SAVEPOINT _sqlx_savepoint_{depth}");
                let mut guard = inner.lock().await;
                guard.execute_batch(&sql).await.map_err(firebird_err)?;
            }

            conn.transaction_depth += 1;
            Ok(())
        })
    }

    fn commit(
        conn: &mut FirebirdConnection,
    ) -> impl std::future::Future<Output = Result<(), Error>> + Send + '_ {
        let inner = conn.inner.clone();
        let depth = conn.transaction_depth;
        AssertSend(async move {
            if depth > 0 {
                if depth == 1 {
                    let guard = inner.lock().await;
                    guard.commit().await.map_err(firebird_err)?;
                } else {
                    let sql = format!("RELEASE SAVEPOINT _sqlx_savepoint_{}", depth - 1);
                    let mut guard = inner.lock().await;
                    guard.execute_batch(&sql).await.map_err(firebird_err)?;
                }
                conn.transaction_depth = depth - 1;
            }
            Ok(())
        })
    }

    fn rollback(
        conn: &mut FirebirdConnection,
    ) -> impl std::future::Future<Output = Result<(), Error>> + Send + '_ {
        let inner = conn.inner.clone();
        let depth = conn.transaction_depth;
        AssertSend(async move {
            if depth > 0 {
                if depth == 1 {
                    let mut guard = inner.lock().await;
                    guard.rollback().await.map_err(firebird_err)?;
                } else {
                    let sql = format!("ROLLBACK TO SAVEPOINT _sqlx_savepoint_{}", depth - 1);
                    let mut guard = inner.lock().await;
                    guard.execute_batch(&sql).await.map_err(firebird_err)?;
                }
                conn.transaction_depth = depth - 1;
            }
            Ok(())
        })
    }

    fn start_rollback(conn: &mut FirebirdConnection) {
        let depth = conn.transaction_depth;
        if depth > 0 {
            conn.transaction_depth = depth - 1;
        }
    }

    fn get_transaction_depth(conn: &FirebirdConnection) -> usize {
        conn.transaction_depth
    }
}