diff --git a/quaint/src/connector/mssql/native/mod.rs b/quaint/src/connector/mssql/native/mod.rs
index 8eda2704674..5941b3c73d1 100644
--- a/quaint/src/connector/mssql/native/mod.rs
+++ b/quaint/src/connector/mssql/native/mod.rs
@@ -15,6 +15,7 @@ use crate::{
 };
 use async_trait::async_trait;
 use futures::lock::Mutex;
+use std::borrow::Cow;
 use std::{
     convert::TryFrom,
     future::Future,
@@ -242,40 +243,32 @@ impl Queryable for Mssql {
     }
 
     /// Statement to begin a transaction
-    async fn begin_statement(&self, depth: i32) -> String {
-        let savepoint_stmt = format!("SAVE TRANSACTION savepoint{}", depth);
-        let ret = if depth > 1 {
-            savepoint_stmt
+    fn begin_statement(&self, depth: u32) -> Cow<'static, str> {
+        if depth > 1 {
+            Cow::Owned(format!("SAVEPOINT TRANSACTION savepoint{depth}"))
         } else {
-            "BEGIN TRAN".to_string()
-        };
-
-        return ret;
+            Cow::Borrowed("BEGIN TRAN")
+        }
     }
 
     /// Statement to commit a transaction
-    async fn commit_statement(&self, depth: i32) -> String {
+    fn commit_statement(&self, depth: u32) -> Cow<'static, str> {
         // MSSQL doesn't have a "RELEASE SAVEPOINT" equivalent, so in a nested
         // transaction we just continue onwards
-        let ret = if depth > 1 {
-            " ".to_string()
+        if depth > 1 {
+            Cow::Owned("".to_string())
         } else {
-            "COMMIT".to_string()
-        };
-
-        return ret;
+            Cow::Borrowed("COMMIT")
+        }
     }
 
     /// Statement to rollback a transaction
-    async fn rollback_statement(&self, depth: i32) -> String {
-        let savepoint_stmt = format!("ROLLBACK TRANSACTION savepoint{}", depth);
-        let ret = if depth > 1 {
-            savepoint_stmt
+    fn rollback_statement(&self, depth: u32) -> Cow<'static, str> {
+        if depth > 1 {
+            Cow::Owned(format!("ROLLBACK TRANSACTION savepoint{depth}"))
         } else {
-            "ROLLBACK".to_string()
-        };
-
-        return ret;
+            Cow::Borrowed("ROLLBACK")
+        }
     }
 
     fn requires_isolation_first(&self) -> bool {
diff --git a/quaint/src/connector/mysql/native/mod.rs b/quaint/src/connector/mysql/native/mod.rs
index fc0b9667e19..0282733ea7a 100644
--- a/quaint/src/connector/mysql/native/mod.rs
+++ b/quaint/src/connector/mysql/native/mod.rs
@@ -21,6 +21,7 @@ use mysql_async::{
     self as my,
     prelude::{Query as _, Queryable as _},
 };
+use std::borrow::Cow;
 use std::{
     future::Future,
     sync::atomic::{AtomicBool, Ordering},
@@ -347,34 +348,29 @@ impl Queryable for Mysql {
     }
 
     /// Statement to begin a transaction
-    async fn begin_statement(&self, depth: i32) -> String {
-        let savepoint_stmt = format!("SAVEPOINT savepoint{}", depth);
-        let ret = if depth > 1 { savepoint_stmt } else { "BEGIN".to_string() };
-
-        return ret;
+    fn begin_statement(&self, depth: u32) -> Cow<'static, str> {
+        if depth > 1 {
+            Cow::Owned(format!("SAVEPOINT savepoint{depth}"))
+        } else {
+            Cow::Borrowed("BEGIN")
+        }
     }
 
     /// Statement to commit a transaction
-    async fn commit_statement(&self, depth: i32) -> String {
-        let savepoint_stmt = format!("RELEASE SAVEPOINT savepoint{}", depth);
-        let ret = if depth > 1 {
-            savepoint_stmt
+    fn commit_statement(&self, depth: u32) -> Cow<'static, str> {
+        if depth > 1 {
+            Cow::Owned(format!("RELEASE SAVEPOINT savepoint{depth}"))
         } else {
-            "COMMIT".to_string()
-        };
-
-        return ret;
+            Cow::Borrowed("COMMIT")
+        }
     }
 
     /// Statement to rollback a transaction
-    async fn rollback_statement(&self, depth: i32) -> String {
-        let savepoint_stmt = format!("ROLLBACK TO savepoint{}", depth);
-        let ret = if depth > 1 {
-            savepoint_stmt
+    fn rollback_statement(&self, depth: u32) -> Cow<'static, str> {
+        if depth > 1 {
+            Cow::Owned(format!("ROLLBACK TO savepoint{depth}"))
         } else {
-            "ROLLBACK".to_string()
-        };
-
-        return ret;
+            Cow::Borrowed("ROLLBACK")
+        }
     }
 }
diff --git a/quaint/src/connector/postgres/native/mod.rs b/quaint/src/connector/postgres/native/mod.rs
index 825cf2cabf9..3372ef4291e 100644
--- a/quaint/src/connector/postgres/native/mod.rs
+++ b/quaint/src/connector/postgres/native/mod.rs
@@ -27,6 +27,7 @@ use lru_cache::LruCache;
 use native_tls::{Certificate, Identity, TlsConnector};
 use postgres_native_tls::MakeTlsConnector;
 use postgres_types::{Kind as PostgresKind, Type as PostgresType};
+use std::borrow::Cow;
 use std::hash::{DefaultHasher, Hash, Hasher};
 use std::{
     borrow::Borrow,
@@ -765,36 +766,30 @@ impl Queryable for PostgreSql {
     }
 
     /// Statement to begin a transaction
-    async fn begin_statement(&self, depth: i32) -> String {
-        println!("pg connector: Transaction depth: {}", depth);
-        let savepoint_stmt = format!("SAVEPOINT savepoint{}", depth);
-        let ret = if depth > 1 { savepoint_stmt } else { "BEGIN".to_string() };
-
-        return ret;
+    fn begin_statement(&self, depth: u32) -> Cow<'static, str> {
+        if depth > 1 {
+            Cow::Owned(format!("SAVEPOINT savepoint{depth}"))
+        } else {
+            Cow::Borrowed("BEGIN")
+        }
     }
 
     /// Statement to commit a transaction
-    async fn commit_statement(&self, depth: i32) -> String {
-        let savepoint_stmt = format!("RELEASE SAVEPOINT savepoint{}", depth);
-        let ret = if depth > 1 {
-            savepoint_stmt
+    fn commit_statement(&self, depth: u32) -> Cow<'static, str> {
+        if depth > 1 {
+            Cow::Owned(format!("RELEASE SAVEPOINT savepoint{depth}"))
         } else {
-            "COMMIT".to_string()
-        };
-
-        return ret;
+            Cow::Borrowed("COMMIT")
+        }
     }
 
     /// Statement to rollback a transaction
-    async fn rollback_statement(&self, depth: i32) -> String {
-        let savepoint_stmt = format!("ROLLBACK TO SAVEPOINT savepoint{}", depth);
-        let ret = if depth > 1 {
-            savepoint_stmt
+    fn rollback_statement(&self, depth: u32) -> Cow<'static, str> {
+        if depth > 1 {
+            Cow::Owned(format!("ROLLBACK TO SAVEPOINT savepoint{depth}"))
         } else {
-            "ROLLBACK".to_string()
-        };
-
-        return ret;
+            Cow::Borrowed("ROLLBACK")
+        }
     }
 }
 
diff --git a/quaint/src/connector/queryable.rs b/quaint/src/connector/queryable.rs
index 1894176b0df..b34e42866d8 100644
--- a/quaint/src/connector/queryable.rs
+++ b/quaint/src/connector/queryable.rs
@@ -1,3 +1,5 @@
+use std::borrow::Cow;
+
 use super::{DescribedQuery, IsolationLevel, ResultSet, Transaction};
 use crate::ast::*;
 use async_trait::async_trait;
@@ -90,36 +92,30 @@ pub trait Queryable: Send + Sync {
     }
 
     /// Statement to begin a transaction
-    async fn begin_statement(&self, depth: i32) -> String {
-        println!("connector: Transaction depth: {}", depth);
-        let savepoint_stmt = format!("SAVEPOINT savepoint{}", depth);
-        let ret = if depth > 1 { savepoint_stmt } else { "BEGIN".to_string() };
-
-        return ret;
+    fn begin_statement(&self, depth: u32) -> Cow<'static, str> {
+        if depth > 1 {
+            Cow::Owned(format!("SAVEPOINT savepoint{depth}"))
+        } else {
+            Cow::Borrowed("BEGIN")
+        }
     }
 
     /// Statement to commit a transaction
-    async fn commit_statement(&self, depth: i32) -> String {
-        let savepoint_stmt = format!("RELEASE SAVEPOINT savepoint{}", depth);
-        let ret = if depth > 1 {
-            savepoint_stmt
+    fn commit_statement(&self, depth: u32) -> Cow<'static, str> {
+        if depth > 1 {
+            Cow::Owned(format!("RELEASE SAVEPOINT savepoint{depth}"))
         } else {
-            "COMMIT".to_string()
-        };
-
-        return ret;
+            Cow::Borrowed("COMMIT")
+        }
     }
 
     /// Statement to rollback a transaction
-    async fn rollback_statement(&self, depth: i32) -> String {
-        let savepoint_stmt = format!("ROLLBACK TO SAVEPOINT savepoint{}", depth);
-        let ret = if depth > 1 {
-            savepoint_stmt
+    fn rollback_statement(&self, depth: u32) -> Cow<'static, str> {
+        if depth > 1 {
+            Cow::Owned(format!("ROLLBACK TO SAVEPOINT savepoint{depth}"))
         } else {
-            "ROLLBACK".to_string()
-        };
-
-        return ret;
+            Cow::Borrowed("ROLLBACK")
+        }
     }
 
     /// Sets the transaction isolation level to given value.
diff --git a/quaint/src/connector/sqlite/native/mod.rs b/quaint/src/connector/sqlite/native/mod.rs
index 5b3d2abbe0f..e83375073ff 100644
--- a/quaint/src/connector/sqlite/native/mod.rs
+++ b/quaint/src/connector/sqlite/native/mod.rs
@@ -17,6 +17,7 @@ use crate::{
     visitor::{self, Visitor},
 };
 use async_trait::async_trait;
+use std::borrow::Cow;
 use std::convert::TryFrom;
 use tokio::sync::Mutex;
 
@@ -182,43 +183,34 @@ impl Queryable for Sqlite {
     }
 
     /// Statement to begin a transaction
-    async fn begin_statement(&self, depth: i32) -> String {
-        let savepoint_stmt = format!("SAVEPOINT savepoint{}", depth);
+    fn begin_statement(&self, depth: u32) -> Cow<'static, str> {
         // From https://sqlite.org/isolation.html:
         // `BEGIN IMMEDIATE` avoids possible `SQLITE_BUSY_SNAPSHOT` that arise when another connection jumps ahead in line.
         //  The BEGIN IMMEDIATE command goes ahead and starts a write transaction, and thus blocks all other writers.
         // If the BEGIN IMMEDIATE operation succeeds, then no subsequent operations in that transaction will ever fail with an SQLITE_BUSY error.
-        let ret = if depth > 1 {
-            savepoint_stmt
+        if depth > 1 {
+            Cow::Owned(format!("SAVEPOINT savepoint{depth}"))
         } else {
-            "BEGIN IMMEDIATE".to_string()
-        };
-
-        return ret;
+            Cow::Borrowed("BEGIN IMMEDIATE")
+        }
     }
 
     /// Statement to commit a transaction
-    async fn commit_statement(&self, depth: i32) -> String {
-        let savepoint_stmt = format!("RELEASE SAVEPOINT savepoint{}", depth);
-        let ret = if depth > 1 {
-            savepoint_stmt
+    fn commit_statement(&self, depth: u32) -> Cow<'static, str> {
+        if depth > 1 {
+            Cow::Owned(format!("RELEASE SAVEPOINT savepoint{depth}"))
         } else {
-            "COMMIT".to_string()
-        };
-
-        return ret;
+            Cow::Borrowed("COMMIT")
+        }
     }
 
     /// Statement to rollback a transaction
-    async fn rollback_statement(&self, depth: i32) -> String {
-        let savepoint_stmt = format!("ROLLBACK TO savepoint{}", depth);
-        let ret = if depth > 1 {
-            savepoint_stmt
+    fn rollback_statement(&self, depth: u32) -> Cow<'static, str> {
+        if depth > 1 {
+            Cow::Owned(format!("ROLLBACK TO savepoint{depth}"))
         } else {
-            "ROLLBACK".to_string()
-        };
-
-        return ret;
+            Cow::Borrowed("ROLLBACK")
+        }
     }
 }
 
diff --git a/quaint/src/connector/transaction.rs b/quaint/src/connector/transaction.rs
index 42ce8120961..ff23e259456 100644
--- a/quaint/src/connector/transaction.rs
+++ b/quaint/src/connector/transaction.rs
@@ -19,10 +19,10 @@ pub trait Transaction: Queryable {
     async fn begin(&mut self) -> crate::Result<()>;
 
     /// Commit the changes to the database and consume the transaction.
-    async fn commit(&mut self) -> crate::Result<i32>;
+    async fn commit(&mut self) -> crate::Result<u32>;
 
     /// Rolls back the changes to the database.
-    async fn rollback(&mut self) -> crate::Result<i32>;
+    async fn rollback(&mut self) -> crate::Result<u32>;
 
     /// workaround for lack of upcasting between traits https://github.com/rust-lang/rust/issues/65991
     fn as_queryable(&self) -> &dyn Queryable;
@@ -43,7 +43,7 @@ pub(crate) struct TransactionOptions {
 /// transaction object will panic.
 pub struct DefaultTransaction<'a> {
     pub inner: &'a dyn Queryable,
-    pub depth: Arc<Mutex<i32>>,
+    pub depth: Arc<Mutex<u32>>,
 }
 
 impl<'a> DefaultTransaction<'a> {
@@ -87,7 +87,7 @@ impl<'a> Transaction for DefaultTransaction<'a> {
             *depth
         };
 
-        let begin_statement = self.inner.begin_statement(current_depth).await;
+        let begin_statement = self.inner.begin_statement(current_depth);
 
         self.inner.raw_cmd(&begin_statement).await?;
 
@@ -95,7 +95,7 @@ impl<'a> Transaction for DefaultTransaction<'a> {
     }
 
     /// Commit the changes to the database and consume the transaction.
-    async fn commit(&mut self) -> crate::Result<i32> {
+    async fn commit(&mut self) -> crate::Result<u32> {
         decrement_gauge!("prisma_client_queries_active", 1.0);
 
         // Lock the mutex and get the depth value
@@ -105,7 +105,7 @@ impl<'a> Transaction for DefaultTransaction<'a> {
         };
 
         // Perform the asynchronous operation without holding the lock
-        let commit_statement = self.inner.commit_statement(depth_val).await;
+        let commit_statement = self.inner.commit_statement(depth_val);
         self.inner.raw_cmd(&commit_statement).await?;
 
         // Lock the mutex again to modify the depth
@@ -119,7 +119,7 @@ impl<'a> Transaction for DefaultTransaction<'a> {
     }
 
     /// Rolls back the changes to the database.
-    async fn rollback(&mut self) -> crate::Result<i32> {
+    async fn rollback(&mut self) -> crate::Result<u32> {
         decrement_gauge!("prisma_client_queries_active", 1.0);
 
         // Lock the mutex and get the depth value
@@ -129,7 +129,7 @@ impl<'a> Transaction for DefaultTransaction<'a> {
         };
 
         // Perform the asynchronous operation without holding the lock
-        let rollback_statement = self.inner.rollback_statement(depth_val).await;
+        let rollback_statement = self.inner.rollback_statement(depth_val);
 
         self.inner.raw_cmd(&rollback_statement).await?;
 
diff --git a/quaint/src/pooled/manager.rs b/quaint/src/pooled/manager.rs
index 5e96c3c51bd..ac2def4c9fe 100644
--- a/quaint/src/pooled/manager.rs
+++ b/quaint/src/pooled/manager.rs
@@ -1,3 +1,5 @@
+use std::borrow::Cow;
+
 #[cfg(feature = "mssql-native")]
 use crate::connector::MssqlUrl;
 #[cfg(feature = "mysql-native")]
@@ -66,16 +68,16 @@ impl Queryable for PooledConnection {
         self.inner.server_reset_query(tx).await
     }
 
-    async fn begin_statement(&self, depth: i32) -> String {
-        self.inner.begin_statement(depth).await
+    fn begin_statement(&self, depth: u32) -> Cow<'static, str> {
+        self.inner.begin_statement(depth)
     }
 
-    async fn commit_statement(&self, depth: i32) -> String {
-        self.inner.commit_statement(depth).await
+    fn commit_statement(&self, depth: u32) -> Cow<'static, str> {
+        self.inner.commit_statement(depth)
     }
 
-    async fn rollback_statement(&self, depth: i32) -> String {
-        self.inner.rollback_statement(depth).await
+    fn rollback_statement(&self, depth: u32) -> Cow<'static, str> {
+        self.inner.rollback_statement(depth)
     }
 
     async fn set_tx_isolation_level(&self, isolation_level: IsolationLevel) -> crate::Result<()> {
diff --git a/quaint/src/single.rs b/quaint/src/single.rs
index 128e63c5a6c..d5ac130a218 100644
--- a/quaint/src/single.rs
+++ b/quaint/src/single.rs
@@ -5,7 +5,7 @@ use crate::{
     connector::{self, impl_default_TransactionCapable, ConnectionInfo, IsolationLevel, Queryable, TransactionCapable},
 };
 use async_trait::async_trait;
-use std::{fmt, sync::Arc};
+use std::{borrow::Cow, fmt, sync::Arc};
 
 #[cfg(feature = "sqlite-native")]
 use std::convert::TryFrom;
@@ -237,16 +237,16 @@ impl Queryable for Quaint {
         self.inner.is_healthy()
     }
 
-    async fn begin_statement(&self, depth: i32) -> String {
-        self.inner.begin_statement(depth).await
+    fn begin_statement(&self, depth: u32) -> Cow<'static, str> {
+        self.inner.begin_statement(depth)
     }
 
-    async fn commit_statement(&self, depth: i32) -> String {
-        self.inner.commit_statement(depth).await
+    fn commit_statement(&self, depth: u32) -> Cow<'static, str> {
+        self.inner.commit_statement(depth)
     }
 
-    async fn rollback_statement(&self, depth: i32) -> String {
-        self.inner.rollback_statement(depth).await
+    fn rollback_statement(&self, depth: u32) -> Cow<'static, str> {
+        self.inner.rollback_statement(depth)
     }
 
     async fn set_tx_isolation_level(&self, isolation_level: IsolationLevel) -> crate::Result<()> {
diff --git a/query-engine/connectors/mongodb-query-connector/src/interface/transaction.rs b/query-engine/connectors/mongodb-query-connector/src/interface/transaction.rs
index d2baa1bf597..f4173af2a56 100644
--- a/query-engine/connectors/mongodb-query-connector/src/interface/transaction.rs
+++ b/query-engine/connectors/mongodb-query-connector/src/interface/transaction.rs
@@ -43,7 +43,7 @@ impl<'conn> Transaction for MongoDbTransaction<'conn> {
         Ok(())
     }
 
-    async fn commit(&mut self) -> connector_interface::Result<i32> {
+    async fn commit(&mut self) -> connector_interface::Result<u32> {
         decrement_gauge!(PRISMA_CLIENT_QUERIES_ACTIVE, 1.0);
 
         utils::commit_with_retry(&mut self.connection.session)
@@ -53,7 +53,7 @@ impl<'conn> Transaction for MongoDbTransaction<'conn> {
         Ok(0)
     }
 
-    async fn rollback(&mut self) -> connector_interface::Result<i32> {
+    async fn rollback(&mut self) -> connector_interface::Result<u32> {
         decrement_gauge!(PRISMA_CLIENT_QUERIES_ACTIVE, 1.0);
 
         self.connection
diff --git a/query-engine/connectors/query-connector/src/interface.rs b/query-engine/connectors/query-connector/src/interface.rs
index 2c41e674c3c..b07dc2b1832 100644
--- a/query-engine/connectors/query-connector/src/interface.rs
+++ b/query-engine/connectors/query-connector/src/interface.rs
@@ -33,8 +33,8 @@ pub trait Connection: ConnectionLike {
 #[async_trait]
 pub trait Transaction: ConnectionLike {
     async fn begin(&mut self) -> crate::Result<()>;
-    async fn commit(&mut self) -> crate::Result<i32>;
-    async fn rollback(&mut self) -> crate::Result<i32>;
+    async fn commit(&mut self) -> crate::Result<u32>;
+    async fn rollback(&mut self) -> crate::Result<u32>;
 
     async fn version(&self) -> Option<String>;
 
diff --git a/query-engine/connectors/sql-query-connector/src/database/transaction.rs b/query-engine/connectors/sql-query-connector/src/database/transaction.rs
index 75e58483d12..36a6172f007 100644
--- a/query-engine/connectors/sql-query-connector/src/database/transaction.rs
+++ b/query-engine/connectors/sql-query-connector/src/database/transaction.rs
@@ -44,14 +44,14 @@ impl<'tx> Transaction for SqlConnectorTransaction<'tx> {
         .await
     }
 
-    async fn commit(&mut self) -> connector::Result<i32> {
+    async fn commit(&mut self) -> connector::Result<u32> {
         catch(&self.connection_info, async {
             self.inner.commit().await.map_err(SqlError::from)
         })
         .await
     }
 
-    async fn rollback(&mut self) -> connector::Result<i32> {
+    async fn rollback(&mut self) -> connector::Result<u32> {
         catch(&self.connection_info, async {
             let res = self.inner.rollback().await.map_err(SqlError::from);
 
diff --git a/query-engine/core/src/interactive_transactions/actors.rs b/query-engine/core/src/interactive_transactions/actors.rs
index 4038e62e5a6..23dd9d7e312 100644
--- a/query-engine/core/src/interactive_transactions/actors.rs
+++ b/query-engine/core/src/interactive_transactions/actors.rs
@@ -152,7 +152,7 @@ impl<'a> ITXServer<'a> {
         Ok(())
     }
 
-    pub(crate) async fn commit(&mut self) -> crate::Result<i32> {
+    pub(crate) async fn commit(&mut self) -> crate::Result<u32> {
         if let CachedTx::Open(_) = self.cached_tx {
             let open_tx = self.cached_tx.as_open()?;
             trace!("[{}] committing.", self.id.to_string());
@@ -166,7 +166,7 @@ impl<'a> ITXServer<'a> {
         Ok(0)
     }
 
-    pub(crate) async fn rollback(&mut self, was_timeout: bool) -> crate::Result<i32> {
+    pub(crate) async fn rollback(&mut self, was_timeout: bool) -> crate::Result<u32> {
         debug!("[{}] rolling back, was timed out = {was_timeout}", self.name());
         if let CachedTx::Open(_) = self.cached_tx {
             let open_tx = self.cached_tx.as_open()?;
@@ -201,7 +201,7 @@ impl ITXClient {
         Ok(())
     }
 
-    pub(crate) async fn commit(&self) -> crate::Result<i32> {
+    pub(crate) async fn commit(&self) -> crate::Result<u32> {
         let msg = self.send_and_receive(TxOpRequestMsg::Commit).await?;
 
         if let TxOpResponse::Committed(resp) = msg {
@@ -212,7 +212,7 @@ impl ITXClient {
         }
     }
 
-    pub(crate) async fn rollback(&self) -> crate::Result<i32> {
+    pub(crate) async fn rollback(&self) -> crate::Result<u32> {
         let msg = self.send_and_receive(TxOpRequestMsg::Rollback).await?;
 
         if let TxOpResponse::RolledBack(resp) = msg {
diff --git a/query-engine/core/src/interactive_transactions/messages.rs b/query-engine/core/src/interactive_transactions/messages.rs
index a61a2887ef8..e5d746482de 100644
--- a/query-engine/core/src/interactive_transactions/messages.rs
+++ b/query-engine/core/src/interactive_transactions/messages.rs
@@ -31,8 +31,8 @@ impl Display for TxOpRequest {
 #[derive(Debug)]
 pub enum TxOpResponse {
     Begin(()),
-    Committed(crate::Result<i32>),
-    RolledBack(crate::Result<i32>),
+    Committed(crate::Result<u32>),
+    RolledBack(crate::Result<u32>),
     Single(crate::Result<ResponseData>),
     Batch(crate::Result<Vec<crate::Result<ResponseData>>>),
 }
diff --git a/query-engine/driver-adapters/src/queryable.rs b/query-engine/driver-adapters/src/queryable.rs
index db5f9141577..bed71197d9a 100644
--- a/query-engine/driver-adapters/src/queryable.rs
+++ b/query-engine/driver-adapters/src/queryable.rs
@@ -326,7 +326,7 @@ impl JsQueryable {
 
         tx.depth += 1;
 
-        let begin_stmt = tx.begin_statement(tx.depth).await;
+        let begin_stmt = tx.begin_statement(tx.depth);
         let tx_opts = tx.options();
 
         if tx_opts.use_phantom_query {
diff --git a/query-engine/driver-adapters/src/transaction.rs b/query-engine/driver-adapters/src/transaction.rs
index d6b2fe88be9..19958b80e46 100644
--- a/query-engine/driver-adapters/src/transaction.rs
+++ b/query-engine/driver-adapters/src/transaction.rs
@@ -1,4 +1,4 @@
-use std::future::Future;
+use std::{borrow::Cow, future::Future};
 
 use async_trait::async_trait;
 use metrics::decrement_gauge;
@@ -86,7 +86,7 @@ impl Queryable for JsTransactionContext {
 pub(crate) struct JsTransaction {
     tx_proxy: TransactionProxy,
     inner: JsBaseQueryable,
-    pub depth: i32,
+    pub depth: u32,
 }
 
 impl JsTransaction {
@@ -116,7 +116,7 @@ impl QuaintTransaction for JsTransaction {
 
         self.depth += 1;
 
-        let begin_stmt = self.begin_statement(self.depth).await;
+        let begin_stmt = self.begin_statement(self.depth);
 
         if self.options().use_phantom_query {
             let commit_stmt = JsBaseQueryable::phantom_query_message(&begin_stmt);
@@ -129,11 +129,11 @@ impl QuaintTransaction for JsTransaction {
 
         UnsafeFuture(self.tx_proxy.begin()).await
     }
-    async fn commit(&mut self) -> quaint::Result<i32> {
+    async fn commit(&mut self) -> quaint::Result<u32> {
         // increment of this gauge is done in DriverProxy::startTransaction
         decrement_gauge!("prisma_client_queries_active", 1.0);
 
-        let commit_stmt = self.commit_statement(self.depth).await;
+        let commit_stmt = self.commit_statement(self.depth);
 
         if self.options().use_phantom_query {
             let commit_stmt = JsBaseQueryable::phantom_query_message(&commit_stmt);
@@ -150,11 +150,11 @@ impl QuaintTransaction for JsTransaction {
         Ok(self.depth)
     }
 
-    async fn rollback(&mut self) -> quaint::Result<i32> {
+    async fn rollback(&mut self) -> quaint::Result<u32> {
         // increment of this gauge is done in DriverProxy::startTransaction
         decrement_gauge!("prisma_client_queries_active", 1.0);
 
-        let rollback_stmt = self.rollback_statement(self.depth).await;
+        let rollback_stmt = self.rollback_statement(self.depth);
 
         if self.options().use_phantom_query {
             let rollback_stmt = JsBaseQueryable::phantom_query_message(&rollback_stmt);
@@ -226,16 +226,16 @@ impl Queryable for JsTransaction {
         self.inner.requires_isolation_first()
     }
 
-    async fn begin_statement(&self, depth: i32) -> String {
-        self.inner.begin_statement(depth).await
+    fn begin_statement(&self, depth: u32) -> Cow<'static, str> {
+        self.inner.begin_statement(depth)
     }
 
-    async fn commit_statement(&self, depth: i32) -> String {
-        self.inner.commit_statement(depth).await
+    fn commit_statement(&self, depth: u32) -> Cow<'static, str> {
+        self.inner.commit_statement(depth)
     }
 
-    async fn rollback_statement(&self, depth: i32) -> String {
-        self.inner.rollback_statement(depth).await
+    fn rollback_statement(&self, depth: u32) -> Cow<'static, str> {
+        self.inner.rollback_statement(depth)
     }
 }