is_materialised and Do not update st tables

Author: Shubham8287

Cargo.lock

@@ -1463,7 +1463,7 @@ impl ModuleHost {
 
     pub async fn call_view(
         &self,
-        mut tx: MutTxId,
+        tx: MutTxId,
         view_name: &str,
         args: FunctionArgs,
         caller_identity: Identity,
@@ -1478,15 +1478,6 @@ impl ModuleHost {
         let view_seed = ArgsSeed(self.info.module_def.typespace().with_type(view_def));
         let args = args.into_tuple(view_seed).map_err(InvalidViewArguments)?;
 
-        match tx.ctx.workload() {
-            WorkloadType::Subscribe => {
-                // New subscription, update st_view_client table.
-                let connection_id = caller_connection_id.ok_or(ViewCallError::MissingClientConnection)?;
-                tx.insert_st_view_client(view_name, args.get_bsatn(), caller_identity, connection_id)?;
-            }
-            _ => {}
-        }
-
         let res = self
             .call_view_inner(
                 tx,

crates/core/src/host/module_host.rs

@@ -204,7 +204,7 @@ pub async fn run(
 
     for (view_name, args) in stmt.views() {
         let (is_memoized, args) = tx
-            .has_memoized_view(view_name, args, caller_identity)
+            .is_materialized(view_name, args, caller_identity)
             .map_err(|e| DBError::Other(anyhow!("Failed to check memoized view: {e}")))?;
 
         // Skip if already memoized

crates/core/src/sql/execute.rs

@@ -98,7 +98,7 @@ impl CommittedReadSets {
 
     /// Returns true if the given view exists in any read set.
     /// This is used to determine whether a view needs to be re-evaluated.
-    fn has_memoized_view(&self, view: &UniqueView) -> bool {
+    fn is_materialized(&self, view: &UniqueView) -> bool {
         self.tables.values().any(|views| views.contains(view))
             || self.index_keys.values().any(|col_map| {
                 col_map
@@ -1061,8 +1061,8 @@ impl CommittedState {
             .set(self.blob_store.bytes_used_by_blobs() as _);
     }
 
-    pub(super) fn has_memoized_view(&self, view: &UniqueView) -> bool {
-        self.read_sets.has_memoized_view(view)
+    pub(super) fn is_materialized(&self, view: &UniqueView) -> bool {
+        self.read_sets.is_materialized(view)
     }
 }
 

crates/datastore/src/locking_tx_datastore/committed_state.rs

@@ -742,12 +742,12 @@ impl MutTxId {
 
     /// Checks whether a memoized view exists for the given view name, arguments, and sender identity.
     ///
-    /// If no memoized result is found, [`RelationalDB::evaluate_view`] should be called to compute and store it.
+    /// If view is not materialized, [`RelationalDB::evaluate_view`] should be called to compute and store it.
     ///
     /// - `view_name`: The name of the view to look up.
     /// - `args`: The serialized (bastn-encoded) arguments for the view.
     /// - `sender`: The identity of the sender requesting the view.
-    pub fn has_memoized_view(&self, view_name: &str, args: Bytes, sender: Identity) -> Result<(bool, Bytes)> {
+    pub fn is_materialized(&self, view_name: &str, args: Bytes, sender: Identity) -> Result<(bool, Bytes)> {
         let (view_id, is_anonymous) = self
             .view_from_name(view_name)?
             .map(|view_row| (view_row.view_id, view_row.is_anonymous))
@@ -760,7 +760,7 @@ impl MutTxId {
         };
 
         let has_memoized = self.read_sets.contains_key(&unique_view)
-            || self.committed_state_write_lock.has_memoized_view(&unique_view);
+            || self.committed_state_write_lock.is_materialized(&unique_view);
 
         Ok((has_memoized, unique_view.into_args()))
     }
@@ -1910,8 +1910,8 @@ impl MutTxId {
         let row = &StViewClientRow {
             view_id,
             arg_id,
-            identity: IdentityViaU256(sender).into(),
-            connection_id: ConnectionIdViaU128(connection_id).into(),
+            identity: IdentityViaU256(sender),
+            connection_id: ConnectionIdViaU128(connection_id),
         };
         self.insert_via_serialize_bsatn(ST_VIEW_CLIENT_ID, row)?;