Method begin

src/database/transaction.rs:32–91

(
        conn: Arc<Mutex<InnerConnection>>,
        backend: DbBackend,
        metric_callback: Option<crate::metric::Callback>,
        isolation_level: Option<IsolationLevel>,
        access_mode:

impl DatabaseTransaction {
    #[instrument(level = "trace", skip(metric_callback))]
    pub(crate) async fn begin(
        conn: Arc<Mutex<InnerConnection>>,
        backend: DbBackend,
        metric_callback: Option<crate::metric::Callback>,
        isolation_level: Option<IsolationLevel>,
        access_mode: Option<AccessMode>,
    ) -> Result<DatabaseTransaction, DbErr> {
        let res = DatabaseTransaction {
            conn,
            backend,
            open: true,
            metric_callback,
        };
        match *res.conn.lock().await {
            #[cfg(feature = "sqlx-mysql")]
            InnerConnection::MySql(ref mut c) => {
                // in MySQL SET TRANSACTION operations must be executed before transaction start
                crate::driver::sqlx_mysql::set_transaction_config(c, isolation_level, access_mode)
                    .await?;
                <sqlx::MySql as sqlx::Database>::TransactionManager::begin(c, None)
                    .await
                    .map_err(sqlx_error_to_query_err)
            }
            #[cfg(feature = "sqlx-postgres")]
            InnerConnection::Postgres(ref mut c) => {
                <sqlx::Postgres as sqlx::Database>::TransactionManager::begin(c, None)
                    .await
                    .map_err(sqlx_error_to_query_err)?;
                // in PostgreSQL SET TRANSACTION operations must be executed inside transaction
                crate::driver::sqlx_postgres::set_transaction_config(
                    c,
                    isolation_level,
                    access_mode,
                )
                .await
            }
            #[cfg(feature = "sqlx-sqlite")]
            InnerConnection::Sqlite(ref mut c) => {
                // in SQLite isolation level and access mode are global settings
                crate::driver::sqlx_sqlite::set_transaction_config(c, isolation_level, access_mode)
                    .await?;
                <sqlx::Sqlite as sqlx::Database>::TransactionManager::begin(c, None)
                    .await
                    .map_err(sqlx_error_to_query_err)
            }
            #[cfg(feature = "mock")]
            InnerConnection::Mock(ref mut c) => {
                c.begin();
                Ok(())
            }
            #[cfg(feature = "proxy")]
            InnerConnection::Proxy(ref mut c) => {
                c.begin().await;
                Ok(())
            }
            #[allow(unreachable_patterns)]
            _ => Err(conn_err("Disconnected")),
        }?;