Implemented database optimization routine

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+### Enhancements
+
+- Implemented database optimization routine (#721).
+
 ### Fixes
 
 - Faucet webpage is missing `background.png` and `favicon.ico` (#672).

bin/node/src/config.rs

@@ -101,6 +101,7 @@ mod tests {
                     database_filepath = "local.sqlite3"
                     genesis_filepath = "genesis.dat"
                     blockstore_dir = "blocks"
+                    db_optimization_interval_secs = 86400
                 "#,
             )?;
 
@@ -120,7 +121,8 @@ mod tests {
                         endpoint: Url::parse("https://127.0.0.1:8080").unwrap(),
                         database_filepath: "local.sqlite3".into(),
                         genesis_filepath: "genesis.dat".into(),
-                        blockstore_dir: "blocks".into()
+                        blockstore_dir: "blocks".into(),
+                        db_optimization_interval_secs: 24 * 60 * 60,
                     },
                 }
             );

crates/store/src/config.rs

@@ -21,13 +21,25 @@ pub struct StoreConfig {
     pub genesis_filepath: PathBuf,
     /// Block store directory
     pub blockstore_dir: PathBuf,
+    /// Database optimization interval in seconds
+    pub db_optimization_interval_secs: u64,
 }
 
 impl Display for StoreConfig {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         f.write_fmt(format_args!(
-            "{{ endpoint: \"{}\",  database_filepath: {:?}, genesis_filepath: {:?}, blockstore_dir: {:?} }}",
-            self.endpoint, self.database_filepath, self.genesis_filepath, self.blockstore_dir
+            "{{ \
+                endpoint: \"{}\", \
+                database_filepath: {:?}, \
+                genesis_filepath: {:?}, \
+                blockstore_dir: {:?}, \
+                db_optimization_interval_secs: {} \
+            }}",
+            self.endpoint,
+            self.database_filepath,
+            self.genesis_filepath,
+            self.blockstore_dir,
+            self.db_optimization_interval_secs
         ))
     }
 }
@@ -41,6 +53,7 @@ impl Default for StoreConfig {
             database_filepath: PathBuf::from(NODE_STORE_DIR.to_string() + "miden-store.sqlite3"),
             genesis_filepath: PathBuf::from(NODE_STORE_DIR.to_string() + "genesis.dat"),
             blockstore_dir: PathBuf::from(NODE_STORE_DIR.to_string() + "blocks"),
+            db_optimization_interval_secs: 24 * 60 * 60, // 24 hours
         }
     }
 }

crates/store/src/db/migrations.rs

@@ -75,6 +75,20 @@ pub fn apply_migrations(conn: &mut Connection) -> super::Result<()> {
         Settings::set_value(conn, DB_MIGRATION_HASH_FIELD, &new_hash)?;
     }
 
+    info!(target: COMPONENT, "Starting database optimization");
+
+    // Run full database optimization. This will run indexes analysis for the query planner.
+    // This will also increase the `schema_version` value.
+    //
+    // We should run full database optimization in following cases:
+    // 1. Once schema was changed, especially new indexes were created.
+    // 2. After restarting of the node, on first connection established.
+    //
+    // More info: https://www.sqlite.org/pragma.html#pragma_optimize
+    conn.execute("PRAGMA optimize = 0x10002;", ())?;
+
+    info!(target: COMPONENT, "Finished database optimization");
+
     let new_schema_version = schema_version(conn)?;
     debug!(target: COMPONENT, new_schema_version, "Updating schema version in settings table");
     Settings::set_value(conn, DB_SCHEMA_VERSION_FIELD, &new_schema_version)?;

crates/store/src/db/mod.rs

@@ -222,7 +222,9 @@ impl Db {
                         })
                         .await
                         .map_err(|e| {
-                            HookError::Message(format!("Loading carray module failed: {e}").into())
+                            HookError::Message(
+                                format!("Failed to configure connection: {e}").into(),
+                            )
                         })?;
 
                     Ok(())
@@ -515,6 +517,23 @@ impl Db {
             .map_err(|err| DatabaseError::InteractError(err.to_string()))?
     }
 
+    /// Runs database optimization.
+    #[instrument(target = COMPONENT, skip_all, err)]
+    pub async fn optimize(&self) -> Result<(), DatabaseError> {
+        self.pool
+            .get()
+            .await?
+            .interact(move |conn| -> Result<()> {
+                conn.execute("PRAGMA optimize;", ())
+                    .map(|_| ())
+                    .map_err(DatabaseError::SqliteError)
+            })
+            .await
+            .map_err(|err| {
+                DatabaseError::InteractError(format!("Database optimization task failed: {err}"))
+            })?
+    }
+
     // HELPERS
     // ---------------------------------------------------------------------------------------------
 

crates/store/src/db/sql/utils.rs

@@ -47,7 +47,7 @@ macro_rules! subst {
 ///
 /// # Usage:
 ///
-/// ```
+/// ```ignore
 /// insert_sql!(users { id, first_name, last_name, age });
 /// ```
 /// which generates:

crates/store/src/server/api.rs

@@ -487,7 +487,7 @@ impl api_server::Api for StoreApi {
 
         Ok(Response::new(GetAccountProofsResponse {
             block_num: block_num.as_u32(),
-            account_proofs: infos.into_iter().map(Into::into).collect(),
+            account_proofs: infos.into_iter().collect(),
         }))
     }
 

crates/store/src/server/db_maintenance.rs

@@ -0,0 +1,30 @@
+use std::{sync::Arc, time::Duration};
+
+use tracing::{error, info};
+
+use crate::{state::State, COMPONENT};
+
+pub struct DbMaintenance {
+    state: Arc<State>,
+    optimization_interval: Duration,
+}
+
+impl DbMaintenance {
+    pub fn new(state: Arc<State>, optimization_interval: Duration) -> Self {
+        Self { state, optimization_interval }
+    }
+
+    /// Runs infinite maintenance loop.
+    pub async fn run(self) {
+        loop {
+            tokio::time::sleep(self.optimization_interval).await;
+
+            info!(target: COMPONENT, "Starting database optimization");
+
+            match self.state.optimize_db().await {
+                Ok(_) => info!(target: COMPONENT, "Finished database optimization"),
+                Err(err) => error!(target: COMPONENT, %err, "Database optimization failed"),
+            }
+        }
+    }
+}

crates/store/src/server/mod.rs

@@ -1,14 +1,18 @@
-use std::sync::Arc;
+use std::{sync::Arc, time::Duration};
 
 use miden_node_proto::generated::store::api_server;
 use miden_node_utils::errors::ApiError;
 use tokio::net::TcpListener;
 use tokio_stream::wrappers::TcpListenerStream;
 use tracing::info;
 
-use crate::{blocks::BlockStore, config::StoreConfig, db::Db, state::State, COMPONENT};
+use crate::{
+    blocks::BlockStore, config::StoreConfig, db::Db, server::db_maintenance::DbMaintenance,
+    state::State, COMPONENT,
+};
 
 mod api;
+mod db_maintenance;
 
 /// Represents an initialized store component where the RPC connection is open, but not yet actively
 /// responding to requests.
@@ -18,6 +22,7 @@ mod api;
 /// components.
 pub struct Store {
     api_service: api_server::ApiServer<api::StoreApi>,
+    db_maintenance_service: DbMaintenance,
     listener: TcpListener,
 }
 
@@ -40,6 +45,10 @@ impl Store {
                 .map_err(|err| ApiError::DatabaseConnectionFailed(err.to_string()))?,
         );
 
+        let db_maintenance_service = DbMaintenance::new(
+            Arc::clone(&state),
+            Duration::from_secs(config.db_optimization_interval_secs),
+        );
         let api_service = api_server::ApiServer::new(api::StoreApi { state });
 
         let addr = config
@@ -54,13 +63,18 @@ impl Store {
 
         info!(target: COMPONENT, "Database loaded");
 
-        Ok(Self { api_service, listener })
+        Ok(Self {
+            api_service,
+            db_maintenance_service,
+            listener,
+        })
     }
 
-    /// Serves the store's RPC API.
+    /// Serves the store's RPC API and DB maintenance background task.
     ///
     /// Note: this blocks until the server dies.
     pub async fn serve(self) -> Result<(), ApiError> {
+        tokio::spawn(self.db_maintenance_service.run());
         tonic::transport::Server::builder()
             .trace_fn(miden_node_utils::tracing::grpc::store_trace_fn)
             .add_service(self.api_service)

crates/store/src/state.rs

@@ -962,10 +962,7 @@ impl State {
         from_block: BlockNumber,
         to_block: BlockNumber,
     ) -> Result<Option<AccountDelta>, DatabaseError> {
-        self.db
-            .select_account_state_delta(account_id, from_block, to_block)
-            .await
-            .map_err(Into::into)
+        self.db.select_account_state_delta(account_id, from_block, to_block).await
     }
 
     /// Loads a block from the block store. Return `Ok(None)` if the block is not found.
@@ -983,6 +980,11 @@ impl State {
     pub async fn latest_block_num(&self) -> BlockNumber {
         self.inner.read().await.latest_block_num()
     }
+
+    /// Runs database optimization.
+    pub async fn optimize_db(&self) -> Result<(), DatabaseError> {
+        self.db.optimize().await
+    }
 }
 
 // UTILITIES