Merge pull request #4791 from stacks-network/feat/sqlite-feature-flag

Make rusqlite optional

Author: obycode

clarity/Cargo.toml

@@ -27,7 +27,7 @@ regex = "1"
 lazy_static = "1.4.0"
 integer-sqrt = "0.1.3"
 slog = { version = "2.5.2", features = [ "max_level_trace" ] }
-stacks_common = { package = "stacks-common", path = "../stacks-common" }
+stacks_common = { package = "stacks-common", path = "../stacks-common", optional = true, default-features = false }
 rstest = "0.17.0"
 rstest_reuse = "0.5.0"
 hashbrown = { workspace = true }
@@ -39,6 +39,7 @@ features = ["arbitrary_precision", "unbounded_depth"]
 
 [dependencies.rusqlite]
 version = "=0.24.2"
+optional = true
 features = ["blob", "serde_json", "i128_blob", "bundled", "trace"]
 
 [dependencies.time]
@@ -52,8 +53,9 @@ assert-json-diff = "1.0.0"
 # criterion = "0.3"
 
 [features]
-default = []
-developer-mode = []
+default = ["canonical"]
+canonical = ["rusqlite", "stacks_common/canonical"]
+developer-mode = ["stacks_common/developer-mode"]
 slog_json = ["stacks_common/slog_json"]
-testing = []
+testing = ["canonical"]
 devtools = []

clarity/src/vm/analysis/arithmetic_checker/tests.rs

@@ -22,12 +22,13 @@ use stacks_common::types::StacksEpochId;
 
 use crate::vm::analysis::arithmetic_checker::Error::*;
 use crate::vm::analysis::arithmetic_checker::{ArithmeticOnlyChecker, Error};
-use crate::vm::analysis::{mem_type_check, ContractAnalysis};
+use crate::vm::analysis::ContractAnalysis;
 use crate::vm::ast::parse;
 use crate::vm::costs::LimitedCostTracker;
 use crate::vm::functions::define::DefineFunctions;
 use crate::vm::functions::NativeFunctions;
 use crate::vm::tests::test_clarity_versions;
+use crate::vm::tooling::mem_type_check;
 use crate::vm::types::QualifiedContractIdentifier;
 use crate::vm::variables::NativeVariables;
 use crate::vm::ClarityVersion;

clarity/src/vm/analysis/mod.rs

@@ -37,12 +37,15 @@ use self::type_checker::v2_1::TypeChecker as TypeChecker2_1;
 pub use self::types::{AnalysisPass, ContractAnalysis};
 use crate::vm::ast::{build_ast_with_rules, ASTRules};
 use crate::vm::costs::LimitedCostTracker;
-use crate::vm::database::{MemoryBackingStore, STORE_CONTRACT_SRC_INTERFACE};
+#[cfg(feature = "canonical")]
+use crate::vm::database::MemoryBackingStore;
+use crate::vm::database::STORE_CONTRACT_SRC_INTERFACE;
 use crate::vm::representations::SymbolicExpression;
 use crate::vm::types::{QualifiedContractIdentifier, TypeSignature};
 use crate::vm::ClarityVersion;
 
 /// Used by CLI tools like the docs generator. Not used in production
+#[cfg(feature = "canonical")]
 pub fn mem_type_check(
     snippet: &str,
     version: ClarityVersion,

clarity/src/vm/analysis/type_checker/v2_05/tests/assets.rs

@@ -17,9 +17,10 @@
 use stacks_common::types::StacksEpochId;
 
 use crate::vm::analysis::errors::CheckErrors;
-use crate::vm::analysis::{mem_type_check, AnalysisDatabase};
+use crate::vm::analysis::AnalysisDatabase;
 use crate::vm::ast::parse;
 use crate::vm::database::MemoryBackingStore;
+use crate::vm::tooling::mem_type_check;
 use crate::vm::types::{
     QualifiedContractIdentifier, SequenceSubtype, StringSubtype, TypeSignature,
 };

clarity/src/vm/analysis/type_checker/v2_1/tests/mod.rs

@@ -29,7 +29,6 @@ use crate::vm::analysis::{mem_type_check as mem_run_analysis, AnalysisDatabase};
 use crate::vm::ast::errors::ParseErrors;
 use crate::vm::ast::{build_ast, parse};
 use crate::vm::contexts::OwnedEnvironment;
-use crate::vm::database::MemoryBackingStore;
 use crate::vm::representations::SymbolicExpression;
 use crate::vm::tests::test_clarity_versions;
 use crate::vm::types::signatures::TypeSignature::OptionalType;

clarity/src/vm/ast/definition_sorter/tests.rs

@@ -25,7 +25,6 @@ use crate::vm::ast::errors::{ParseErrors, ParseResult};
 use crate::vm::ast::expression_identifier::ExpressionIdentifier;
 use crate::vm::ast::parser;
 use crate::vm::ast::types::{BuildASTPass, ContractAST};
-use crate::vm::database::MemoryBackingStore;
 use crate::vm::types::QualifiedContractIdentifier;
 use crate::vm::ClarityVersion;
 

clarity/src/vm/costs/mod.rs

@@ -19,7 +19,6 @@ use std::{cmp, fmt};
 
 use hashbrown::HashMap;
 use lazy_static::lazy_static;
-use rusqlite::types::{FromSql, FromSqlResult, ToSql, ToSqlOutput, ValueRef};
 use serde::{Deserialize, Serialize};
 use stacks_common::types::StacksEpochId;
 
@@ -1166,23 +1165,6 @@ impl fmt::Display for ExecutionCost {
     }
 }
 
-impl ToSql for ExecutionCost {
-    fn to_sql(&self) -> rusqlite::Result<ToSqlOutput> {
-        let val = serde_json::to_string(self)
-            .map_err(|e| rusqlite::Error::ToSqlConversionFailure(Box::new(e)))?;
-        Ok(ToSqlOutput::from(val))
-    }
-}
-
-impl FromSql for ExecutionCost {
-    fn column_result(value: ValueRef) -> FromSqlResult<ExecutionCost> {
-        let str_val = String::column_result(value)?;
-        let parsed = serde_json::from_str(&str_val)
-            .map_err(|e| rusqlite::types::FromSqlError::Other(Box::new(e)))?;
-        Ok(parsed)
-    }
-}
-
 pub trait CostOverflowingMath<T> {
     fn cost_overflow_mul(self, other: T) -> Result<T>;
     fn cost_overflow_add(self, other: T) -> Result<T>;

clarity/src/vm/database/clarity_store.rs

@@ -16,15 +16,18 @@
 
 use std::path::PathBuf;
 
+#[cfg(feature = "canonical")]
 use rusqlite::Connection;
 use stacks_common::types::chainstate::{BlockHeaderHash, StacksBlockId, VRFSeed};
 use stacks_common::util::hash::{hex_bytes, to_hex, Hash160, Sha512Trunc256Sum};
 
 use crate::vm::analysis::AnalysisDatabase;
 use crate::vm::contexts::GlobalContext;
+#[cfg(feature = "canonical")]
+use crate::vm::database::SqliteConnection;
 use crate::vm::database::{
     BurnStateDB, ClarityDatabase, ClarityDeserializable, ClaritySerializable, HeadersDB,
-    SqliteConnection, NULL_BURN_STATE_DB, NULL_HEADER_DB,
+    NULL_BURN_STATE_DB, NULL_HEADER_DB,
 };
 use crate::vm::errors::{
     CheckErrors, IncomparableError, InterpreterError, InterpreterResult as Result,
@@ -83,6 +86,8 @@ pub trait ClarityBackingStore {
 
     fn get_open_chain_tip_height(&mut self) -> u32;
     fn get_open_chain_tip(&mut self) -> StacksBlockId;
+
+    #[cfg(feature = "canonical")]
     fn get_side_store(&mut self) -> &Connection;
 
     fn get_cc_special_cases_handler(&self) -> Option<SpecialCaseHandler> {
@@ -106,59 +111,27 @@ pub trait ClarityBackingStore {
     fn get_contract_hash(
         &mut self,
         contract: &QualifiedContractIdentifier,
-    ) -> Result<(StacksBlockId, Sha512Trunc256Sum)> {
-        let key = make_contract_hash_key(contract);
-        let contract_commitment = self
-            .get_data(&key)?
-            .map(|x| ContractCommitment::deserialize(&x))
-            .ok_or_else(|| CheckErrors::NoSuchContract(contract.to_string()))?;
-        let ContractCommitment {
-            block_height,
-            hash: contract_hash,
-        } = contract_commitment?;
-        let bhh = self.get_block_at_height(block_height)
-            .ok_or_else(|| InterpreterError::Expect("Should always be able to map from height to block hash when looking up contract information.".into()))?;
-        Ok((bhh, contract_hash))
-    }
+    ) -> Result<(StacksBlockId, Sha512Trunc256Sum)>;
 
     fn insert_metadata(
         &mut self,
         contract: &QualifiedContractIdentifier,
         key: &str,
         value: &str,
-    ) -> Result<()> {
-        let bhh = self.get_open_chain_tip();
-        SqliteConnection::insert_metadata(
-            self.get_side_store(),
-            &bhh,
-            &contract.to_string(),
-            key,
-            value,
-        )
-    }
+    ) -> Result<()>;
 
     fn get_metadata(
         &mut self,
         contract: &QualifiedContractIdentifier,
         key: &str,
-    ) -> Result<Option<String>> {
-        let (bhh, _) = self.get_contract_hash(contract)?;
-        SqliteConnection::get_metadata(self.get_side_store(), &bhh, &contract.to_string(), key)
-    }
+    ) -> Result<Option<String>>;
 
     fn get_metadata_manual(
         &mut self,
         at_height: u32,
         contract: &QualifiedContractIdentifier,
         key: &str,
-    ) -> Result<Option<String>> {
-        let bhh = self.get_block_at_height(at_height)
-            .ok_or_else(|| {
-                warn!("Unknown block height when manually querying metadata"; "block_height" => at_height);
-                RuntimeErrorType::BadBlockHeight(at_height.to_string())
-            })?;
-        SqliteConnection::get_metadata(self.get_side_store(), &bhh, &contract.to_string(), key)
-    }
+    ) -> Result<Option<String>>;
 
     fn put_all_metadata(
         &mut self,
@@ -240,6 +213,7 @@ impl ClarityBackingStore for NullBackingStore {
         panic!("NullBackingStore can't retrieve data")
     }
 
+    #[cfg(feature = "canonical")]
     fn get_side_store(&mut self) -> &Connection {
         panic!("NullBackingStore has no side store")
     }
@@ -263,84 +237,37 @@ impl ClarityBackingStore for NullBackingStore {
     fn put_all_data(&mut self, mut _items: Vec<(String, String)>) -> Result<()> {
         panic!("NullBackingStore cannot put")
     }
-}
-
-pub struct MemoryBackingStore {
-    side_store: Connection,
-}
 
-impl Default for MemoryBackingStore {
-    fn default() -> Self {
-        MemoryBackingStore::new()
-    }
-}
-
-impl MemoryBackingStore {
-    #[allow(clippy::unwrap_used)]
-    pub fn new() -> MemoryBackingStore {
-        let side_store = SqliteConnection::memory().unwrap();
-
-        let mut memory_marf = MemoryBackingStore { side_store };
-
-        memory_marf.as_clarity_db().initialize();
-
-        memory_marf
-    }
-
-    pub fn as_clarity_db(&mut self) -> ClarityDatabase {
-        ClarityDatabase::new(self, &NULL_HEADER_DB, &NULL_BURN_STATE_DB)
-    }
-
-    pub fn as_analysis_db(&mut self) -> AnalysisDatabase {
-        AnalysisDatabase::new(self)
-    }
-}
-
-impl ClarityBackingStore for MemoryBackingStore {
-    fn set_block_hash(&mut self, bhh: StacksBlockId) -> InterpreterResult<StacksBlockId> {
-        Err(RuntimeErrorType::UnknownBlockHeaderHash(BlockHeaderHash(bhh.0)).into())
-    }
-
-    fn get_data(&mut self, key: &str) -> Result<Option<String>> {
-        SqliteConnection::get(self.get_side_store(), key)
-    }
-
-    fn get_data_with_proof(&mut self, key: &str) -> Result<Option<(String, Vec<u8>)>> {
-        Ok(SqliteConnection::get(self.get_side_store(), key)?.map(|x| (x, vec![])))
-    }
-
-    fn get_side_store(&mut self) -> &Connection {
-        &self.side_store
-    }
-
-    fn get_block_at_height(&mut self, height: u32) -> Option<StacksBlockId> {
-        if height == 0 {
-            Some(StacksBlockId([255; 32]))
-        } else {
-            None
-        }
-    }
-
-    fn get_open_chain_tip(&mut self) -> StacksBlockId {
-        StacksBlockId([255; 32])
-    }
-
-    fn get_open_chain_tip_height(&mut self) -> u32 {
-        0
+    fn get_contract_hash(
+        &mut self,
+        _contract: &QualifiedContractIdentifier,
+    ) -> Result<(StacksBlockId, Sha512Trunc256Sum)> {
+        panic!("NullBackingStore cannot get_contract_hash")
     }
 
-    fn get_current_block_height(&mut self) -> u32 {
-        1
+    fn insert_metadata(
+        &mut self,
+        _contract: &QualifiedContractIdentifier,
+        _key: &str,
+        _value: &str,
+    ) -> Result<()> {
+        panic!("NullBackingStore cannot insert_metadata")
     }
 
-    fn get_cc_special_cases_handler(&self) -> Option<SpecialCaseHandler> {
-        None
+    fn get_metadata(
+        &mut self,
+        _contract: &QualifiedContractIdentifier,
+        _key: &str,
+    ) -> Result<Option<String>> {
+        panic!("NullBackingStore cannot get_metadata")
     }
 
-    fn put_all_data(&mut self, items: Vec<(String, String)>) -> Result<()> {
-        for (key, value) in items.into_iter() {
-            SqliteConnection::put(self.get_side_store(), &key, &value)?;
-        }
-        Ok(())
+    fn get_metadata_manual(
+        &mut self,
+        _at_height: u32,
+        _contract: &QualifiedContractIdentifier,
+        _key: &str,
+    ) -> Result<Option<String>> {
+        panic!("NullBackingStore cannot get_metadata_manual")
     }
 }

clarity/src/vm/database/mod.rs

@@ -15,13 +15,16 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use hashbrown::HashMap;
+#[cfg(feature = "canonical")]
+pub use sqlite::MemoryBackingStore;
 
 pub use self::clarity_db::{
     BurnStateDB, ClarityDatabase, HeadersDB, StoreType, NULL_BURN_STATE_DB, NULL_HEADER_DB,
     STORE_CONTRACT_SRC_INTERFACE,
 };
-pub use self::clarity_store::{ClarityBackingStore, MemoryBackingStore, SpecialCaseHandler};
+pub use self::clarity_store::{ClarityBackingStore, SpecialCaseHandler};
 pub use self::key_value_wrapper::{RollbackWrapper, RollbackWrapperPersistedLog};
+#[cfg(feature = "canonical")]
 pub use self::sqlite::SqliteConnection;
 pub use self::structures::{
     ClarityDeserializable, ClaritySerializable, DataMapMetadata, DataVariableMetadata,
@@ -31,5 +34,6 @@ pub use self::structures::{
 pub mod clarity_db;
 pub mod clarity_store;
 mod key_value_wrapper;
-mod sqlite;
+#[cfg(feature = "canonical")]
+pub mod sqlite;
 mod structures;