commentary

Author: Shubham8287

crates/core/src/db/relational_db.rs

@@ -21,8 +21,7 @@ use spacetimedb_datastore::locking_tx_datastore::state_view::{
     IterByColEqMutTx, IterByColRangeMutTx, IterMutTx, IterTx, StateView,
 };
 use spacetimedb_datastore::locking_tx_datastore::{MutTxId, TxId};
-use spacetimedb_datastore::system_tables::ST_VIEW_ID;
-use spacetimedb_datastore::system_tables::{system_tables, StModuleRow, StViewRow};
+use spacetimedb_datastore::system_tables::{system_tables, StModuleRow};
 use spacetimedb_datastore::system_tables::{StFields, StVarFields, StVarName, StVarRow, ST_MODULE_ID, ST_VAR_ID};
 use spacetimedb_datastore::traits::{
     InsertFlags, IsolationLevel, Metadata, MutTx as _, MutTxDatastore, Program, RowTypeForTable, Tx as _, TxDatastore,

crates/core/src/host/module_host.rs

@@ -546,6 +546,7 @@ pub struct CallViewParams {
     /// The expected return type of the view, used for deserialization.
     /// This type information is obtained from the [`ModuleDef`].
     pub return_type: AlgebraicType,
+    /// Whether the view is being called anonymously (i.e., without a client identity).
     pub is_anonymous: bool,
 }
 

crates/core/src/host/wasm_common/module_host_actor.rs

@@ -726,6 +726,7 @@ impl InstanceCommon {
         }
     }
 
+    /// Calls a function (reducer, view) and performs energy monitoring.
     fn call_function<F, R: FunctionResult>(
         &mut self,
         caller_identity: Identity,
@@ -768,6 +769,11 @@ impl InstanceCommon {
         (tx, result)
     }
 
+    /// Execute a view.
+    ///
+    /// Similar to `call_reducer_with_tx`, but for views.
+    /// unlike to `call_reducer_with_tx`, It does not handle `tx`creation or commit,
+    /// It returns the updated `tx` instead.
     fn call_view_with_tx(
         &mut self,
         replica_ctx: &ReplicaContext,

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

@@ -126,6 +126,7 @@ const STANDARD_BYTES_SINK: u32 = 1;
 type WasmResult<T> = Result<T, WasmError>;
 type RtResult<T> = anyhow::Result<T>;
 
+/// The type of function call being performed.
 pub enum FuncCallType {
     Reducer,
     Procedure,

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

@@ -97,6 +97,10 @@ fn handle_error_sink_code(code: i32, error: Vec<u8>) -> Result<(), Box<str>> {
     }
 }
 
+/// Handle the return code from a function using a result sink.
+///
+/// On success, returns the result bytes.
+/// On failure, returns the error message.
 fn handle_result_sink_code(code: i32, result: Vec<u8>) -> Result<Vec<u8>, Box<str>> {
     match code {
         0 => Ok(result),

crates/core/src/subscription/module_subscription_actor.rs

@@ -197,6 +197,7 @@ impl ModuleSubscriptions {
         }
     }
 
+    /// Should be called once to initialize the `ModuleSubscriptions` with a `ModuleHost` receiver.
     pub fn init(&self, module_host: watch::Receiver<ModuleHost>) {
         self.module_rx
             .set(module_host)

crates/datastore/src/locking_tx_datastore/mut_tx.rs

@@ -8,22 +8,14 @@ use super::{
     tx_state::{IndexIdMap, PendingSchemaChange, TxState, TxTableForInsertion},
     SharedMutexGuard, SharedWriteGuard,
 };
-<<<<<<< HEAD
-use crate::system_tables::{
-    system_tables, ConnectionIdViaU128, StConnectionCredentialsFields, StConnectionCredentialsRow, StViewColumnFields,
-    StViewFields, StViewParamFields, StViewParamRow, ST_CONNECTION_CREDENTIALS_ID, ST_VIEW_COLUMN_ID, ST_VIEW_ID,
-    ST_VIEW_PARAM_ID,
-};
-=======
->>>>>>> d533f9c4c (Shub/view interface (#3561))
 use crate::traits::{InsertFlags, RowTypeForTable, TxData, UpdateFlags};
 use crate::{
     error::ViewError,
     system_tables::{
         system_tables, ConnectionIdViaU128, IdentityViaU256, StConnectionCredentialsFields, StConnectionCredentialsRow,
-        StViewArgFields, StViewArgRow, StViewClientFields, StViewClientRow, StViewColumnFields, StViewFields,
-        StViewParamFields, StViewParamRow, ST_CONNECTION_CREDENTIALS_ID, ST_VIEW_ARG_ID, ST_VIEW_CLIENT_ID,
-        ST_VIEW_COLUMN_ID, ST_VIEW_ID, ST_VIEW_PARAM_ID,
+        StViewArgFields, StViewArgRow, StViewClientRow, StViewColumnFields, StViewFields, StViewParamFields,
+        StViewParamRow, ST_CONNECTION_CREDENTIALS_ID, ST_VIEW_ARG_ID, ST_VIEW_CLIENT_ID, ST_VIEW_COLUMN_ID, ST_VIEW_ID,
+        ST_VIEW_PARAM_ID,
     },
 };
 use crate::{
@@ -1853,34 +1845,6 @@ impl<'a, I: Iterator<Item = RowRef<'a>>> Iterator for FilterDeleted<'a, I> {
 }
 
 impl MutTxId {
-    /// Delete view data and metadata for a client connection
-    pub fn delete_view_data_for_client(&mut self, sender: Identity, connection_id: ConnectionId) -> Result<()> {
-        for row in self.delete_st_view_client_rows(sender, connection_id)? {
-            if !self.is_identity_subscribed_to_view_args(row.view_id, row.arg_id, sender)? {
-                self.delete_view_rows_for_identity(row.view_id, row.arg_id, sender)?;
-            }
-        }
-        Ok(())
-    }
-
-    /// Delete and return the rows in `st_view_client` for a client connection
-    fn delete_st_view_client_rows(
-        &mut self,
-        sender: Identity,
-        connection_id: ConnectionId,
-    ) -> Result<Vec<StViewClientRow>> {
-        let sender = IdentityViaU256(sender);
-        let conn_id = ConnectionIdViaU128(connection_id);
-        let cols = col_list![StViewClientFields::Identity, StViewClientFields::ConnectionId];
-        let value = AlgebraicValue::product([sender.into(), conn_id.into()]);
-        self.iter_by_col_eq(ST_VIEW_CLIENT_ID, cols, &value)?
-            .map(|row_ref| StViewClientRow::try_from(row_ref).map(|row| (row, row_ref.pointer())))
-            .collect::<Result<Vec<_>>>()?
-            .into_iter()
-            .map(|(row, ptr)| self.delete(ST_VIEW_CLIENT_ID, ptr).map(|_| row))
-            .collect()
-    }
-
     /// Get or insert view argument into `ST_VIEW_ARG_ID`.
     pub fn get_or_insert_st_view_arg(&mut self, args: &Bytes) -> Result<u64> {
         let bytes_av = AlgebraicValue::Bytes(args.to_vec().into());
@@ -1926,22 +1890,6 @@ impl MutTxId {
         Ok(arg_id)
     }
 
-    /// Is anyone is subscribed to the view arguments identified by `arg_id`
-    fn is_identity_subscribed_to_view_args(&self, view_id: ViewId, arg_id: u64, sender: Identity) -> Result<bool> {
-        Ok(self
-            .iter_by_col_eq(
-                ST_VIEW_CLIENT_ID,
-                col_list![
-                    StViewClientFields::ViewId,
-                    StViewClientFields::ArgId,
-                    StViewClientFields::Identity
-                ],
-                &AlgebraicValue::product([view_id.into(), arg_id.into(), sender.into()]),
-            )?
-            .next()
-            .is_some())
-    }
-
     /// Lookup a row in `st_view` by its primary key
     fn st_view_row(&self, view_id: ViewId) -> Result<Option<StViewRow>> {
         self.iter_by_col_eq(ST_VIEW_ID, col_list![StViewFields::ViewId], &view_id.into())?
@@ -1958,29 +1906,6 @@ impl MutTxId {
             .and_then(|row| row.table_id.map(|id| (id, row.is_anonymous))))
     }
 
-    /// Delete the rows of a view subscribed to by `sender`
-    fn delete_view_rows_for_identity(&mut self, view_id: ViewId, arg_id: u64, sender: Identity) -> Result<()> {
-        if let Some((table_id, is_anonymous)) = self.get_table_id_for_view(view_id)? {
-            let value = if is_anonymous {
-                let none_sender = AlgebraicValue::OptionNone();
-                AlgebraicValue::product([none_sender, arg_id.into()])
-            } else {
-                let sender = IdentityViaU256(sender);
-                let some_sender = AlgebraicValue::OptionSome(sender.into());
-                AlgebraicValue::product([some_sender, arg_id.into()])
-            };
-            for row_pointer in self
-                .iter_by_col_eq(table_id, col_list![0, 1], &value)?
-                .map(|row_ref| row_ref.pointer())
-                .collect::<Vec<_>>()
-                .into_iter()
-            {
-                self.delete(table_id, row_pointer)?;
-            }
-        }
-        Ok(())
-    }
-
     pub fn insert_st_client(
         &mut self,
         identity: Identity,