WASM ABI: delete_by_rel -> datastore_delete_all_by_eq_bsatn (#1638)

Author: Centril

crates/bindings-csharp/Runtime/Exceptions.cs

@@ -12,6 +12,11 @@ public class NotInTransactionException : StdbException
     public override string Message => "ABI call can only be made while in a transaction";
 }
 
+public class BsatnDecodeException : StdbException
+{
+    public override string Message => "Couldn't decode the BSATN to the expected type";
+}
+
 public class NoSuchTableException : StdbException
 {
     public override string Message => "No such table";

crates/bindings-csharp/Runtime/Internal/FFI.cs

@@ -24,6 +24,7 @@ public enum Errno : short
     OK = 0,
     HOST_CALL_FAILURE = 1,
     NOT_IN_TRANSACTION = 2,
+    BSATN_DECODE_ERROR = 3,
     NO_SUCH_TABLE = 4,
     NO_SUCH_ITER = 6,
     NO_SUCH_BYTES = 8,
@@ -70,11 +71,13 @@ public static CheckedStatus ConvertToManaged(Errno status)
                 throw status switch
                 {
                     Errno.NOT_IN_TRANSACTION => new NotInTransactionException(),
+                    Errno.BSATN_DECODE_ERROR => new BsatnDecodeException(),
                     Errno.NO_SUCH_TABLE => new NoSuchTableException(),
-                    Errno.UNIQUE_ALREADY_EXISTS => new UniqueAlreadyExistsException(),
-                    Errno.BUFFER_TOO_SMALL => new BufferTooSmallException(),
+                    Errno.NO_SUCH_ITER => new NoSuchIterException(),
                     Errno.NO_SUCH_BYTES => new NoSuchBytesException(),
                     Errno.NO_SPACE => new NoSpaceException(),
+                    Errno.BUFFER_TOO_SMALL => new BufferTooSmallException(),
+                    Errno.UNIQUE_ALREADY_EXISTS => new UniqueAlreadyExistsException(),
                     _ => new UnknownException(status),
                 };
             }
@@ -153,14 +156,6 @@ public static partial CheckedStatus _delete_by_col_eq(
         out uint out_
     );
 
-    [LibraryImport(StdbNamespace)]
-    public static partial CheckedStatus _delete_by_rel(
-        TableId table_id,
-        [In] byte[] relation,
-        uint relation_len,
-        out uint out_
-    );
-
     [LibraryImport(StdbNamespace)]
     public static partial CheckedStatus _iter_start_filtered(
         TableId table_id,
@@ -179,6 +174,14 @@ ref uint buffer_len
     [LibraryImport(StdbNamespace)]
     public static partial CheckedStatus _row_iter_bsatn_close(RowIter iter_handle);
 
+    [LibraryImport(StdbNamespace)]
+    public static partial CheckedStatus _datastore_delete_all_by_eq_bsatn(
+        TableId table_id,
+        [In] byte[] relation,
+        uint relation_len,
+        out uint out_
+    );
+
     [LibraryImport(StdbNamespace)]
     public static partial void _volatile_nonatomic_schedule_immediate(
         [In] byte[] name,

crates/bindings-csharp/Runtime/bindings.c

@@ -60,10 +60,6 @@ IMPORT(Status, _delete_by_col_eq,
        (TableId table_id, ColId col_id, const uint8_t* value,
         uint32_t value_len, uint32_t* num_deleted),
        (table_id, col_id, value, value_len, num_deleted));
-IMPORT(Status, _delete_by_rel,
-       (TableId table_id, const uint8_t* relation, uint32_t relation_len,
-        uint32_t* num_deleted),
-       (table_id, relation, relation_len, num_deleted));
 IMPORT(Status, _iter_start_filtered,
        (TableId table_id, const uint8_t* filter, uint32_t filter_len,
         RowIter* iter),
@@ -72,6 +68,10 @@ IMPORT(int16_t, _row_iter_bsatn_advance,
        (RowIter iter, uint8_t* buffer_ptr, size_t* buffer_len_ptr),
        (iter, buffer_ptr, buffer_len_ptr));
 IMPORT(uint16_t, _row_iter_bsatn_close, (RowIter iter), (iter));
+IMPORT(Status, _datastore_delete_all_by_eq_bsatn,
+       (TableId table_id, const uint8_t* rel_ptr, uint32_t rel_len,
+        uint32_t* num_deleted),
+       (table_id, rel_ptr, rel_len, num_deleted));
 IMPORT(void, _volatile_nonatomic_schedule_immediate,
        (const uint8_t* name, size_t name_len, const uint8_t* args, size_t args_len),
        (name, name_len, args, args_len));

crates/bindings-csharp/Runtime/build/SpacetimeDB.Runtime.targets

@@ -7,13 +7,13 @@
     <WasmImport Include="$(SpacetimeNamespace)!_iter_by_col_eq" />
     <WasmImport Include="$(SpacetimeNamespace)!_insert" />
     <WasmImport Include="$(SpacetimeNamespace)!_delete_by_col_eq" />
-    <WasmImport Include="$(SpacetimeNamespace)!_delete_by_rel" />
     <WasmImport Include="$(SpacetimeNamespace)!_iter_start_filtered" />
     <WasmImport Include="$(SpacetimeNamespace)!_table_id_from_name" />
     <WasmImport Include="$(SpacetimeNamespace)!_datastore_table_row_count" />
     <WasmImport Include="$(SpacetimeNamespace)!_datastore_table_scan_bsatn" />
     <WasmImport Include="$(SpacetimeNamespace)!_row_iter_bsatn_advance" />
     <WasmImport Include="$(SpacetimeNamespace)!_row_iter_bsatn_close" />
+    <WasmImport Include="$(SpacetimeNamespace)!_datastore_delete_all_by_eq_bsatn" />
     <WasmImport Include="$(SpacetimeNamespace)!_bytes_source_read" />
     <WasmImport Include="$(SpacetimeNamespace)!_bytes_sink_write" />
 

crates/bindings-sys/src/lib.rs

@@ -138,22 +138,37 @@ pub mod raw {
         ) -> u16;
 
         /// Deletes those rows, in the table identified by `table_id`,
-        /// that match any row in `relation`.
+        /// that match any row in the byte string `rel = rel_ptr[..rel_len]` in WASM memory.
         ///
         /// Matching is defined by first BSATN-decoding
         /// the byte string pointed to at by `relation` to a `Vec<ProductValue>`
         /// according to the row schema of the table
         /// and then using `Ord for AlgebraicValue`.
+        /// A match happens when `Ordering::Equal` is returned from `fn cmp`.
+        /// This occurs exactly when the row's BSATN-encoding is equal to the encoding of the `ProductValue`.
         ///
         /// The number of rows deleted is written to the WASM pointer `out`.
         ///
-        /// Returns an error if
-        /// - a table with the provided `table_id` doesn't exist
-        /// - `(relation, relation_len)` doesn't decode from BSATN to a `Vec<ProductValue>`
-        ///   according to the `ProductValue` that the table's schema specifies for rows.
-        /// - `relation + relation_len` overflows a 64-bit integer
-        /// - writing to `out` would overflow a 32-bit integer
-        pub fn _delete_by_rel(table_id: TableId, relation: *const u8, relation_len: usize, out: *mut u32) -> u16;
+        /// # Traps
+        ///
+        /// Traps if:
+        /// - `rel_ptr` is NULL or `rel` is not in bounds of WASM memory.
+        /// - `out` is NULL or `out[..size_of::<u32>()]` is not in bounds of WASM memory.
+        ///
+        /// # Errors
+        ///
+        /// Returns an error:
+        ///
+        /// - `NOT_IN_TRANSACTION`, when called outside of a transaction.
+        /// - `NO_SUCH_TABLE`, when `table_id` is not a known ID of a table.
+        /// - `BSATN_DECODE_ERROR`, when `rel` cannot be decoded to `Vec<ProductValue>`
+        ///   where each `ProductValue` is typed at the `ProductType` the table's schema specifies.
+        pub fn _datastore_delete_all_by_eq_bsatn(
+            table_id: TableId,
+            rel_ptr: *const u8,
+            rel_len: usize,
+            out: *mut u32,
+        ) -> u16;
 
         /// Like [`_datastore_table_scan_bsatn`], start iteration on each row,
         /// as bytes, of a table identified by `table_id`.
@@ -200,7 +215,7 @@ pub mod raw {
         /// - `BUFFER_TOO_SMALL`, when there are rows left but they cannot fit in `buffer`.
         ///   When this occurs, `buffer_len` is set to the size of the next item in the iterator.
         ///   To make progress, the caller should reallocate the buffer to at least that size and try again.
-        pub fn _row_iter_bsatn_advance(iter: RowIter, buffer: *mut u8, buffer_len: *mut usize) -> i16;
+        pub fn _row_iter_bsatn_advance(iter: RowIter, buffer_ptr: *mut u8, buffer_len_ptr: *mut usize) -> i16;
 
         /// Destroys the iterator registered under `iter`.
         ///
@@ -538,17 +553,28 @@ unsafe fn call<T: Copy>(f: impl FnOnce(*mut T) -> u16) -> Result<T, Errno> {
     Ok(out.assume_init())
 }
 
-/// Queries and returns the `table_id` associated with the given (table) `name`.
+/// Queries the `table_id` associated with the given (table) `name`.
+///
+/// The table id is returned.
+///
+/// # Errors
 ///
-/// Returns an error if the table does not exist.
+/// Returns an error:
+///
+/// - `NO_SUCH_TABLE`, when `name` is not the name of a table.
 #[inline]
 pub fn table_id_from_name(name: &str) -> Result<TableId, Errno> {
     unsafe { call(|out| raw::_table_id_from_name(name.as_ptr(), name.len(), out)) }
 }
 
-/// Queries and returns the number of rows in the table identified by `table_id`.
+/// Returns the number of rows currently in table identified by `table_id`.
+///
+/// # Errors
+///
+/// Returns an error:
 ///
-/// Returns an error if the table does not exist or if not in a transaction.
+/// - `NOT_IN_TRANSACTION`, when called outside of a transaction.
+/// - `NO_SUCH_TABLE`, when `table_id` is not a known ID of a table.
 #[inline]
 pub fn datastore_table_row_count(table_id: TableId) -> Result<u64, Errno> {
     unsafe { call(|out| raw::_datastore_table_row_count(table_id, out)) }
@@ -611,31 +637,34 @@ pub fn delete_by_col_eq(table_id: TableId, col_id: ColId, value: &[u8]) -> Resul
 }
 
 /// Deletes those rows, in the table identified by `table_id`,
-/// that match any row in `relation`.
+/// that match any row in the byte string `relation`.
 ///
 /// Matching is defined by first BSATN-decoding
 /// the byte string pointed to at by `relation` to a `Vec<ProductValue>`
 /// according to the row schema of the table
 /// and then using `Ord for AlgebraicValue`.
+/// A match happens when `Ordering::Equal` is returned from `fn cmp`.
+/// This occurs exactly when the row's BSATN-encoding is equal to the encoding of the `ProductValue`.
 ///
-/// Returns the number of rows deleted.
+/// The number of rows deleted is returned.
 ///
-/// Returns an error if
-/// - a table with the provided `table_id` doesn't exist
-/// - `(relation, relation_len)` doesn't decode from BSATN to a `Vec<ProductValue>`
+/// # Errors
+///
+/// Returns an error:
+///
+/// - `NOT_IN_TRANSACTION`, when called outside of a transaction.
+/// - `NO_SUCH_TABLE`, when `table_id` is not a known ID of a table.
+/// - `BSATN_DECODE_ERROR`, when `rel` cannot be decoded to `Vec<ProductValue>`
+///   where each `ProductValue` is typed at the `ProductType` the table's schema specifies.
 #[inline]
-pub fn delete_by_rel(table_id: TableId, relation: &[u8]) -> Result<u32, Errno> {
-    unsafe { call(|out| raw::_delete_by_rel(table_id, relation.as_ptr(), relation.len(), out)) }
+pub fn datastore_delete_all_by_eq_bsatn(table_id: TableId, relation: &[u8]) -> Result<u32, Errno> {
+    unsafe { call(|out| raw::_datastore_delete_all_by_eq_bsatn(table_id, relation.as_ptr(), relation.len(), out)) }
 }
 
 /// Starts iteration on each row, as BSATN-encoded, of a table identified by `table_id`.
 /// Returns iterator handle is written to the `out` pointer.
 /// This handle can be advanced by [`row_iter_bsatn_advance`].
 ///
-/// # Traps
-///
-/// This function does not trap.
-///
 /// # Errors
 ///
 /// Returns an error:

crates/bindings/src/lib.rs

@@ -225,13 +225,14 @@ pub fn delete_by_col_eq(table_id: TableId, col_id: ColId, value: &impl Serialize
 /// Returns an error if
 /// - a table with the provided `table_id` doesn't exist
 /// - `(relation, relation_len)` doesn't decode from BSATN to a `Vec<ProductValue>`
+/// - this is called outside a transaction
 ///
 /// Panics when serialization fails.
 pub fn delete_by_rel(table_id: TableId, relation: &[impl Serialize]) -> Result<u32> {
     with_row_buf(|bytes| {
         // Encode `value` as BSATN into `bytes` and then use that.
         bsatn::to_writer(bytes, relation).unwrap();
-        sys::delete_by_rel(table_id, bytes)
+        sys::datastore_delete_all_by_eq_bsatn(table_id, bytes)
     })
 }
 

crates/core/src/host/instance_env.rs

@@ -169,9 +169,12 @@ impl InstanceEnv {
     /// where the rows match one in `relation`
     /// which is a bsatn encoding of `Vec<ProductValue>`.
     ///
-    /// Returns an error if no rows were deleted.
+    /// Returns an error if
+    /// - not in a transaction.
+    /// - the table didn't exist.
+    /// - a row couldn't be decoded to the table schema type.
     #[tracing::instrument(skip(self, relation))]
-    pub fn delete_by_rel(&self, table_id: TableId, relation: &[u8]) -> Result<u32, NodesError> {
+    pub fn datastore_delete_all_by_eq_bsatn(&self, table_id: TableId, relation: &[u8]) -> Result<u32, NodesError> {
         let stdb = &*self.dbic.relational_db;
         let tx = &mut *self.get_tx()?;
 

crates/core/src/host/wasm_common.rs

@@ -320,6 +320,7 @@ pub(super) type TimingSpanSet = ResourceSlab<TimingSpanIdx>;
 pub fn err_to_errno(err: &NodesError) -> Option<NonZeroU16> {
     match err {
         NodesError::NotInTransaction => Some(errno::NOT_IN_TRANSACTION),
+        NodesError::DecodeRow(_) => Some(errno::BSATN_DECODE_ERROR),
         NodesError::TableNotFound => Some(errno::NO_SUCH_TABLE),
         NodesError::AlreadyExists(_) => Some(errno::UNIQUE_ALREADY_EXISTS),
         NodesError::Internal(internal) => match **internal {
@@ -351,12 +352,12 @@ macro_rules! abi_funcs {
             "spacetime_10.0"::datastore_table_scan_bsatn,
             "spacetime_10.0"::row_iter_bsatn_advance,
             "spacetime_10.0"::row_iter_bsatn_close,
+            "spacetime_10.0"::datastore_delete_all_by_eq_bsatn,
             "spacetime_10.0"::bytes_source_read,
             "spacetime_10.0"::bytes_sink_write,
 
             "spacetime_10.0"::console_log,
             "spacetime_10.0"::delete_by_col_eq,
-            "spacetime_10.0"::delete_by_rel,
             "spacetime_10.0"::insert,
             "spacetime_10.0"::iter_by_col_eq,
             "spacetime_10.0"::iter_start_filtered,

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

@@ -417,37 +417,6 @@ impl WasmInstanceEnv {
         })
     }
 
-    /// Deletes those rows, in the table identified by `table_id`,
-    /// that match any row in `relation`.
-    ///
-    /// Matching is defined by first BSATN-decoding
-    /// the byte string pointed to at by `relation` to a `Vec<ProductValue>`
-    /// according to the row schema of the table
-    /// and then using `Ord for AlgebraicValue`.
-    ///
-    /// The number of rows deleted is written to the WASM pointer `out`.
-    ///
-    /// Returns an error if
-    /// - a table with the provided `table_id` doesn't exist
-    /// - `(relation, relation_len)` doesn't decode from BSATN to a `Vec<ProductValue>`
-    ///   according to the `ProductValue` that the table's schema specifies for rows.
-    /// - `relation + relation_len` overflows a 64-bit integer
-    /// - writing to `out` would overflow a 32-bit integer
-    #[tracing::instrument(skip_all)]
-    pub fn delete_by_rel(
-        caller: Caller<'_, Self>,
-        table_id: u32,
-        relation: WasmPtr<u8>,
-        relation_len: u32,
-        out: WasmPtr<u32>,
-    ) -> RtResult<u32> {
-        Self::cvt_ret(caller, AbiCall::DeleteByRel, out, |caller| {
-            let (mem, env) = Self::mem_env(caller);
-            let relation = mem.deref_slice(relation, relation_len)?;
-            Ok(env.instance_env.delete_by_rel(table_id.into(), relation)?)
-        })
-    }
-
     /// Queries the `table_id` associated with the given (table) `name`
     /// where `name` is the UTF-8 slice in WASM memory at `name_ptr[..name_len]`.
     ///
@@ -743,6 +712,49 @@ impl WasmInstanceEnv {
         })
     }
 
+    /// Deletes those rows, in the table identified by `table_id`,
+    /// that match any row in the byte string `rel = rel_ptr[..rel_len]` in WASM memory.
+    ///
+    /// Matching is defined by first BSATN-decoding
+    /// the byte string pointed to at by `relation` to a `Vec<ProductValue>`
+    /// according to the row schema of the table
+    /// and then using `Ord for AlgebraicValue`.
+    /// A match happens when `Ordering::Equal` is returned from `fn cmp`.
+    /// This occurs exactly when the row's BSATN-encoding is equal to the encoding of the `ProductValue`.
+    ///
+    /// The number of rows deleted is written to the WASM pointer `out`.
+    ///
+    /// # Traps
+    ///
+    /// Traps if:
+    /// - `rel_ptr` is NULL or `rel` is not in bounds of WASM memory.
+    /// - `out` is NULL or `out[..size_of::<u32>()]` is not in bounds of WASM memory.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error:
+    ///
+    /// - `NOT_IN_TRANSACTION`, when called outside of a transaction.
+    /// - `NO_SUCH_TABLE`, when `table_id` is not a known ID of a table.
+    /// - `BSATN_DECODE_ERROR`, when `rel` cannot be decoded to `Vec<ProductValue>`
+    ///   where each `ProductValue` is typed at the `ProductType` the table's schema specifies.
+    #[tracing::instrument(skip_all)]
+    pub fn datastore_delete_all_by_eq_bsatn(
+        caller: Caller<'_, Self>,
+        table_id: u32,
+        rel_ptr: WasmPtr<u8>,
+        rel_len: u32,
+        out: WasmPtr<u32>,
+    ) -> RtResult<u32> {
+        Self::cvt_ret(caller, AbiCall::DeleteByRel, out, |caller| {
+            let (mem, env) = Self::mem_env(caller);
+            let relation = mem.deref_slice(rel_ptr, rel_len)?;
+            Ok(env
+                .instance_env
+                .datastore_delete_all_by_eq_bsatn(table_id.into(), relation)?)
+        })
+    }
+
     pub fn volatile_nonatomic_schedule_immediate(
         mut caller: Caller<'_, Self>,
         name: WasmPtr<u8>,

crates/primitives/src/errno.rs

@@ -10,6 +10,7 @@ macro_rules! errnos {
         $mac!(
             HOST_CALL_FAILURE(1, "ABI called by host returned an error"),
             NOT_IN_TRANSACTION(2, "ABI call can only be made while in a transaction"),
+            BSATN_DECODE_ERROR(3, "Couldn't decode the BSATN to the expected type"),
             NO_SUCH_TABLE(4, "No such table"),
             NO_SUCH_ITER(6, "The provided row iterator is not valid"),
             NO_SUCH_BYTES(8, "The provided bytes source or sink is not valid"),