Add tests of triviality (linera-io#3040)

* Add tests of triviality in the `db_storage` for `contains_keys`, `read_multi_values`, and `write_batch`. * Remove the tests in `ScyllaDb` since they should be matched before the calls. * Add the tests of triviality for `LruCachingStore` since the input can be non-trivial but match the cache. * Add the code for the `load` of the `linera-views-derive` since many containers have `NUM_INIT_KEYS=0` and the compiler should be able to optimize it away. * Add the test in the `Context` to handle the test for the views.
christos-h · Dec 17, 2024 · 95d7316 · 95d7316
1 parent f76d8c4
commit 95d7316
Show file tree

Hide file tree

Showing 21 changed files with 162 additions and 73 deletions.
diff --git a/linera-storage/src/db_storage.rs b/linera-storage/src/db_storage.rs
@@ -422,6 +422,9 @@ where
     }
 
     async fn read_blobs(&self, blob_ids: &[BlobId]) -> Result<Vec<Option<Blob>>, ViewError> {
+        if blob_ids.is_empty() {
+            return Ok(Vec::new());
+        }
         let blob_keys = blob_ids
             .iter()
             .map(|blob_id| bcs::to_bytes(&BaseKey::Blob(*blob_id)))
@@ -452,6 +455,9 @@ where
     }
 
     async fn read_blob_states(&self, blob_ids: &[BlobId]) -> Result<Vec<BlobState>, ViewError> {
+        if blob_ids.is_empty() {
+            return Ok(Vec::new());
+        }
         let blob_state_keys = blob_ids
             .iter()
             .map(|blob_id| bcs::to_bytes(&BaseKey::BlobState(*blob_id)))
@@ -524,6 +530,9 @@ where
         blob_ids: &[BlobId],
         blob_state: BlobState,
     ) -> Result<Vec<Epoch>, ViewError> {
+        if blob_ids.is_empty() {
+            return Ok(Vec::new());
+        }
         let blob_state_keys = blob_ids
             .iter()
             .map(|blob_id| bcs::to_bytes(&BaseKey::BlobState(*blob_id)))
@@ -567,6 +576,9 @@ where
     }
 
     async fn write_blobs(&self, blobs: &[Blob]) -> Result<(), ViewError> {
+        if blobs.is_empty() {
+            return Ok(());
+        }
         let mut batch = Batch::new();
         for blob in blobs {
             Self::add_blob_to_batch(blob, &mut batch)?;
@@ -614,6 +626,9 @@ where
         hashes: I,
     ) -> Result<Vec<ConfirmedBlockCertificate>, ViewError> {
         let hashes = hashes.into_iter().collect::<Vec<_>>();
+        if hashes.is_empty() {
+            return Ok(Vec::new());
+        }
         let keys = Self::get_keys_for_certificates(&hashes)?;
         let values = self.store.read_multi_values_bytes(keys).await;
         if values.is_ok() {

diff --git a/linera-views-derive/src/lib.rs b/linera-views-derive/src/lib.rs
@@ -190,9 +190,13 @@ fn generate_view_code(input: ItemStruct, root: bool) -> TokenStream2 {
             async fn load(context: #context) -> Result<Self, linera_views::views::ViewError> {
                 use linera_views::context::Context as _;
                 #load_metrics
-                let keys = Self::pre_load(&context)?;
-                let values = context.read_multi_values_bytes(keys).await?;
-                Self::post_load(context, &values)
+                if Self::NUM_INIT_KEYS == 0 {
+                    Self::post_load(context, &[])
+                } else {
+                    let keys = Self::pre_load(&context)?;
+                    let values = context.read_multi_values_bytes(keys).await?;
+                    Self::post_load(context, &values)
+                }
             }
 
 

diff --git a/linera-views-derive/src/snapshots/linera_views_derive__tests__test_generate_view_code_C.snap b/linera-views-derive/src/snapshots/linera_views_derive__tests__test_generate_view_code_C.snap
@@ -64,9 +64,13 @@ where
     }
     async fn load(context: C) -> Result<Self, linera_views::views::ViewError> {
         use linera_views::context::Context as _;
-        let keys = Self::pre_load(&context)?;
-        let values = context.read_multi_values_bytes(keys).await?;
-        Self::post_load(context, &values)
+        if Self::NUM_INIT_KEYS == 0 {
+            Self::post_load(context, &[])
+        } else {
+            let keys = Self::pre_load(&context)?;
+            let values = context.read_multi_values_bytes(keys).await?;
+            Self::post_load(context, &values)
+        }
     }
     fn rollback(&mut self) {
         self.register.rollback();

diff --git a/...erive/src/snapshots/linera_views_derive__tests__test_generate_view_code_C_with_where.snap b/...erive/src/snapshots/linera_views_derive__tests__test_generate_view_code_C_with_where.snap
@@ -65,9 +65,13 @@ where
     }
     async fn load(context: C) -> Result<Self, linera_views::views::ViewError> {
         use linera_views::context::Context as _;
-        let keys = Self::pre_load(&context)?;
-        let values = context.read_multi_values_bytes(keys).await?;
-        Self::post_load(context, &values)
+        if Self::NUM_INIT_KEYS == 0 {
+            Self::post_load(context, &[])
+        } else {
+            let keys = Self::pre_load(&context)?;
+            let values = context.read_multi_values_bytes(keys).await?;
+            Self::post_load(context, &values)
+        }
     }
     fn rollback(&mut self) {
         self.register.rollback();

diff --git a/...rive/src/snapshots/linera_views_derive__tests__test_generate_view_code_CustomContext.snap b/...rive/src/snapshots/linera_views_derive__tests__test_generate_view_code_CustomContext.snap
@@ -76,9 +76,13 @@ impl linera_views::views::View<CustomContext> for TestView {
         context: CustomContext,
     ) -> Result<Self, linera_views::views::ViewError> {
         use linera_views::context::Context as _;
-        let keys = Self::pre_load(&context)?;
-        let values = context.read_multi_values_bytes(keys).await?;
-        Self::post_load(context, &values)
+        if Self::NUM_INIT_KEYS == 0 {
+            Self::post_load(context, &[])
+        } else {
+            let keys = Self::pre_load(&context)?;
+            let values = context.read_multi_values_bytes(keys).await?;
+            Self::post_load(context, &values)
+        }
     }
     fn rollback(&mut self) {
         self.register.rollback();

diff --git a/...apshots/linera_views_derive__tests__test_generate_view_code_CustomContext_with_where.snap b/...apshots/linera_views_derive__tests__test_generate_view_code_CustomContext_with_where.snap
@@ -79,9 +79,13 @@ where
         context: CustomContext,
     ) -> Result<Self, linera_views::views::ViewError> {
         use linera_views::context::Context as _;
-        let keys = Self::pre_load(&context)?;
-        let values = context.read_multi_values_bytes(keys).await?;
-        Self::post_load(context, &values)
+        if Self::NUM_INIT_KEYS == 0 {
+            Self::post_load(context, &[])
+        } else {
+            let keys = Self::pre_load(&context)?;
+            let values = context.read_multi_values_bytes(keys).await?;
+            Self::post_load(context, &values)
+        }
     }
     fn rollback(&mut self) {
         self.register.rollback();

diff --git a/...pshots/linera_views_derive__tests__test_generate_view_code_custom__GenericContext_T_.snap b/...pshots/linera_views_derive__tests__test_generate_view_code_custom__GenericContext_T_.snap
@@ -80,9 +80,13 @@ impl linera_views::views::View<custom::GenericContext<T>> for TestView {
         context: custom::GenericContext<T>,
     ) -> Result<Self, linera_views::views::ViewError> {
         use linera_views::context::Context as _;
-        let keys = Self::pre_load(&context)?;
-        let values = context.read_multi_values_bytes(keys).await?;
-        Self::post_load(context, &values)
+        if Self::NUM_INIT_KEYS == 0 {
+            Self::post_load(context, &[])
+        } else {
+            let keys = Self::pre_load(&context)?;
+            let values = context.read_multi_values_bytes(keys).await?;
+            Self::post_load(context, &values)
+        }
     }
     fn rollback(&mut self) {
         self.register.rollback();

diff --git a/...ra_views_derive__tests__test_generate_view_code_custom__GenericContext_T__with_where.snap b/...ra_views_derive__tests__test_generate_view_code_custom__GenericContext_T__with_where.snap
@@ -83,9 +83,13 @@ where
         context: custom::GenericContext<T>,
     ) -> Result<Self, linera_views::views::ViewError> {
         use linera_views::context::Context as _;
-        let keys = Self::pre_load(&context)?;
-        let values = context.read_multi_values_bytes(keys).await?;
-        Self::post_load(context, &values)
+        if Self::NUM_INIT_KEYS == 0 {
+            Self::post_load(context, &[])
+        } else {
+            let keys = Self::pre_load(&context)?;
+            let values = context.read_multi_values_bytes(keys).await?;
+            Self::post_load(context, &values)
+        }
     }
     fn rollback(&mut self) {
         self.register.rollback();

diff --git a/...ts/linera_views_derive__tests__test_generate_view_code_custom__path__to__ContextType.snap b/...ts/linera_views_derive__tests__test_generate_view_code_custom__path__to__ContextType.snap
@@ -80,9 +80,13 @@ impl linera_views::views::View<custom::path::to::ContextType> for TestView {
         context: custom::path::to::ContextType,
     ) -> Result<Self, linera_views::views::ViewError> {
         use linera_views::context::Context as _;
-        let keys = Self::pre_load(&context)?;
-        let values = context.read_multi_values_bytes(keys).await?;
-        Self::post_load(context, &values)
+        if Self::NUM_INIT_KEYS == 0 {
+            Self::post_load(context, &[])
+        } else {
+            let keys = Self::pre_load(&context)?;
+            let values = context.read_multi_values_bytes(keys).await?;
+            Self::post_load(context, &values)
+        }
     }
     fn rollback(&mut self) {
         self.register.rollback();

diff --git a/...iews_derive__tests__test_generate_view_code_custom__path__to__ContextType_with_where.snap b/...iews_derive__tests__test_generate_view_code_custom__path__to__ContextType_with_where.snap
@@ -84,9 +84,13 @@ where
         context: custom::path::to::ContextType,
     ) -> Result<Self, linera_views::views::ViewError> {
         use linera_views::context::Context as _;
-        let keys = Self::pre_load(&context)?;
-        let values = context.read_multi_values_bytes(keys).await?;
-        Self::post_load(context, &values)
+        if Self::NUM_INIT_KEYS == 0 {
+            Self::post_load(context, &[])
+        } else {
+            let keys = Self::pre_load(&context)?;
+            let values = context.read_multi_values_bytes(keys).await?;
+            Self::post_load(context, &values)
+        }
     }
     fn rollback(&mut self) {
         self.register.rollback();

diff --git a/...s-derive/src/snapshots/linera_views_derive__tests__test_generate_view_code_metrics_C.snap b/...s-derive/src/snapshots/linera_views_derive__tests__test_generate_view_code_metrics_C.snap
@@ -73,9 +73,13 @@ where
         #[cfg(not(target_arch = "wasm32"))]
         use linera_views::metrics::prometheus_util::MeasureLatency as _;
         let _latency = linera_views::metrics::LOAD_VIEW_LATENCY.measure_latency();
-        let keys = Self::pre_load(&context)?;
-        let values = context.read_multi_values_bytes(keys).await?;
-        Self::post_load(context, &values)
+        if Self::NUM_INIT_KEYS == 0 {
+            Self::post_load(context, &[])
+        } else {
+            let keys = Self::pre_load(&context)?;
+            let values = context.read_multi_values_bytes(keys).await?;
+            Self::post_load(context, &values)
+        }
     }
     fn rollback(&mut self) {
         self.register.rollback();

diff --git a/...c/snapshots/linera_views_derive__tests__test_generate_view_code_metrics_C_with_where.snap b/...c/snapshots/linera_views_derive__tests__test_generate_view_code_metrics_C_with_where.snap
@@ -74,9 +74,13 @@ where
         #[cfg(not(target_arch = "wasm32"))]
         use linera_views::metrics::prometheus_util::MeasureLatency as _;
         let _latency = linera_views::metrics::LOAD_VIEW_LATENCY.measure_latency();
-        let keys = Self::pre_load(&context)?;
-        let values = context.read_multi_values_bytes(keys).await?;
-        Self::post_load(context, &values)
+        if Self::NUM_INIT_KEYS == 0 {
+            Self::post_load(context, &[])
+        } else {
+            let keys = Self::pre_load(&context)?;
+            let values = context.read_multi_values_bytes(keys).await?;
+            Self::post_load(context, &values)
+        }
     }
     fn rollback(&mut self) {
         self.register.rollback();

diff --git a/.../snapshots/linera_views_derive__tests__test_generate_view_code_metrics_CustomContext.snap b/.../snapshots/linera_views_derive__tests__test_generate_view_code_metrics_CustomContext.snap
@@ -85,9 +85,13 @@ impl linera_views::views::View<CustomContext> for TestView {
         #[cfg(not(target_arch = "wasm32"))]
         use linera_views::metrics::prometheus_util::MeasureLatency as _;
         let _latency = linera_views::metrics::LOAD_VIEW_LATENCY.measure_latency();
-        let keys = Self::pre_load(&context)?;
-        let values = context.read_multi_values_bytes(keys).await?;
-        Self::post_load(context, &values)
+        if Self::NUM_INIT_KEYS == 0 {
+            Self::post_load(context, &[])
+        } else {
+            let keys = Self::pre_load(&context)?;
+            let values = context.read_multi_values_bytes(keys).await?;
+            Self::post_load(context, &values)
+        }
     }
     fn rollback(&mut self) {
         self.register.rollback();

diff --git a/...linera_views_derive__tests__test_generate_view_code_metrics_CustomContext_with_where.snap b/...linera_views_derive__tests__test_generate_view_code_metrics_CustomContext_with_where.snap
@@ -88,9 +88,13 @@ where
         #[cfg(not(target_arch = "wasm32"))]
         use linera_views::metrics::prometheus_util::MeasureLatency as _;
         let _latency = linera_views::metrics::LOAD_VIEW_LATENCY.measure_latency();
-        let keys = Self::pre_load(&context)?;
-        let values = context.read_multi_values_bytes(keys).await?;
-        Self::post_load(context, &values)
+        if Self::NUM_INIT_KEYS == 0 {
+            Self::post_load(context, &[])
+        } else {
+            let keys = Self::pre_load(&context)?;
+            let values = context.read_multi_values_bytes(keys).await?;
+            Self::post_load(context, &values)
+        }
     }
     fn rollback(&mut self) {
         self.register.rollback();

diff --git a/...inera_views_derive__tests__test_generate_view_code_metrics_custom__GenericContext_T_.snap b/...inera_views_derive__tests__test_generate_view_code_metrics_custom__GenericContext_T_.snap
@@ -89,9 +89,13 @@ impl linera_views::views::View<custom::GenericContext<T>> for TestView {
         #[cfg(not(target_arch = "wasm32"))]
         use linera_views::metrics::prometheus_util::MeasureLatency as _;
         let _latency = linera_views::metrics::LOAD_VIEW_LATENCY.measure_latency();
-        let keys = Self::pre_load(&context)?;
-        let values = context.read_multi_values_bytes(keys).await?;
-        Self::post_load(context, &values)
+        if Self::NUM_INIT_KEYS == 0 {
+            Self::post_load(context, &[])
+        } else {
+            let keys = Self::pre_load(&context)?;
+            let values = context.read_multi_values_bytes(keys).await?;
+            Self::post_load(context, &values)
+        }
     }
     fn rollback(&mut self) {
         self.register.rollback();

diff --git a/..._derive__tests__test_generate_view_code_metrics_custom__GenericContext_T__with_where.snap b/..._derive__tests__test_generate_view_code_metrics_custom__GenericContext_T__with_where.snap
@@ -92,9 +92,13 @@ where
         #[cfg(not(target_arch = "wasm32"))]
         use linera_views::metrics::prometheus_util::MeasureLatency as _;
         let _latency = linera_views::metrics::LOAD_VIEW_LATENCY.measure_latency();
-        let keys = Self::pre_load(&context)?;
-        let values = context.read_multi_values_bytes(keys).await?;
-        Self::post_load(context, &values)
+        if Self::NUM_INIT_KEYS == 0 {
+            Self::post_load(context, &[])
+        } else {
+            let keys = Self::pre_load(&context)?;
+            let values = context.read_multi_values_bytes(keys).await?;
+            Self::post_load(context, &values)
+        }
     }
     fn rollback(&mut self) {
         self.register.rollback();

diff --git a/...a_views_derive__tests__test_generate_view_code_metrics_custom__path__to__ContextType.snap b/...a_views_derive__tests__test_generate_view_code_metrics_custom__path__to__ContextType.snap
@@ -89,9 +89,13 @@ impl linera_views::views::View<custom::path::to::ContextType> for TestView {
         #[cfg(not(target_arch = "wasm32"))]
         use linera_views::metrics::prometheus_util::MeasureLatency as _;
         let _latency = linera_views::metrics::LOAD_VIEW_LATENCY.measure_latency();
-        let keys = Self::pre_load(&context)?;
-        let values = context.read_multi_values_bytes(keys).await?;
-        Self::post_load(context, &values)
+        if Self::NUM_INIT_KEYS == 0 {
+            Self::post_load(context, &[])
+        } else {
+            let keys = Self::pre_load(&context)?;
+            let values = context.read_multi_values_bytes(keys).await?;
+            Self::post_load(context, &values)
+        }
     }
     fn rollback(&mut self) {
         self.register.rollback();

diff --git a/...ive__tests__test_generate_view_code_metrics_custom__path__to__ContextType_with_where.snap b/...ive__tests__test_generate_view_code_metrics_custom__path__to__ContextType_with_where.snap
@@ -93,9 +93,13 @@ where
         #[cfg(not(target_arch = "wasm32"))]
         use linera_views::metrics::prometheus_util::MeasureLatency as _;
         let _latency = linera_views::metrics::LOAD_VIEW_LATENCY.measure_latency();
-        let keys = Self::pre_load(&context)?;
-        let values = context.read_multi_values_bytes(keys).await?;
-        Self::post_load(context, &values)
+        if Self::NUM_INIT_KEYS == 0 {
+            Self::post_load(context, &[])
+        } else {
+            let keys = Self::pre_load(&context)?;
+            let values = context.read_multi_values_bytes(keys).await?;
+            Self::post_load(context, &values)
+        }
     }
     fn rollback(&mut self) {
         self.register.rollback();

diff --git a/linera-views/src/backends/lru_caching.rs b/linera-views/src/backends/lru_caching.rs
@@ -173,9 +173,11 @@ where
                 }
             }
         }
-        let key_results = self.store.contains_keys(key_requests).await?;
-        for (index, result) in indices.into_iter().zip(key_results) {
-            results[index] = result;
+        if !key_requests.is_empty() {
+            let key_results = self.store.contains_keys(key_requests).await?;
+            for (index, result) in indices.into_iter().zip(key_results) {
+                results[index] = result;
+            }
         }
         Ok(results)
     }
@@ -207,17 +209,19 @@ where
                 }
             }
         }
-        let values = self
-            .store
-            .read_multi_values_bytes(miss_keys.clone())
-            .await?;
-        let mut lru_read_values = lru_read_values.lock().unwrap();
-        for (i, (key, value)) in cache_miss_indices
-            .into_iter()
-            .zip(miss_keys.into_iter().zip(values))
-        {
-            lru_read_values.insert(key, value.clone());
-            result[i] = value;
+        if !miss_keys.is_empty() {
+            let values = self
+                .store
+                .read_multi_values_bytes(miss_keys.clone())
+                .await?;
+            let mut lru_read_values = lru_read_values.lock().unwrap();
+            for (i, (key, value)) in cache_miss_indices
+                .into_iter()
+                .zip(miss_keys.into_iter().zip(values))
+            {
+                lru_read_values.insert(key, value.clone());
+                result[i] = value;
+            }
         }
         Ok(result)
     }