New database trait (#5549)

* Introduce trait

* The trait

* Generic

* Basic impls.

* Remove unneeded bounds

* Minor changes

* Switch over to the new DB trait

* Integrated parity-db and added CLI for db selection

* Default impl.

* Fix logs.

* Started integrating subdb

* Apply suggestions from code review

Co-Authored-By: Cecile Tonglet <cecile@parity.io>

* Apply suggestions from code review

Co-Authored-By: Nikolay Volf <nikvolf@gmail.com>

* Enable subdb

* Bump parity-db

* Fixed CLI macro

* Fixed browser build

* Fixed features

* Sort out features

* Use parity-db from crates.io

* Typo

Co-authored-by: arkpar <arkady.paronyan@gmail.com>
Co-authored-by: Cecile Tonglet <cecile@parity.io>
Co-authored-by: Nikolay Volf <nikvolf@gmail.com>

substrate/client/db/src/cache/list_storage.rs

@@ -18,17 +18,17 @@
 
 use std::sync::Arc;
 
-use kvdb::{KeyValueDB, DBTransaction};
-
 use sp_blockchain::{Error as ClientError, Result as ClientResult};
 use codec::{Encode, Decode};
 use sp_runtime::generic::BlockId;
 use sp_runtime::traits::{Block as BlockT, Header as HeaderT, NumberFor};
-use crate::utils::{self, db_err, meta_keys};
+use sp_database::{Database, Transaction};
+use crate::utils::{self, meta_keys};
 
 use crate::cache::{CacheItemT, ComplexBlockId};
 use crate::cache::list_cache::{CommitOperation, Fork};
 use crate::cache::list_entry::{Entry, StorageEntry};
+use crate::DbHash;
 
 /// Single list-cache metadata.
 #[derive(Debug)]
@@ -97,19 +97,19 @@ pub struct DbColumns {
 pub struct DbStorage {
 	name: Vec<u8>,
 	meta_key: Vec<u8>,
-	db: Arc<dyn KeyValueDB>,
+	db: Arc<dyn Database<DbHash>>,
 	columns: DbColumns,
 }
 
 impl DbStorage {
 	/// Create new database-backed list cache storage.
-	pub fn new(name: Vec<u8>, db: Arc<dyn KeyValueDB>, columns: DbColumns) -> Self {
+	pub fn new(name: Vec<u8>, db: Arc<dyn Database<DbHash>>, columns: DbColumns) -> Self {
 		let meta_key = meta::key(&name);
 		DbStorage { name, meta_key, db, columns }
 	}
 
 	/// Get reference to the database.
-	pub fn db(&self) -> &Arc<dyn KeyValueDB> { &self.db }
+	pub fn db(&self) -> &Arc<dyn Database<DbHash>> { &self.db }
 
 	/// Get reference to the database columns.
 	pub fn columns(&self) -> &DbColumns { &self.columns }
@@ -135,49 +135,45 @@ impl<Block: BlockT, T: CacheItemT> Storage<Block, T> for DbStorage {
 	}
 
 	fn read_meta(&self) -> ClientResult<Metadata<Block>> {
-		self.db.get(self.columns.meta, &self.meta_key)
-			.map_err(db_err)
-			.and_then(|meta| match meta {
-				Some(meta) => meta::decode(&*meta),
-				None => Ok(Metadata {
-					finalized: None,
-					unfinalized: Vec::new(),
-				}),
+		match self.db.get(self.columns.meta, &self.meta_key) {
+			Some(meta) => meta::decode(&*meta),
+			None => Ok(Metadata {
+				finalized: None,
+				unfinalized: Vec::new(),
 			})
+		}
 	}
 
 	fn read_entry(&self, at: &ComplexBlockId<Block>) -> ClientResult<Option<StorageEntry<Block, T>>> {
-		self.db.get(self.columns.cache, &self.encode_block_id(at))
-			.map_err(db_err)
-			.and_then(|entry| match entry {
-				Some(entry) => StorageEntry::<Block, T>::decode(&mut &entry[..])
-					.map_err(|_| ClientError::Backend("Failed to decode cache entry".into()))
-					.map(Some),
-				None => Ok(None),
-			})
+		match self.db.get(self.columns.cache, &self.encode_block_id(at)) {
+			Some(entry) => StorageEntry::<Block, T>::decode(&mut &entry[..])
+				.map_err(|_| ClientError::Backend("Failed to decode cache entry".into()))
+				.map(Some),
+			None => Ok(None),
+		}
 	}
 }
 
 /// Database-backed list cache storage transaction.
 pub struct DbStorageTransaction<'a> {
 	storage: &'a DbStorage,
-	tx: &'a mut DBTransaction,
+	tx: &'a mut Transaction<DbHash>,
 }
 
 impl<'a> DbStorageTransaction<'a> {
 	/// Create new database transaction.
-	pub fn new(storage: &'a DbStorage, tx: &'a mut DBTransaction) -> Self {
+	pub fn new(storage: &'a DbStorage, tx: &'a mut Transaction<DbHash>) -> Self {
 		DbStorageTransaction { storage, tx }
 	}
 }
 
 impl<'a, Block: BlockT, T: CacheItemT> StorageTransaction<Block, T> for DbStorageTransaction<'a> {
 	fn insert_storage_entry(&mut self, at: &ComplexBlockId<Block>, entry: &StorageEntry<Block, T>) {
-		self.tx.put(self.storage.columns.cache, &self.storage.encode_block_id(at), &entry.encode());
+		self.tx.set_from_vec(self.storage.columns.cache, &self.storage.encode_block_id(at), entry.encode());
 	}
 
 	fn remove_storage_entry(&mut self, at: &ComplexBlockId<Block>) {
-		self.tx.delete(self.storage.columns.cache, &self.storage.encode_block_id(at));
+		self.tx.remove(self.storage.columns.cache, &self.storage.encode_block_id(at));
 	}
 
 	fn update_meta(
@@ -186,10 +182,10 @@ impl<'a, Block: BlockT, T: CacheItemT> StorageTransaction<Block, T> for DbStorag
 		unfinalized: &[Fork<Block, T>],
 		operation: &CommitOperation<Block, T>,
 	) {
-		self.tx.put(
+		self.tx.set_from_vec(
 			self.storage.columns.meta,
 			&self.storage.meta_key,
-			&meta::encode(best_finalized_entry, unfinalized, operation));
+			meta::encode(best_finalized_entry, unfinalized, operation));
 	}
 }
 

substrate/client/db/src/cache/mod.rs

@@ -19,14 +19,14 @@
 use std::{sync::Arc, collections::{HashMap, hash_map::Entry}};
 use parking_lot::RwLock;
 
-use kvdb::{KeyValueDB, DBTransaction};
-
 use sc_client_api::blockchain::{well_known_cache_keys::{self, Id as CacheKeyId}, Cache as BlockchainCache};
 use sp_blockchain::Result as ClientResult;
+use sp_database::{Database, Transaction};
 use codec::{Encode, Decode};
 use sp_runtime::generic::BlockId;
 use sp_runtime::traits::{Block as BlockT, Header as HeaderT, NumberFor, Zero};
-use crate::utils::{self, COLUMN_META, db_err};
+use crate::utils::{self, COLUMN_META};
+use crate::DbHash;
 
 use self::list_cache::{ListCache, PruningStrategy};
 
@@ -78,7 +78,7 @@ impl<T> CacheItemT for T where T: Clone + Decode + Encode + PartialEq {}
 /// Database-backed blockchain data cache.
 pub struct DbCache<Block: BlockT> {
 	cache_at: HashMap<CacheKeyId, ListCache<Block, Vec<u8>, self::list_storage::DbStorage>>,
-	db: Arc<dyn KeyValueDB>,
+	db: Arc<dyn Database<DbHash>>,
 	key_lookup_column: u32,
 	header_column: u32,
 	cache_column: u32,
@@ -89,7 +89,7 @@ pub struct DbCache<Block: BlockT> {
 impl<Block: BlockT> DbCache<Block> {
 	/// Create new cache.
 	pub fn new(
-		db: Arc<dyn KeyValueDB>,
+		db: Arc<dyn Database<DbHash>>,
 		key_lookup_column: u32,
 		header_column: u32,
 		cache_column: u32,
@@ -113,7 +113,7 @@ impl<Block: BlockT> DbCache<Block> {
 	}
 
 	/// Begin cache transaction.
-	pub fn transaction<'a>(&'a mut self, tx: &'a mut DBTransaction) -> DbCacheTransaction<'a, Block> {
+	pub fn transaction<'a>(&'a mut self, tx: &'a mut Transaction<DbHash>) -> DbCacheTransaction<'a, Block> {
 		DbCacheTransaction {
 			cache: self,
 			tx,
@@ -125,7 +125,7 @@ impl<Block: BlockT> DbCache<Block> {
 	/// Begin cache transaction with given ops.
 	pub fn transaction_with_ops<'a>(
 		&'a mut self,
-		tx: &'a mut DBTransaction,
+		tx: &'a mut Transaction<DbHash>,
 		ops: DbCacheTransactionOps<Block>,
 	) -> DbCacheTransaction<'a, Block> {
 		DbCacheTransaction {
@@ -169,7 +169,7 @@ impl<Block: BlockT> DbCache<Block> {
 fn get_cache_helper<'a, Block: BlockT>(
 	cache_at: &'a mut HashMap<CacheKeyId, ListCache<Block, Vec<u8>, self::list_storage::DbStorage>>,
 	name: CacheKeyId,
-	db: &Arc<dyn KeyValueDB>,
+	db: &Arc<dyn Database<DbHash>>,
 	key_lookup: u32,
 	header: u32,
 	cache: u32,
@@ -215,7 +215,7 @@ impl<Block: BlockT> DbCacheTransactionOps<Block> {
 /// Database-backed blockchain data cache transaction valid for single block import.
 pub struct DbCacheTransaction<'a, Block: BlockT> {
 	cache: &'a mut DbCache<Block>,
-	tx: &'a mut DBTransaction,
+	tx: &'a mut Transaction<DbHash>,
 	cache_at_ops: HashMap<CacheKeyId, self::list_cache::CommitOperations<Block, Vec<u8>>>,
 	best_finalized_block: Option<ComplexBlockId<Block>>,
 }
@@ -328,7 +328,7 @@ impl<Block: BlockT> BlockchainCache<Block> for DbCacheSync<Block> {
 		let genesis_hash = cache.genesis_hash;
 		let cache_contents = vec![(*key, data)].into_iter().collect();
 		let db = cache.db.clone();
-		let mut dbtx = DBTransaction::new();
+		let mut dbtx = Transaction::new();
 		let tx = cache.transaction(&mut dbtx);
 		let tx = tx.on_block_insert(
 			ComplexBlockId::new(Default::default(), Zero::zero()),
@@ -337,7 +337,7 @@ impl<Block: BlockT> BlockchainCache<Block> for DbCacheSync<Block> {
 			EntryType::Genesis,
 		)?;
 		let tx_ops = tx.into_ops();
-		db.write(dbtx).map_err(db_err)?;
+		db.commit(dbtx);
 		cache.commit(tx_ops)?;
 		Ok(())
 	}