diff --git a/ethcore/src/blockchain/blockchain.rs b/ethcore/src/blockchain/blockchain.rs index e76cf42c4..379d77407 100644 --- a/ethcore/src/blockchain/blockchain.rs +++ b/ethcore/src/blockchain/blockchain.rs @@ -380,7 +380,7 @@ impl BlockChain { children: vec![] }; - let batch = DBTransaction::new(&db); + let mut batch = DBTransaction::new(&db); batch.put(db::COL_HEADERS, &hash, block.header_rlp().as_raw()); batch.put(db::COL_BODIES, &hash, &Self::block_to_body(genesis)); @@ -419,7 +419,7 @@ impl BlockChain { } } - let batch = db.transaction(); + let mut batch = db.transaction(); batch.put(db::COL_EXTRA, b"first", &hash); db.write(batch).expect("Low level database error."); @@ -451,7 +451,7 @@ impl BlockChain { #[cfg(test)] fn rewind(&self) -> Option { use db::Key; - let batch = self.db.transaction(); + let mut batch =self.db.transaction(); // track back to the best block we have in the blocks database if let Some(best_block_hash) = self.db.get(db::COL_EXTRA, b"best").unwrap() { let best_block_hash = H256::from_slice(&best_block_hash); @@ -604,7 +604,7 @@ impl BlockChain { assert!(self.pending_best_block.read().is_none()); - let batch = self.db.transaction(); + let mut batch = self.db.transaction(); let block_rlp = UntrustedRlp::new(bytes); let compressed_header = block_rlp.at(0).unwrap().compress(RlpType::Blocks); @@ -625,7 +625,7 @@ impl BlockChain { location: BlockLocation::CanonChain, }; - self.prepare_update(&batch, ExtrasUpdate { + self.prepare_update(&mut batch, ExtrasUpdate { block_hashes: self.prepare_block_hashes_update(bytes, &info), block_details: self.prepare_block_details_update(bytes, &info), block_receipts: self.prepare_block_receipts_update(receipts, &info), @@ -659,7 +659,7 @@ impl BlockChain { let mut update = HashMap::new(); update.insert(hash, block_details); - self.prepare_update(&batch, ExtrasUpdate { + self.prepare_update(&mut batch, ExtrasUpdate { block_hashes: self.prepare_block_hashes_update(bytes, &info), block_details: update, block_receipts: self.prepare_block_receipts_update(receipts, &info), @@ -682,7 +682,7 @@ impl BlockChain { let mut parent_details = self.block_details(&block_hash) .unwrap_or_else(|| panic!("Invalid block hash: {:?}", block_hash)); - let batch = self.db.transaction(); + let mut batch = self.db.transaction(); parent_details.children.push(child_hash); let mut update = HashMap::new(); @@ -701,7 +701,7 @@ impl BlockChain { /// Inserts the block into backing cache database. /// Expects the block to be valid and already verified. /// If the block is already known, does nothing. - pub fn insert_block(&self, batch: &DBTransaction, bytes: &[u8], receipts: Vec) -> ImportRoute { + pub fn insert_block(&self, batch: &mut DBTransaction, bytes: &[u8], receipts: Vec) -> ImportRoute { // create views onto rlp let block = BlockView::new(bytes); let header = block.header_view(); @@ -782,7 +782,7 @@ impl BlockChain { } /// Prepares extras update. - fn prepare_update(&self, batch: &DBTransaction, update: ExtrasUpdate, is_best: bool) { + fn prepare_update(&self, batch: &mut DBTransaction, update: ExtrasUpdate, is_best: bool) { { let block_hashes: Vec<_> = update.block_details.keys().cloned().collect(); @@ -1147,8 +1147,8 @@ mod tests { assert_eq!(bc.best_block_number(), 0); // when - let batch = db.transaction(); - bc.insert_block(&batch, &first, vec![]); + let mut batch =db.transaction(); + bc.insert_block(&mut batch, &first, vec![]); assert_eq!(bc.best_block_number(), 0); bc.commit(); // NOTE no db.write here (we want to check if best block is cached) @@ -1177,8 +1177,8 @@ mod tests { assert_eq!(bc.block_hash(1), None); assert_eq!(bc.block_details(&genesis_hash).unwrap().children, vec![]); - let batch = db.transaction(); - bc.insert_block(&batch, &first, vec![]); + let mut batch =db.transaction(); + bc.insert_block(&mut batch, &first, vec![]); db.write(batch).unwrap(); bc.commit(); @@ -1203,11 +1203,11 @@ mod tests { let bc = BlockChain::new(Config::default(), &genesis, db.clone()); let mut block_hashes = vec![genesis_hash.clone()]; - let batch = db.transaction(); + let mut batch =db.transaction(); for _ in 0..10 { let block = canon_chain.generate(&mut finalizer).unwrap(); block_hashes.push(BlockView::new(&block).header_view().sha3()); - bc.insert_block(&batch, &block, vec![]); + bc.insert_block(&mut batch, &block, vec![]); bc.commit(); } db.write(batch).unwrap(); @@ -1238,20 +1238,20 @@ mod tests { let db = new_db(temp.as_str()); let bc = BlockChain::new(Config::default(), &genesis, db.clone()); - let batch = db.transaction(); + let mut batch =db.transaction(); for b in &[&b1a, &b1b, &b2a, &b2b, &b3a, &b3b, &b4a, &b4b, &b5a, &b5b] { - bc.insert_block(&batch, b, vec![]); + bc.insert_block(&mut batch, b, vec![]); bc.commit(); } - bc.insert_block(&batch, &b1b, vec![]); - bc.insert_block(&batch, &b2a, vec![]); - bc.insert_block(&batch, &b2b, vec![]); - bc.insert_block(&batch, &b3a, vec![]); - bc.insert_block(&batch, &b3b, vec![]); - bc.insert_block(&batch, &b4a, vec![]); - bc.insert_block(&batch, &b4b, vec![]); - bc.insert_block(&batch, &b5a, vec![]); - bc.insert_block(&batch, &b5b, vec![]); + bc.insert_block(&mut batch, &b1b, vec![]); + bc.insert_block(&mut batch, &b2a, vec![]); + bc.insert_block(&mut batch, &b2b, vec![]); + bc.insert_block(&mut batch, &b3a, vec![]); + bc.insert_block(&mut batch, &b3b, vec![]); + bc.insert_block(&mut batch, &b4a, vec![]); + bc.insert_block(&mut batch, &b4b, vec![]); + bc.insert_block(&mut batch, &b5a, vec![]); + bc.insert_block(&mut batch, &b5b, vec![]); db.write(batch).unwrap(); assert_eq!( @@ -1286,17 +1286,17 @@ mod tests { let db = new_db(temp.as_str()); let bc = BlockChain::new(Config::default(), &genesis, db.clone()); - let batch = db.transaction(); - let ir1 = bc.insert_block(&batch, &b1, vec![]); + let mut batch =db.transaction(); + let ir1 = bc.insert_block(&mut batch, &b1, vec![]); bc.commit(); - let ir2 = bc.insert_block(&batch, &b2, vec![]); + let ir2 = bc.insert_block(&mut batch, &b2, vec![]); bc.commit(); - let ir3b = bc.insert_block(&batch, &b3b, vec![]); + let ir3b = bc.insert_block(&mut batch, &b3b, vec![]); bc.commit(); db.write(batch).unwrap(); assert_eq!(bc.block_hash(3).unwrap(), b3b_hash); - let batch = db.transaction(); - let ir3a = bc.insert_block(&batch, &b3a, vec![]); + let mut batch =db.transaction(); + let ir3a = bc.insert_block(&mut batch, &b3a, vec![]); bc.commit(); db.write(batch).unwrap(); @@ -1402,8 +1402,8 @@ mod tests { let db = new_db(temp.as_str()); let bc = BlockChain::new(Config::default(), &genesis, db.clone()); assert_eq!(bc.best_block_hash(), genesis_hash); - let batch = db.transaction(); - bc.insert_block(&batch, &first, vec![]); + let mut batch =db.transaction(); + bc.insert_block(&mut batch, &first, vec![]); db.write(batch).unwrap(); bc.commit(); assert_eq!(bc.best_block_hash(), first_hash); @@ -1467,8 +1467,8 @@ mod tests { let temp = RandomTempPath::new(); let db = new_db(temp.as_str()); let bc = BlockChain::new(Config::default(), &genesis, db.clone()); - let batch = db.transaction(); - bc.insert_block(&batch, &b1, vec![]); + let mut batch =db.transaction(); + bc.insert_block(&mut batch, &b1, vec![]); db.write(batch).unwrap(); bc.commit(); @@ -1480,8 +1480,8 @@ mod tests { } fn insert_block(db: &Arc, bc: &BlockChain, bytes: &[u8], receipts: Vec) -> ImportRoute { - let batch = db.transaction(); - let res = bc.insert_block(&batch, bytes, receipts); + let mut batch =db.transaction(); + let res = bc.insert_block(&mut batch, bytes, receipts); db.write(batch).unwrap(); bc.commit(); res @@ -1569,16 +1569,16 @@ mod tests { let bc = BlockChain::new(Config::default(), &genesis, db.clone()); let uncle = canon_chain.fork(1).generate(&mut finalizer.fork()).unwrap(); - let batch = db.transaction(); + let mut batch =db.transaction(); // create a longer fork for _ in 0..5 { let canon_block = canon_chain.generate(&mut finalizer).unwrap(); - bc.insert_block(&batch, &canon_block, vec![]); + bc.insert_block(&mut batch, &canon_block, vec![]); bc.commit(); } assert_eq!(bc.best_block_number(), 5); - bc.insert_block(&batch, &uncle, vec![]); + bc.insert_block(&mut batch, &uncle, vec![]); db.write(batch).unwrap(); bc.commit(); } @@ -1604,10 +1604,10 @@ mod tests { let db = new_db(temp.as_str()); let bc = BlockChain::new(Config::default(), &genesis, db.clone()); - let batch = db.transaction(); - bc.insert_block(&batch, &first, vec![]); + let mut batch =db.transaction(); + bc.insert_block(&mut batch, &first, vec![]); bc.commit(); - bc.insert_block(&batch, &second, vec![]); + bc.insert_block(&mut batch, &second, vec![]); bc.commit(); db.write(batch).unwrap(); diff --git a/ethcore/src/client/client.rs b/ethcore/src/client/client.rs index 5e0a4b9f8..78669912c 100644 --- a/ethcore/src/client/client.rs +++ b/ethcore/src/client/client.rs @@ -172,8 +172,8 @@ impl Client { let mut state_db = journaldb::new(db.clone(), config.pruning, ::db::COL_STATE); if state_db.is_empty() && try!(spec.ensure_db_good(state_db.as_hashdb_mut())) { - let batch = DBTransaction::new(&db); - try!(state_db.commit(&batch, 0, &spec.genesis_header().hash(), None)); + let mut batch = DBTransaction::new(&db); + try!(state_db.commit(&mut batch, 0, &spec.genesis_header().hash(), None)); try!(db.write(batch).map_err(ClientError::Database)); } @@ -431,14 +431,14 @@ impl Client { //let traces = From::from(block.traces().clone().unwrap_or_else(Vec::new)); - let batch = DBTransaction::new(&self.db); + let mut batch = DBTransaction::new(&self.db); // CHECK! I *think* this is fine, even if the state_root is equal to another // already-imported block of the same number. // TODO: Prove it with a test. - block.drain().commit(&batch, number, hash, ancient).expect("DB commit failed."); + block.drain().commit(&mut batch, number, hash, ancient).expect("DB commit failed."); - let route = self.chain.insert_block(&batch, block_data, receipts); - self.tracedb.import(&batch, TraceImportRequest { + let route = self.chain.insert_block(&mut batch, block_data, receipts); + self.tracedb.import(&mut batch, TraceImportRequest { traces: traces.into(), block_hash: hash.clone(), block_number: number, diff --git a/ethcore/src/db.rs b/ethcore/src/db.rs index e7a6425e3..7fcf30de3 100644 --- a/ethcore/src/db.rs +++ b/ethcore/src/db.rs @@ -83,10 +83,10 @@ pub trait Key { /// Should be used to write value into database. pub trait Writable { /// Writes the value into the database. - fn write(&self, col: Option, key: &Key, value: &T) where T: Encodable, R: Deref; + fn write(&mut self, col: Option, key: &Key, value: &T) where T: Encodable, R: Deref; /// Writes the value into the database and updates the cache. - fn write_with_cache(&self, col: Option, cache: &mut Cache, key: K, value: T, policy: CacheUpdatePolicy) where + fn write_with_cache(&mut self, col: Option, cache: &mut Cache, key: K, value: T, policy: CacheUpdatePolicy) where K: Key + Hash + Eq, T: Encodable, R: Deref { @@ -102,7 +102,7 @@ pub trait Writable { } /// Writes the values into the database and updates the cache. - fn extend_with_cache(&self, col: Option, cache: &mut Cache, values: HashMap, policy: CacheUpdatePolicy) where + fn extend_with_cache(&mut self, col: Option, cache: &mut Cache, values: HashMap, policy: CacheUpdatePolicy) where K: Key + Hash + Eq, T: Encodable, R: Deref { @@ -169,7 +169,7 @@ pub trait Readable { } impl Writable for DBTransaction { - fn write(&self, col: Option, key: &Key, value: &T) where T: Encodable, R: Deref { + fn write(&mut self, col: Option, key: &Key, value: &T) where T: Encodable, R: Deref { self.put(col, &key.key(), &encode(value)); } } diff --git a/ethcore/src/snapshot/mod.rs b/ethcore/src/snapshot/mod.rs index 84afb7cc1..a1f9812d5 100644 --- a/ethcore/src/snapshot/mod.rs +++ b/ethcore/src/snapshot/mod.rs @@ -492,8 +492,8 @@ impl StateRebuilder { } let backing = self.db.backing().clone(); - let batch = backing.transaction(); - try!(self.db.inject(&batch)); + let mut batch = backing.transaction(); + try!(self.db.inject(&mut batch)); try!(backing.write(batch).map_err(::util::UtilError::SimpleString)); trace!(target: "snapshot", "current state root: {:?}", self.state_root); Ok(()) diff --git a/ethcore/src/snapshot/tests/blocks.rs b/ethcore/src/snapshot/tests/blocks.rs index a7a6d5b7e..ac9880263 100644 --- a/ethcore/src/snapshot/tests/blocks.rs +++ b/ethcore/src/snapshot/tests/blocks.rs @@ -43,14 +43,16 @@ fn chunk_and_restore(amount: u64) { let bc = BlockChain::new(Default::default(), &genesis, old_db.clone()); // build the blockchain. + let mut batch = old_db.transaction(); for _ in 0..amount { let block = canon_chain.generate(&mut finalizer).unwrap(); - let batch = old_db.transaction(); - bc.insert_block(&batch, &block, vec![]); + bc.insert_block(&mut batch, &block, vec![]); bc.commit(); - old_db.write(batch).unwrap(); } + old_db.write(batch).unwrap(); + + let best_hash = bc.best_block_hash(); // snapshot it. diff --git a/ethcore/src/tests/helpers.rs b/ethcore/src/tests/helpers.rs index 03a1a2232..4942ace5a 100644 --- a/ethcore/src/tests/helpers.rs +++ b/ethcore/src/tests/helpers.rs @@ -259,9 +259,9 @@ pub fn generate_dummy_blockchain(block_number: u32) -> GuardedTempResult GuardedTempRes let bc = BlockChain::new(BlockChainConfig::default(), &create_unverifiable_block(0, H256::zero()), db.clone()); - let batch = db.transaction(); + let mut batch = db.transaction(); for block_order in 1..block_number { - bc.insert_block(&batch, &create_unverifiable_block_with_extra(block_order, bc.best_block_hash(), None), vec![]); + bc.insert_block(&mut batch, &create_unverifiable_block_with_extra(block_order, bc.best_block_hash(), None), vec![]); bc.commit(); } db.write(batch).unwrap(); diff --git a/ethcore/src/trace/db.rs b/ethcore/src/trace/db.rs index 684c12a70..d295e084c 100644 --- a/ethcore/src/trace/db.rs +++ b/ethcore/src/trace/db.rs @@ -142,7 +142,7 @@ impl TraceDB where T: DatabaseExtras { false => [0x0] }; - let batch = DBTransaction::new(&tracesdb); + let mut batch = DBTransaction::new(&tracesdb); batch.put(db::COL_TRACE, b"enabled", &encoded_tracing); batch.put(db::COL_TRACE, b"version", TRACE_DB_VER); tracesdb.write(batch).unwrap(); @@ -261,7 +261,7 @@ impl TraceDatabase for TraceDB where T: DatabaseExtras { /// Traces of import request's enacted blocks are expected to be already in database /// or to be the currently inserted trace. - fn import(&self, batch: &DBTransaction, request: ImportRequest) { + fn import(&self, batch: &mut DBTransaction, request: ImportRequest) { // valid (canon): retracted 0, enacted 1 => false, true, // valid (branch): retracted 0, enacted 0 => false, false, // valid (bbcc): retracted 1, enacted 1 => true, true, @@ -611,8 +611,8 @@ mod tests { // import block 0 let request = create_simple_import_request(0, block_0.clone()); - let batch = DBTransaction::new(&db); - tracedb.import(&batch, request); + let mut batch = DBTransaction::new(&db); + tracedb.import(&mut batch, request); db.write(batch).unwrap(); let filter = Filter { @@ -627,8 +627,8 @@ mod tests { // import block 1 let request = create_simple_import_request(1, block_1.clone()); - let batch = DBTransaction::new(&db); - tracedb.import(&batch, request); + let mut batch = DBTransaction::new(&db); + tracedb.import(&mut batch, request); db.write(batch).unwrap(); let filter = Filter { @@ -686,8 +686,8 @@ mod tests { // import block 0 let request = create_simple_import_request(0, block_0.clone()); - let batch = DBTransaction::new(&db); - tracedb.import(&batch, request); + let mut batch = DBTransaction::new(&db); + tracedb.import(&mut batch, request); db.write(batch).unwrap(); } diff --git a/ethcore/src/trace/mod.rs b/ethcore/src/trace/mod.rs index 277227729..4b6b4ad92 100644 --- a/ethcore/src/trace/mod.rs +++ b/ethcore/src/trace/mod.rs @@ -121,7 +121,7 @@ pub trait Database { fn tracing_enabled(&self) -> bool; /// Imports new block traces. - fn import(&self, batch: &DBTransaction, request: ImportRequest); + fn import(&self, batch: &mut DBTransaction, request: ImportRequest); /// Returns localized trace at given position. fn trace(&self, block_number: BlockNumber, tx_position: usize, trace_position: Vec) -> Option; diff --git a/util/src/journaldb/archivedb.rs b/util/src/journaldb/archivedb.rs index 417d5b865..863b490a6 100644 --- a/util/src/journaldb/archivedb.rs +++ b/util/src/journaldb/archivedb.rs @@ -156,7 +156,7 @@ impl JournalDB for ArchiveDB { self.latest_era.is_none() } - fn commit(&mut self, batch: &DBTransaction, now: u64, _id: &H256, _end: Option<(u64, H256)>) -> Result { + fn commit(&mut self, batch: &mut DBTransaction, now: u64, _id: &H256, _end: Option<(u64, H256)>) -> Result { let mut inserts = 0usize; let mut deletes = 0usize; @@ -185,7 +185,7 @@ impl JournalDB for ArchiveDB { Ok((inserts + deletes) as u32) } - fn inject(&mut self, batch: &DBTransaction) -> Result { + fn inject(&mut self, batch: &mut DBTransaction) -> Result { let mut inserts = 0usize; let mut deletes = 0usize; diff --git a/util/src/journaldb/earlymergedb.rs b/util/src/journaldb/earlymergedb.rs index e2543d11c..4e53202c1 100644 --- a/util/src/journaldb/earlymergedb.rs +++ b/util/src/journaldb/earlymergedb.rs @@ -101,13 +101,13 @@ impl EarlyMergeDB { } // The next three are valid only as long as there is an insert operation of `key` in the journal. - fn set_already_in(batch: &DBTransaction, col: Option, key: &H256) { batch.put(col, &Self::morph_key(key, 0), &[1u8]); } - fn reset_already_in(batch: &DBTransaction, col: Option, key: &H256) { batch.delete(col, &Self::morph_key(key, 0)); } + fn set_already_in(batch: &mut DBTransaction, col: Option, key: &H256) { batch.put(col, &Self::morph_key(key, 0), &[1u8]); } + fn reset_already_in(batch: &mut DBTransaction, col: Option, key: &H256) { batch.delete(col, &Self::morph_key(key, 0)); } fn is_already_in(backing: &Database, col: Option, key: &H256) -> bool { backing.get(col, &Self::morph_key(key, 0)).expect("Low-level database error. Some issue with your hard disk?").is_some() } - fn insert_keys(inserts: &[(H256, Bytes)], backing: &Database, col: Option, refs: &mut HashMap, batch: &DBTransaction, trace: bool) { + fn insert_keys(inserts: &[(H256, Bytes)], backing: &Database, col: Option, refs: &mut HashMap, batch: &mut DBTransaction, trace: bool) { for &(ref h, ref d) in inserts { if let Some(c) = refs.get_mut(h) { // already counting. increment. @@ -156,7 +156,7 @@ impl EarlyMergeDB { trace!(target: "jdb.fine", "replay_keys: (end) refs={:?}", refs); } - fn remove_keys(deletes: &[H256], refs: &mut HashMap, batch: &DBTransaction, col: Option, from: RemoveFrom, trace: bool) { + fn remove_keys(deletes: &[H256], refs: &mut HashMap, batch: &mut DBTransaction, col: Option, from: RemoveFrom, trace: bool) { // with a remove on {queue_refs: 1, in_archive: true}, we have two options: // - convert to {queue_refs: 1, in_archive: false} (i.e. remove it from the conceptual archive) // - convert to {queue_refs: 0, in_archive: true} (i.e. remove it from the conceptual queue) @@ -337,7 +337,7 @@ impl JournalDB for EarlyMergeDB { } #[cfg_attr(feature="dev", allow(cyclomatic_complexity))] - fn commit(&mut self, batch: &DBTransaction, now: u64, id: &H256, end: Option<(u64, H256)>) -> Result { + fn commit(&mut self, batch: &mut DBTransaction, now: u64, id: &H256, end: Option<(u64, H256)>) -> Result { // journal format: // [era, 0] => [ id, [insert_0, ...], [remove_0, ...] ] // [era, 1] => [ id, [insert_0, ...], [remove_0, ...] ] @@ -514,7 +514,7 @@ impl JournalDB for EarlyMergeDB { Ok(0) } - fn inject(&mut self, batch: &DBTransaction) -> Result { + fn inject(&mut self, batch: &mut DBTransaction) -> Result { let mut ops = 0; for (key, (value, rc)) in self.overlay.drain() { if rc != 0 { ops += 1 } diff --git a/util/src/journaldb/overlayrecentdb.rs b/util/src/journaldb/overlayrecentdb.rs index 3d1d7e143..bd14eb161 100644 --- a/util/src/journaldb/overlayrecentdb.rs +++ b/util/src/journaldb/overlayrecentdb.rs @@ -222,7 +222,7 @@ impl JournalDB for OverlayRecentDB { .or_else(|| self.backing.get_by_prefix(self.column, &key[0..DB_PREFIX_LEN]).map(|b| b.to_vec())) } - fn commit(&mut self, batch: &DBTransaction, now: u64, id: &H256, end: Option<(u64, H256)>) -> Result { + fn commit(&mut self, batch: &mut DBTransaction, now: u64, id: &H256, end: Option<(u64, H256)>) -> Result { // record new commit's details. trace!("commit: #{} ({}), end era: {:?}", now, id, end); let mut journal_overlay = self.journal_overlay.write(); @@ -314,7 +314,7 @@ impl JournalDB for OverlayRecentDB { self.journal_overlay.write().pending_overlay.clear(); } - fn inject(&mut self, batch: &DBTransaction) -> Result { + fn inject(&mut self, batch: &mut DBTransaction) -> Result { let mut ops = 0; for (key, (value, rc)) in self.transaction_overlay.drain() { if rc != 0 { ops += 1 } diff --git a/util/src/journaldb/refcounteddb.rs b/util/src/journaldb/refcounteddb.rs index 6b37e451f..5e3f09606 100644 --- a/util/src/journaldb/refcounteddb.rs +++ b/util/src/journaldb/refcounteddb.rs @@ -109,7 +109,7 @@ impl JournalDB for RefCountedDB { self.backing.get_by_prefix(self.column, &id[0..DB_PREFIX_LEN]).map(|b| b.to_vec()) } - fn commit(&mut self, batch: &DBTransaction, now: u64, id: &H256, end: Option<(u64, H256)>) -> Result { + fn commit(&mut self, batch: &mut DBTransaction, now: u64, id: &H256, end: Option<(u64, H256)>) -> Result { // journal format: // [era, 0] => [ id, [insert_0, ...], [remove_0, ...] ] // [era, 1] => [ id, [insert_0, ...], [remove_0, ...] ] @@ -182,11 +182,11 @@ impl JournalDB for RefCountedDB { } } - let r = try!(self.forward.commit_to_batch(&batch)); + let r = try!(self.forward.commit_to_batch(batch)); Ok(r) } - fn inject(&mut self, batch: &DBTransaction) -> Result { + fn inject(&mut self, batch: &mut DBTransaction) -> Result { self.inserts.clear(); for remove in self.removes.drain(..) { self.forward.remove(&remove); diff --git a/util/src/journaldb/traits.rs b/util/src/journaldb/traits.rs index 1a00da1e4..85cc7fe58 100644 --- a/util/src/journaldb/traits.rs +++ b/util/src/journaldb/traits.rs @@ -37,7 +37,7 @@ pub trait JournalDB: HashDB { /// Commit all recent insert operations and canonical historical commits' removals from the /// old era to the backing database, reverting any non-canonical historical commit's inserts. - fn commit(&mut self, batch: &DBTransaction, now: u64, id: &H256, end: Option<(u64, H256)>) -> Result; + fn commit(&mut self, batch: &mut DBTransaction, now: u64, id: &H256, end: Option<(u64, H256)>) -> Result; /// Commit all queued insert and delete operations without affecting any journalling -- this requires that all insertions /// and deletions are indeed canonical and will likely lead to an invalid database if that assumption is violated. @@ -46,7 +46,7 @@ pub trait JournalDB: HashDB { /// by any previous `commit` operations. Essentially, this means that `inject` can be used /// either to restore a state to a fresh database, or to insert data which may only be journalled /// from this point onwards. - fn inject(&mut self, batch: &DBTransaction) -> Result; + fn inject(&mut self, batch: &mut DBTransaction) -> Result; /// State data query fn state(&self, _id: &H256) -> Option; @@ -67,8 +67,8 @@ pub trait JournalDB: HashDB { /// Commit all changes in a single batch #[cfg(test)] fn commit_batch(&mut self, now: u64, id: &H256, end: Option<(u64, H256)>) -> Result { - let batch = self.backing().transaction(); - let res = try!(self.commit(&batch, now, id, end)); + let mut batch = self.backing().transaction(); + let res = try!(self.commit(&mut batch, now, id, end)); let result = self.backing().write(batch).map(|_| res).map_err(Into::into); self.flush(); result @@ -77,8 +77,8 @@ pub trait JournalDB: HashDB { /// Inject all changes in a single batch. #[cfg(test)] fn inject_batch(&mut self) -> Result { - let batch = self.backing().transaction(); - let res = try!(self.inject(&batch)); + let mut batch = self.backing().transaction(); + let res = try!(self.inject(&mut batch)); self.backing().write(batch).map(|_| res).map_err(Into::into) } } diff --git a/util/src/kvdb.rs b/util/src/kvdb.rs index 586e4b9a9..5db7801a1 100644 --- a/util/src/kvdb.rs +++ b/util/src/kvdb.rs @@ -28,7 +28,7 @@ const DB_BACKGROUND_COMPACTIONS: i32 = 2; /// Write transaction. Batches a sequence of put/delete operations for efficiency. pub struct DBTransaction { - ops: Mutex>, + ops: Vec, } enum DBOp { @@ -52,15 +52,15 @@ impl DBTransaction { /// Create new transaction. pub fn new(_db: &Database) -> DBTransaction { DBTransaction { - ops: Mutex::new(Vec::with_capacity(256)), + ops: Vec::with_capacity(256), } } /// Insert a key-value pair in the transaction. Any existing value value will be overwritten upon write. - pub fn put(&self, col: Option, key: &[u8], value: &[u8]) { + pub fn put(&mut self, col: Option, key: &[u8], value: &[u8]) { let mut ekey = ElasticArray32::new(); ekey.append_slice(key); - self.ops.lock().push(DBOp::Insert { + self.ops.push(DBOp::Insert { col: col, key: ekey, value: value.to_vec(), @@ -68,10 +68,10 @@ impl DBTransaction { } /// Insert a key-value pair in the transaction. Any existing value value will be overwritten upon write. - pub fn put_vec(&self, col: Option, key: &[u8], value: Bytes) { + pub fn put_vec(&mut self, col: Option, key: &[u8], value: Bytes) { let mut ekey = ElasticArray32::new(); ekey.append_slice(key); - self.ops.lock().push(DBOp::Insert { + self.ops.push(DBOp::Insert { col: col, key: ekey, value: value, @@ -79,11 +79,11 @@ impl DBTransaction { } /// Insert a key-value pair in the transaction. Any existing value value will be overwritten upon write. - /// Value will be RLP-compressed on flush - pub fn put_compressed(&self, col: Option, key: &[u8], value: Bytes) { + /// Value will be RLP-compressed on flush + pub fn put_compressed(&mut self, col: Option, key: &[u8], value: Bytes) { let mut ekey = ElasticArray32::new(); ekey.append_slice(key); - self.ops.lock().push(DBOp::InsertCompressed { + self.ops.push(DBOp::InsertCompressed { col: col, key: ekey, value: value, @@ -91,10 +91,10 @@ impl DBTransaction { } /// Delete value by key. - pub fn delete(&self, col: Option, key: &[u8]) { + pub fn delete(&mut self, col: Option, key: &[u8]) { let mut ekey = ElasticArray32::new(); ekey.append_slice(key); - self.ops.lock().push(DBOp::Delete { + self.ops.push(DBOp::Delete { col: col, key: ekey, }); @@ -299,7 +299,7 @@ impl Database { /// Commit transaction to database. pub fn write_buffered(&self, tr: DBTransaction) { let mut overlay = self.overlay.write(); - let ops = tr.ops.into_inner(); + let ops = tr.ops; for op in ops { match op { DBOp::Insert { col, key, value } => { @@ -359,7 +359,7 @@ impl Database { /// Commit transaction to database. pub fn write(&self, tr: DBTransaction) -> Result<(), String> { let batch = WriteBatch::new(); - let ops = tr.ops.into_inner(); + let ops = tr.ops; for op in ops { match op { DBOp::Insert { col, key, value } => { @@ -425,7 +425,7 @@ mod tests { let key2 = H256::from_str("03c69be41d0b7e40352fc85be1cd65eb03d40ef8427a0ca4596b1ead9a00e9fc").unwrap(); let key3 = H256::from_str("01c69be41d0b7e40352fc85be1cd65eb03d40ef8427a0ca4596b1ead9a00e9fc").unwrap(); - let batch = db.transaction(); + let mut batch = db.transaction(); batch.put(None, &key1, b"cat"); batch.put(None, &key2, b"dog"); db.write(batch).unwrap(); @@ -439,17 +439,17 @@ mod tests { assert_eq!(&*contents[1].0, &*key2); assert_eq!(&*contents[1].1, b"dog"); - let batch = db.transaction(); + let mut batch = db.transaction(); batch.delete(None, &key1); db.write(batch).unwrap(); assert!(db.get(None, &key1).unwrap().is_none()); - let batch = db.transaction(); + let mut batch = db.transaction(); batch.put(None, &key1, b"cat"); db.write(batch).unwrap(); - let transaction = db.transaction(); + let mut transaction = db.transaction(); transaction.put(None, &key3, b"elephant"); transaction.delete(None, &key1); db.write(transaction).unwrap(); @@ -459,7 +459,7 @@ mod tests { assert_eq!(&*db.get_by_prefix(None, &key3).unwrap(), b"elephant"); assert_eq!(&*db.get_by_prefix(None, &key2).unwrap(), b"dog"); - let transaction = db.transaction(); + let mut transaction = db.transaction(); transaction.put(None, &key1, b"horse"); transaction.delete(None, &key3); db.write_buffered(transaction); diff --git a/util/src/migration/mod.rs b/util/src/migration/mod.rs index 0cc5436a0..cfd828086 100644 --- a/util/src/migration/mod.rs +++ b/util/src/migration/mod.rs @@ -72,7 +72,7 @@ impl Batch { pub fn commit(&mut self, dest: &mut Database) -> Result<(), Error> { if self.inner.is_empty() { return Ok(()) } - let transaction = DBTransaction::new(dest); + let mut transaction = DBTransaction::new(dest); for keypair in &self.inner { transaction.put(self.column, &keypair.0, &keypair.1); diff --git a/util/src/migration/tests.rs b/util/src/migration/tests.rs index b21f3344f..ee5ff574e 100644 --- a/util/src/migration/tests.rs +++ b/util/src/migration/tests.rs @@ -35,7 +35,7 @@ fn db_path(path: &Path) -> PathBuf { fn make_db(path: &Path, pairs: BTreeMap, Vec>) { let db = Database::open_default(path.to_str().unwrap()).expect("failed to open temp database"); { - let transaction = db.transaction(); + let mut transaction = db.transaction(); for (k, v) in pairs { transaction.put(None, &k, &v); } diff --git a/util/src/overlaydb.rs b/util/src/overlaydb.rs index a68c9a5ed..4a11961b6 100644 --- a/util/src/overlaydb.rs +++ b/util/src/overlaydb.rs @@ -58,13 +58,13 @@ impl OverlayDB { /// Commit all operations in a single batch. #[cfg(test)] pub fn commit(&mut self) -> Result { - let batch = self.backing.transaction(); - let res = try!(self.commit_to_batch(&batch)); + let mut batch = self.backing.transaction(); + let res = try!(self.commit_to_batch(&mut batch)); self.backing.write(batch).map(|_| res).map_err(|e| e.into()) } /// Commit all operations to given batch. - pub fn commit_to_batch(&mut self, batch: &DBTransaction) -> Result { + pub fn commit_to_batch(&mut self, batch: &mut DBTransaction) -> Result { let mut ret = 0u32; let mut deletes = 0usize; for i in self.overlay.drain().into_iter() { @@ -111,7 +111,7 @@ impl OverlayDB { } /// Put the refs and value of the given key, possibly deleting it from the db. - fn put_payload_in_batch(&self, batch: &DBTransaction, key: &H256, payload: (Bytes, u32)) -> bool { + fn put_payload_in_batch(&self, batch: &mut DBTransaction, key: &H256, payload: (Bytes, u32)) -> bool { if payload.1 > 0 { let mut s = RlpStream::new_list(2); s.append(&payload.1); @@ -195,8 +195,8 @@ impl HashDB for OverlayDB { fn overlaydb_revert() { let mut m = OverlayDB::new_temp(); let foo = m.insert(b"foo"); // insert foo. - let batch = m.backing.transaction(); - m.commit_to_batch(&batch).unwrap(); // commit - new operations begin here... + let mut batch = m.backing.transaction(); + m.commit_to_batch(&mut batch).unwrap(); // commit - new operations begin here... m.backing.write(batch).unwrap(); let bar = m.insert(b"bar"); // insert bar. m.remove(&foo); // remove foo. @@ -300,7 +300,7 @@ fn playpen() { use std::fs; { let db = Database::open_default("/tmp/test").unwrap(); - let batch = db.transaction(); + let mut batch = db.transaction(); batch.put(None, b"test", b"test2"); db.write(batch).unwrap(); match db.get(None, b"test") { @@ -308,7 +308,7 @@ fn playpen() { Ok(None) => println!("No value for that key"), Err(..) => println!("Gah"), } - let batch = db.transaction(); + let mut batch = db.transaction(); batch.delete(None, b"test"); db.write(batch).unwrap(); }