test

Author: Shubham8287

crates/core/src/db/relational_db.rs

@@ -821,7 +821,7 @@ impl RelationalDB {
 
         let is_ephemeral_tables = |table_id: &TableId| -> bool {
             tx_data
-                .ephermal_tables()
+                .ephemeral_tables()
                 .map(|etables| etables.contains(table_id))
                 .unwrap_or(false)
         };
@@ -2494,6 +2494,90 @@ mod tests {
         Ok(())
     }
 
+    fn setup_view(stdb: &TestDB) -> ResultTest<(ViewId, TableId, ModuleDef, ViewDef)> {
+        let module_def = view_module_def();
+        let view_def = module_def.view("my_view").unwrap();
+
+        let mut tx = begin_mut_tx(stdb);
+        let (view_id, table_id) = stdb.create_view(&mut tx, &module_def, view_def)?;
+        stdb.commit_tx(tx)?;
+
+        Ok((view_id, table_id, module_def.clone(), view_def.clone()))
+    }
+
+    fn insert_view_row(
+        stdb: &TestDB,
+        view_id: ViewId,
+        table_id: TableId,
+        typespace: &Typespace,
+        row_type: AlgebraicTypeRef,
+        sender: Identity,
+        v: u8,
+    ) -> ResultTest<()> {
+        let to_bstan = |pv: &ProductValue| {
+            Bytes::from(to_vec(&AlgebraicValue::Array([pv.clone()].into())).expect("bstan serialization failed"))
+        };
+
+        let row_pv = |v: u8| ProductValue::from_iter(vec![AlgebraicValue::U8(v)]);
+
+        let mut tx = begin_mut_tx(stdb);
+        tx.subscribe_view(view_id, ArgId::SENTINEL, sender)?;
+        stdb.materialize_view(&mut tx, table_id, sender, row_type, to_bstan(&row_pv(v)), typespace)?;
+        stdb.commit_tx(tx)?;
+
+        Ok(())
+    }
+
+    fn project_views(stdb: &TestDB, table_id: TableId, sender: Identity) -> Vec<ProductValue> {
+        let tx = begin_tx(stdb);
+
+        stdb.iter_by_col_eq(&tx, table_id, 0, &sender.into())
+            .unwrap()
+            .map(|row| {
+                let pv = row.to_product_value();
+                ProductValue {
+                    elements: pv.elements.iter().skip(1).cloned().collect(),
+                }
+            })
+            .collect()
+    }
+
+
+    #[test]
+    fn test_view_tables_are_ephemeral() -> ResultTest<()> {
+        let stdb = TestDB::durable()?;
+
+        let (view_id, table_id, module_def, view_def) = setup_view(&stdb)?;
+        let row_type = view_def.product_type_ref;
+        let typespace = module_def.typespace();
+
+        // Write some rows (reusing the same helper)
+        insert_view_row(&stdb, view_id, table_id, typespace, row_type, Identity::ONE, 10)?;
+        insert_view_row(&stdb, view_id, table_id, typespace, row_type, Identity::ZERO, 20)?;
+
+        assert!(
+            !project_views(&stdb, table_id, Identity::ZERO).is_empty(),
+            "View table should NOT be empty after insert"
+        );
+
+        // Reopen the database — view tables must not persist
+        let stdb = stdb.reopen()?;
+
+        // Validate that the view's backing table has been removed
+        assert!(
+            project_views(&stdb, table_id, Identity::ZERO).is_empty(),
+            "View table should be empty after reopening the database"
+        );
+
+        let tx = begin_mut_tx(&stdb);
+        let subs_rows = tx.lookup_st_view_subs(view_id)?;
+        assert!(
+            subs_rows.is_empty(),
+            "st_view_subs should be empty after reopening the database"
+        );
+        Ok(())
+    }
+
     #[test]
     fn test_table_name() -> ResultTest<()> {
         let stdb = TestDB::durable()?;

crates/datastore/src/traits.rs

@@ -197,7 +197,7 @@ pub struct TxData {
     /// Set of ephemeral tables modified in this transaction (only populated when a view is executed).
     /// These tables do not need to be persisted to disk.
     /// Every table listed here must appear in either `inserts` or `deletes`.
-    ephermal_tables: Option<EphemeralTables>,
+    ephemeral_tables: Option<EphemeralTables>,
 }
 
 impl TxData {
@@ -241,15 +241,15 @@ impl TxData {
     pub fn set_ephemeral_tables(&mut self, all_ephemeral_tables: &EphemeralTables) {
         for tid in self.tables.keys() {
             if all_ephemeral_tables.contains(tid) {
-                self.ephermal_tables
+                self.ephemeral_tables
                     .get_or_insert_with(EphemeralTables::default)
                     .insert(*tid);
             }
         }
     }
 
-    pub fn ephermal_tables(&self) -> Option<&EphemeralTables> {
-        self.ephermal_tables.as_ref()
+    pub fn ephemeral_tables(&self) -> Option<&EphemeralTables> {
+        self.ephemeral_tables.as_ref()
     }
 
     /// Obtain an iterator over the inserted rows per table.
@@ -286,7 +286,7 @@ impl TxData {
     pub fn durable_deletes(&self) -> impl Iterator<Item = (&TableId, &Arc<[ProductValue]>)> + '_ {
         self.deletes.iter().filter(move |(table_id, _)| {
             !self
-                .ephermal_tables
+                .ephemeral_tables
                 .as_ref()
                 .is_some_and(|etables| etables.contains(*table_id))
         })