with_transaction -> with_tx

Author: Centril

crates/bindings-sys/src/lib.rs

@@ -682,7 +682,7 @@ pub mod raw {
         /// Returns an error:
         ///
         /// - `WOULD_BLOCK_TRANSACTION`, if there's already an ongoing transaction.
-        pub fn procedure_start_mut_transaction(out: *mut i64) -> u16;
+        pub fn procedure_start_mut_tx(out: *mut i64) -> u16;
 
         /// Commits a mutable transaction,
         /// suspending execution of this WASM instance until
@@ -700,14 +700,14 @@ pub mod raw {
         /// Returns an error:
         ///
         /// - `TRANSACTION_NOT_ANONYMOUS`,
-        ///   if the transaction was not started in [`procedure_start_mut_transaction`].
+        ///   if the transaction was not started in [`procedure_start_mut_tx`].
         ///   This can happen if this syscall is erroneously called by a reducer.
         ///   The code `NOT_IN_TRANSACTION` does not happen,
         ///   as it is subsumed by `TRANSACTION_NOT_ANONYMOUS`.
         /// - `TRANSACTION_IS_READ_ONLY`, if the pending transaction is read-only.
         ///   This currently does not happen as anonymous read transactions
         ///   are not exposed to modules.
-        pub fn procedure_commit_mut_transaction() -> u16;
+        pub fn procedure_commit_mut_tx() -> u16;
 
         /// Aborts a mutable transaction,
         /// suspending execution of this WASM instance until
@@ -724,14 +724,14 @@ pub mod raw {
         /// Returns an error:
         ///
         /// - `TRANSACTION_NOT_ANONYMOUS`,
-        ///   if the transaction was not started in [`procedure_start_mut_transaction`].
+        ///   if the transaction was not started in [`procedure_start_mut_tx`].
         ///   This can happen if this syscall is erroneously called by a reducer.
         ///   The code `NOT_IN_TRANSACTION` does not happen,
         ///   as it is subsumed by `TRANSACTION_NOT_ANONYMOUS`.
         /// - `TRANSACTION_IS_READ_ONLY`, if the pending transaction is read-only.
         ///   This currently does not happen as anonymous read transactions
         ///   are not exposed to modules.
-        pub fn procedure_abort_mut_transaction() -> u16;
+        pub fn procedure_abort_mut_tx() -> u16;
     }
 
     /// What strategy does the database index use?
@@ -1346,8 +1346,8 @@ pub mod procedure {
     ///
     /// - `WOULD_BLOCK_TRANSACTION`, if there's already an ongoing transaction.
     #[inline]
-    pub fn procedure_start_mut_transaction() -> Result<i64> {
-        unsafe { call(|out| raw::procedure_start_mut_transaction(out)) }
+    pub fn procedure_start_mut_tx() -> Result<i64> {
+        unsafe { call(|out| raw::procedure_start_mut_tx(out)) }
     }
 
     /// Commits a mutable transaction,
@@ -1362,16 +1362,16 @@ pub mod procedure {
     /// Returns an error:
     ///
     /// - `TRANSACTION_NOT_ANONYMOUS`,
-    ///   if the transaction was not started in [`procedure_start_mut_transaction`].
+    ///   if the transaction was not started in [`procedure_start_mut_tx`].
     ///   This can happen if this syscall is erroneously called by a reducer.
     ///   The code `NOT_IN_TRANSACTION` does not happen,
     ///   as it is subsumed by `TRANSACTION_NOT_ANONYMOUS`.
     /// - `TRANSACTION_IS_READ_ONLY`, if the pending transaction is read-only.
     ///   This currently does not happen as anonymous read transactions
     ///   are not exposed to modules.
     #[inline]
-    pub fn procedure_commit_mut_transaction() -> Result<()> {
-        call_no_ret(|| unsafe { raw::procedure_commit_mut_transaction() })
+    pub fn procedure_commit_mut_tx() -> Result<()> {
+        call_no_ret(|| unsafe { raw::procedure_commit_mut_tx() })
     }
 
     /// Aborts a mutable transaction,
@@ -1385,15 +1385,15 @@ pub mod procedure {
     /// Returns an error:
     ///
     /// - `TRANSACTION_NOT_ANONYMOUS`,
-    ///   if the transaction was not started in [`procedure_start_mut_transaction`].
+    ///   if the transaction was not started in [`procedure_start_mut_tx`].
     ///   This can happen if this syscall is erroneously called by a reducer.
     ///   The code `NOT_IN_TRANSACTION` does not happen,
     ///   as it is subsumed by `TRANSACTION_NOT_ANONYMOUS`.
     /// - `TRANSACTION_IS_READ_ONLY`, if the pending transaction is read-only.
     ///   This currently does not happen as anonymous read transactions
     ///   are not exposed to modules.
     #[inline]
-    pub fn procedure_abort_mut_transaction() -> Result<()> {
-        call_no_ret(|| unsafe { raw::procedure_abort_mut_transaction() })
+    pub fn procedure_abort_mut_tx() -> Result<()> {
+        call_no_ret(|| unsafe { raw::procedure_abort_mut_tx() })
     }
 }

crates/bindings/src/lib.rs

@@ -1007,7 +1007,7 @@ impl ReducerContext {
 }
 
 /// The context that an anonymous transaction
-/// in [`ProcedureContext::with_transaction`] is provided with.
+/// in [`ProcedureContext::with_tx`] is provided with.
 ///
 /// Includes information about the client starting the transaction
 /// and the time of the procedure/reducer,
@@ -1138,10 +1138,10 @@ impl ProcedureContext {
     /// e.g., due to a conflict with a concurrent transaction,
     /// this method will re-invoke `body` with a new transaction in order to retry.
     /// This is done once. On the second failure, a panic will occur.
-    pub fn with_transaction<R: IsOk>(&mut self, body: impl Fn(&TxContext) -> R) -> R {
+    pub fn with_tx<R: IsOk>(&mut self, body: impl Fn(&TxContext) -> R) -> R {
         let run = || {
             // Start the transaction.
-            let timestamp = sys::procedure::procedure_start_mut_transaction().expect(
+            let timestamp = sys::procedure::procedure_start_mut_tx().expect(
                 "holding `&mut ProcedureContext`, so should not be in a tx already; called manually elsewhere?",
             );
             let timestamp = Timestamp::from_micros_since_unix_epoch(timestamp);
@@ -1154,21 +1154,21 @@ impl ProcedureContext {
 
         let mut res = run();
         let abort = || {
-            sys::procedure::procedure_abort_mut_transaction()
-                .expect("should have a pending mutable anon tx as `procedure_start_mut_transaction` preceded")
+            sys::procedure::procedure_abort_mut_tx()
+                .expect("should have a pending mutable anon tx as `procedure_start_mut_tx` preceded")
         };
 
         // Commit or roll back?
         if res.is_ok() {
-            if sys::procedure::procedure_commit_mut_transaction().is_err() {
+            if sys::procedure::procedure_commit_mut_tx().is_err() {
                 log::warn!("committing anonymous transaction failed");
 
                 // NOTE(procedure,centril): there's no actual guarantee that `body`
                 // does the exact same as the time before, as the timestamps differ
                 // and due to interior mutability.
                 res = run();
                 if res.is_ok() {
-                    sys::procedure::procedure_commit_mut_transaction().expect("transaction retry failed again")
+                    sys::procedure::procedure_commit_mut_tx().expect("transaction retry failed again")
                 } else {
                     abort();
                 }

crates/core/src/host/wasm_common.rs

@@ -423,9 +423,9 @@ macro_rules! abi_funcs {
 
         $link_async! {
             "spacetime_10.3"::procedure_sleep_until,
-            "spacetime_10.3"::procedure_start_mut_transaction,
-            "spacetime_10.3"::procedure_commit_mut_transaction,
-            "spacetime_10.3"::procedure_abort_mut_transaction,
+            "spacetime_10.3"::procedure_start_mut_tx,
+            "spacetime_10.3"::procedure_commit_mut_tx,
+            "spacetime_10.3"::procedure_abort_mut_tx,
         }
     };
 }

crates/core/src/host/wasmtime/wasm_instance_env.rs

@@ -1462,7 +1462,7 @@ impl WasmInstanceEnv {
     /// Returns an error:
     ///
     /// - `WOULD_BLOCK_TRANSACTION`, if there's already an ongoing transaction.
-    pub fn procedure_start_mut_transaction<'caller>(
+    pub fn procedure_start_mut_tx<'caller>(
         caller: Caller<'caller, Self>,
         (out,): (WasmPtr<u64>,),
     ) -> Fut<'caller, RtResult<u32>> {
@@ -1503,17 +1503,14 @@ impl WasmInstanceEnv {
     /// Returns an error:
     ///
     /// - `TRANSACTION_NOT_ANONYMOUS`,
-    ///   if the transaction was not started in [`procedure_start_mut_transaction`].
+    ///   if the transaction was not started in [`procedure_start_mut_tx`].
     ///   This can happen if this syscall is erroneously called by a reducer.
     ///   The code `NOT_IN_TRANSACTION` does not happen,
     ///   as it is subsumed by `TRANSACTION_NOT_ANONYMOUS`.
     /// - `TRANSACTION_IS_READ_ONLY`, if the pending transaction is read-only.
     ///   This currently does not happen as anonymous read transactions
     ///   are not exposed to modules.
-    pub fn procedure_commit_mut_transaction<'caller>(
-        caller: Caller<'caller, Self>,
-        (): (),
-    ) -> Fut<'caller, RtResult<u32>> {
+    pub fn procedure_commit_mut_tx<'caller>(caller: Caller<'caller, Self>, (): ()) -> Fut<'caller, RtResult<u32>> {
         Self::async_with_span(
             caller,
             AbiCall::ProcedureCommitMutTransaction,
@@ -1578,17 +1575,14 @@ impl WasmInstanceEnv {
     /// Returns an error:
     ///
     /// - `TRANSACTION_NOT_ANONYMOUS`,
-    ///   if the transaction was not started in [`procedure_start_mut_transaction`].
+    ///   if the transaction was not started in [`procedure_start_mut_tx`].
     ///   This can happen if this syscall is erroneously called by a reducer.
     ///   The code `NOT_IN_TRANSACTION` does not happen,
     ///   as it is subsumed by `TRANSACTION_NOT_ANONYMOUS`.
     /// - `TRANSACTION_IS_READ_ONLY`, if the pending transaction is read-only.
     ///   This currently does not happen as anonymous read transactions
     ///   are not exposed to modules.
-    pub fn procedure_abort_mut_transaction<'caller>(
-        caller: Caller<'caller, Self>,
-        (): (),
-    ) -> Fut<'caller, RtResult<u32>> {
+    pub fn procedure_abort_mut_tx<'caller>(caller: Caller<'caller, Self>, (): ()) -> Fut<'caller, RtResult<u32>> {
         Self::async_with_span(caller, AbiCall::ProcedureAbortMutTransaction, |mut caller| async move {
             let (_, env) = Self::mem_env(&mut caller);
 

crates/testing/tests/standalone_integration_test.rs

@@ -181,7 +181,7 @@ fn test_calling_a_procedure() {
     test_calling_a_procedure_in_module("module-test");
 }
 
-fn test_calling_with_transaction_in_module(module_name: &'static str) {
+fn test_calling_with_tx_in_module(module_name: &'static str) {
     init();
 
     CompiledModule::compile(module_name, CompilationMode::Debug).with_module_async(
@@ -190,7 +190,7 @@ fn test_calling_with_transaction_in_module(module_name: &'static str) {
             let json = r#"
 {
   "CallProcedure": {
-    "procedure": "with_transaction",
+    "procedure": "with_tx",
     "args": "[]",
     "request_id": 0,
     "flags": 0
@@ -211,8 +211,8 @@ fn test_calling_with_transaction_in_module(module_name: &'static str) {
 
 #[test]
 #[serial]
-fn test_calling_with_transaction() {
-    test_calling_with_transaction_in_module("module-test");
+fn test_calling_with_tx() {
+    test_calling_with_tx_in_module("module-test");
 }
 
 /// Invoke the `module-test` module,

modules/module-test/src/lib.rs

@@ -468,6 +468,6 @@ fn return_value(_ctx: &mut ProcedureContext, foo: u64) -> Baz {
 }
 
 #[spacetimedb::procedure]
-fn with_transaction(ctx: &mut ProcedureContext) {
-    ctx.with_transaction(|tx| say_hello(tx));
+fn with_tx(ctx: &mut ProcedureContext) {
+    ctx.with_tx(|tx| say_hello(tx));
 }