From e09ac4209e68aa2210da3422492ed686e04754aa Mon Sep 17 00:00:00 2001 From: Snowmead Date: Fri, 22 Dec 2023 12:54:02 -0500 Subject: [PATCH 01/16] double ended iterator implementation (wip) --- trie-db/src/fatdb.rs | 31 +++++ trie-db/src/iterator.rs | 248 +++++++++++++++++++++++++++++++++++-- trie-db/src/lib.rs | 2 +- trie-db/src/node.rs | 2 +- trie-db/src/triedb.rs | 12 ++ trie-db/test/src/triedb.rs | 24 ++++ 6 files changed, 310 insertions(+), 9 deletions(-) diff --git a/trie-db/src/fatdb.rs b/trie-db/src/fatdb.rs index f3a3fc43..5132c4f0 100644 --- a/trie-db/src/fatdb.rs +++ b/trie-db/src/fatdb.rs @@ -148,6 +148,23 @@ where } } +impl<'db, 'cache, L> DoubleEndedIterator for FatDBIterator<'db, 'cache, L> +where + L: TrieLayout, +{ + fn next_back(&mut self) -> Option { + self.trie_iterator.next_back().map(|res| { + res.map(|(hash, value)| { + let aux_hash = L::Hash::hash(&hash); + ( + self.trie.db().get(&aux_hash, Default::default()).expect("Missing fatdb hash"), + value, + ) + }) + }) + } +} + /// Iterator over inserted keys. pub struct FatDBKeyIterator<'db, 'cache, L> where @@ -192,3 +209,17 @@ where }) } } + +impl<'db, 'cache, L> DoubleEndedIterator for FatDBKeyIterator<'db, 'cache, L> +where + L: TrieLayout, +{ + fn next_back(&mut self) -> Option { + self.trie_iterator.next_back().map(|res| { + res.map(|hash| { + let aux_hash = L::Hash::hash(&hash); + self.trie.db().get(&aux_hash, Default::default()).expect("Missing fatdb hash") + }) + }) + } +} diff --git a/trie-db/src/iterator.rs b/trie-db/src/iterator.rs index ca382b70..bf548c3c 100644 --- a/trie-db/src/iterator.rs +++ b/trie-db/src/iterator.rs @@ -41,7 +41,7 @@ struct Crumb { } impl Crumb { - /// Move on to next status in the node's sequence. + /// Move on to next status in the node's sequence in forward direction. fn increment(&mut self) { self.status = match (self.status, self.node.node_plan()) { (Status::Entering, NodePlan::Extension { .. }) => Status::At, @@ -56,31 +56,56 @@ impl Crumb { _ => Status::Exiting, } } + + /// Move on to next status in the node's sequence in backward direction. + fn decrement(&mut self) { + self.status = match (self.status, self.node.node_plan()) { + (Status::Entering, NodePlan::Extension { .. }) => Status::At, + (Status::Entering, NodePlan::Branch { .. }) | + (Status::Entering, NodePlan::NibbledBranch { .. }) => Status::At, + (Status::At, NodePlan::Branch { .. }) | + (Status::At, NodePlan::NibbledBranch { .. }) => Status::AtChild(15), + (Status::AtChild(x), NodePlan::Branch { .. }) | + (Status::AtChild(x), NodePlan::NibbledBranch { .. }) + if x <= (nibble_ops::NIBBLE_LENGTH - 1) => + Status::AtChild(x - 1), + _ => Status::Exiting, + } + } } /// Iterator for going through all nodes in the trie in pre-order traversal order. pub struct TrieDBRawIterator { + /// Forward trail of nodes to visit. trail: Vec>, + /// Backward trail of nodes to visit. + back_trail: Vec>, + /// The key nibbles of the current node. key_nibbles: NibbleVec, } impl TrieDBRawIterator { /// Create a new empty iterator. pub fn empty() -> Self { - Self { trail: Vec::new(), key_nibbles: NibbleVec::new() } + Self { trail: Vec::new(), back_trail: Vec::new(), key_nibbles: NibbleVec::new() } } /// Create a new iterator. pub fn new(db: &TrieDB) -> Result, CError> { - let mut r = - TrieDBRawIterator { trail: Vec::with_capacity(8), key_nibbles: NibbleVec::new() }; + let mut r = TrieDBRawIterator { + trail: Vec::with_capacity(8), + back_trail: Vec::with_capacity(8), + key_nibbles: NibbleVec::new(), + }; let (root_node, root_hash) = db.get_raw_or_lookup( *db.root(), NodeHandle::Hash(db.root().as_ref()), EMPTY_PREFIX, true, )?; - r.descend(root_node, root_hash); + + r.descend(root_node.clone(), root_hash); + r.descend_dec(root_node, root_hash); Ok(r) } @@ -105,12 +130,21 @@ impl TrieDBRawIterator { Ok(iter) } - /// Descend into a payload. + /// Descend forward into a node. fn descend(&mut self, node: OwnedNode, node_hash: Option>) { self.trail .push(Crumb { hash: node_hash, status: Status::Entering, node: Arc::new(node) }); } + /// Descend backward into a node. + fn descend_dec(&mut self, node: OwnedNode, node_hash: Option>) { + self.back_trail.push(Crumb { + hash: node_hash, + status: Status::Entering, + node: Arc::new(node), + }); + } + /// Fetch value by hash at a current node height pub(crate) fn fetch_value( db: &TrieDB, @@ -149,7 +183,7 @@ impl TrieDBRawIterator { let (next_node, next_node_hash) = { self.descend(node, node_hash); let crumb = self.trail.last_mut().expect( - "descend_into_node pushes a crumb onto the trial; \ + "descend pushes a crumb onto the trail; \ thus the trail is non-empty; qed", ); let node_data = crumb.node.data(); @@ -447,6 +481,107 @@ impl TrieDBRawIterator { } } + fn next_back_raw_item( + &mut self, + db: &TrieDB, + ) -> Option< + Result< + (&NibbleVec, Option<&TrieHash>, &Arc>), + TrieHash, + CError, + >, + > { + loop { + let crumb = self.back_trail.last_mut()?; + let node_data = crumb.node.data(); + + match (crumb.status, crumb.node.node_plan()) { + (Status::Entering, _) => { + // This is only necessary due to current borrow checker's limitation. + let crumb = self.back_trail.last_mut().expect("we've just fetched the last element using `last_mut` so this cannot fail; qed"); + crumb.decrement(); + return Some(Ok((&self.key_nibbles, crumb.hash.as_ref(), &crumb.node))) + }, + (Status::Exiting, node) => { + match node { + NodePlan::Empty | NodePlan::Leaf { .. } => {}, + NodePlan::Extension { partial, .. } => { + self.key_nibbles.drop_lasts(partial.len()); + }, + NodePlan::Branch { .. } => { + self.key_nibbles.pop(); + }, + NodePlan::NibbledBranch { partial, .. } => { + self.key_nibbles.drop_lasts(partial.len() + 1); + }, + } + self.back_trail.pop().expect("we've just fetched the last element using `last_mut` so this cannot fail; qed"); + self.back_trail.last_mut()?.decrement(); + }, + (Status::At, NodePlan::Extension { partial: partial_plan, child }) => { + let partial = partial_plan.build(node_data); + self.key_nibbles.append_partial(partial.right()); + + match db.get_raw_or_lookup( + crumb.hash.unwrap_or_default(), + child.build(node_data), + self.key_nibbles.as_prefix(), + true, + ) { + Ok((node, node_hash)) => { + self.descend_dec(node, node_hash); + }, + Err(err) => { + crumb.decrement(); + return Some(Err(err)) + }, + } + }, + (Status::At, NodePlan::Branch { .. }) => { + self.key_nibbles.push(15); + crumb.decrement(); + }, + (Status::At, NodePlan::NibbledBranch { partial: partial_plan, .. }) => { + let partial = partial_plan.build(node_data); + self.key_nibbles.append_partial(partial.right()); + self.key_nibbles.push(15); + crumb.decrement(); + }, + (Status::AtChild(i), NodePlan::Branch { children, .. }) | + (Status::AtChild(i), NodePlan::NibbledBranch { children, .. }) => { + if let Some(child) = &children[i] { + self.key_nibbles.pop(); + self.key_nibbles.push(i as u8); + + println!("prefix: {:?}", self.key_nibbles); + println!("child: {:?}", child); + + match db.get_raw_or_lookup( + crumb.hash.unwrap_or_default(), + child.build(node_data), + self.key_nibbles.as_prefix(), + true, + ) { + Ok((node, node_hash)) => { + self.descend_dec(node, node_hash); + }, + Err(err) => { + crumb.decrement(); + return Some(Err(err)) + }, + } + } else { + crumb.decrement(); + } + }, + _ => panic!( + "Crumb::increment and TrieDBNodeIterator are implemented so that \ + the above arms are the only possible states" + ), + } + } + } + /// Fetches the next trie item. /// /// Must be called with the same `db` as when the iterator was created. @@ -496,6 +631,52 @@ impl TrieDBRawIterator { None } + pub fn next_back_item(&mut self, db: &TrieDB) -> Option, CError>> { + while let Some(raw_item) = self.next_back_raw_item(db) { + let (prefix, _, node) = match raw_item { + Ok(raw_item) => raw_item, + Err(err) => return Some(Err(err)), + }; + + let mut prefix = prefix.clone(); + let value = match node.node() { + Node::Leaf(partial, value) => { + prefix.append_partial(partial.right()); + value + }, + Node::Branch(_, value) => match value { + Some(value) => value, + None => continue, + }, + Node::NibbledBranch(partial, _, value) => { + prefix.append_partial(partial.right()); + match value { + Some(value) => value, + None => continue, + } + }, + _ => continue, + }; + + let (key_slice, maybe_extra_nibble) = prefix.as_prefix(); + let key = key_slice.to_vec(); + if let Some(extra_nibble) = maybe_extra_nibble { + return Some(Err(Box::new(TrieError::ValueAtIncompleteKey(key, extra_nibble)))) + } + + let value = match value { + Value::Node(hash) => match Self::fetch_value(db, &hash, (key_slice, None)) { + Ok(value) => value, + Err(err) => return Some(Err(err)), + }, + Value::Inline(value) => value.to_vec(), + }; + + return Some(Ok((key, value))) + } + None + } + /// Fetches the next key. /// /// Must be called with the same `db` as when the iterator was created. @@ -534,6 +715,51 @@ impl TrieDBRawIterator { } None } + + pub fn next_back_key(&mut self, db: &TrieDB) -> Option, CError>> { + while let Some(raw_item) = self.next_back_raw_item(db) { + let (prefix, _, node) = match raw_item { + Ok(raw_item) => raw_item, + Err(err) => return Some(Err(err)), + }; + + println!("prefix received: {:?}", prefix); + println!("node received: {:?}", node); + + let mut prefix = prefix.clone(); + match node.node() { + Node::Leaf(partial, _) => { + prefix.append_partial(partial.right()); + + println!("prefix after append: {:?}", prefix); + }, + Node::Branch(_, value) => + if value.is_none() { + continue + }, + Node::NibbledBranch(partial, _, value) => { + prefix.append_partial(partial.right()); + if value.is_none() { + continue + } + }, + _ => continue, + }; + + let (key_slice, maybe_extra_nibble) = prefix.as_prefix(); + let key = key_slice.to_vec(); + + if let Some(extra_nibble) = maybe_extra_nibble { + println!("extra nibble: {:?}", extra_nibble); + return Some(Err(Box::new(TrieError::ValueAtIncompleteKey(key, extra_nibble)))) + } + + println!("key: {:?}", key); + + return Some(Ok(key)) + } + None + } } /// Iterator for going through all nodes in the trie in pre-order traversal order. @@ -605,3 +831,11 @@ impl<'a, 'cache, L: TrieLayout> Iterator for TrieDBNodeIterator<'a, 'cache, L> { }) } } + +impl<'a, 'cache, L: TrieLayout> DoubleEndedIterator for TrieDBNodeIterator<'a, 'cache, L> { + fn next_back(&mut self) -> Option { + self.raw_iter.next_back_raw_item(self.db).map(|result| { + result.map(|(nibble, hash, node)| (nibble.clone(), hash.cloned(), node.clone())) + }) + } +} diff --git a/trie-db/src/lib.rs b/trie-db/src/lib.rs index 5ddab42f..b9977fa2 100644 --- a/trie-db/src/lib.rs +++ b/trie-db/src/lib.rs @@ -353,7 +353,7 @@ pub trait TrieMut { } /// A trie iterator that also supports random access (`seek()`). -pub trait TrieIterator: Iterator { +pub trait TrieIterator: Iterator + DoubleEndedIterator { /// Position the iterator on the first element with key >= `key` fn seek(&mut self, key: &[u8]) -> Result<(), TrieHash, CError>; } diff --git a/trie-db/src/node.rs b/trie-db/src/node.rs index 19ed9162..457c9b33 100644 --- a/trie-db/src/node.rs +++ b/trie-db/src/node.rs @@ -582,7 +582,7 @@ impl NodePlan { /// An `OwnedNode` is an owned type from which a `Node` can be constructed which borrows data from /// the `OwnedNode`. This is useful for trie iterators. #[cfg_attr(feature = "std", derive(Debug))] -#[derive(PartialEq, Eq)] +#[derive(PartialEq, Eq, Clone)] pub struct OwnedNode> { data: D, plan: NodePlan, diff --git a/trie-db/src/triedb.rs b/trie-db/src/triedb.rs index 310deff3..9008b1ad 100644 --- a/trie-db/src/triedb.rs +++ b/trie-db/src/triedb.rs @@ -525,6 +525,12 @@ impl<'a, 'cache, L: TrieLayout> Iterator for TrieDBIterator<'a, 'cache, L> { } } +impl<'a, 'cache, L: TrieLayout> DoubleEndedIterator for TrieDBIterator<'a, 'cache, L> { + fn next_back(&mut self) -> Option { + self.raw_iter.next_back_item(self.db) + } +} + impl<'a, 'cache, L: TrieLayout> Iterator for TrieDBKeyIterator<'a, 'cache, L> { type Item = TrieKeyItem, CError>; @@ -532,3 +538,9 @@ impl<'a, 'cache, L: TrieLayout> Iterator for TrieDBKeyIterator<'a, 'cache, L> { self.raw_iter.next_key(self.db) } } + +impl<'a, 'cache, L: TrieLayout> DoubleEndedIterator for TrieDBKeyIterator<'a, 'cache, L> { + fn next_back(&mut self) -> Option { + self.raw_iter.next_back_key(self.db) + } +} diff --git a/trie-db/test/src/triedb.rs b/trie-db/test/src/triedb.rs index 5f2fa699..ec51ef27 100644 --- a/trie-db/test/src/triedb.rs +++ b/trie-db/test/src/triedb.rs @@ -94,6 +94,30 @@ fn iterator_seek_works_internal() { ); } +test_layouts!(double_ended_iterator, double_ended_iterator_internal); +fn double_ended_iterator_internal() { + let pairs = vec![ + (hex!("00").to_vec(), hex!("00").to_vec()), + (hex!("01").to_vec(), hex!("01").to_vec()), + ]; + + let mut memdb = MemoryDB::, DBValue>::default(); + let mut root = Default::default(); + { + let mut t = TrieDBMutBuilder::::new(&mut memdb, &mut root).build(); + for (x, y) in &pairs { + t.insert(x, y).unwrap(); + } + } + + let t = TrieDBBuilder::::new(&memdb, &root).build(); + + let mut iter = t.iter().unwrap(); + + assert_eq!(iter.next().unwrap().unwrap(), (hex!("00").to_vec(), hex!("00").to_vec(),)); + assert_eq!(iter.next_back().unwrap().unwrap(), (hex!("01").to_vec(), hex!("01").to_vec(),)); +} + test_layouts!(iterator, iterator_internal); fn iterator_internal() { let d = vec![b"A".to_vec(), b"AA".to_vec(), b"AB".to_vec(), b"B".to_vec()]; From 2ac96fe9967f6b490e62cd3afc76f9a8934e089c Mon Sep 17 00:00:00 2001 From: Snowmead Date: Wed, 27 Dec 2023 10:46:23 -0500 Subject: [PATCH 02/16] fix decrement child indexing conditional check, add working extension layout test --- trie-db/src/iterator.rs | 13 +--------- trie-db/test/src/triedb.rs | 49 ++++++++++++++++++++++++++++++++++---- 2 files changed, 45 insertions(+), 17 deletions(-) diff --git a/trie-db/src/iterator.rs b/trie-db/src/iterator.rs index bf548c3c..1155bb33 100644 --- a/trie-db/src/iterator.rs +++ b/trie-db/src/iterator.rs @@ -67,7 +67,7 @@ impl Crumb { (Status::At, NodePlan::NibbledBranch { .. }) => Status::AtChild(15), (Status::AtChild(x), NodePlan::Branch { .. }) | (Status::AtChild(x), NodePlan::NibbledBranch { .. }) - if x <= (nibble_ops::NIBBLE_LENGTH - 1) => + if x > 0 => Status::AtChild(x - 1), _ => Status::Exiting, } @@ -553,9 +553,6 @@ impl TrieDBRawIterator { self.key_nibbles.pop(); self.key_nibbles.push(i as u8); - println!("prefix: {:?}", self.key_nibbles); - println!("child: {:?}", child); - match db.get_raw_or_lookup( crumb.hash.unwrap_or_default(), child.build(node_data), @@ -723,15 +720,10 @@ impl TrieDBRawIterator { Err(err) => return Some(Err(err)), }; - println!("prefix received: {:?}", prefix); - println!("node received: {:?}", node); - let mut prefix = prefix.clone(); match node.node() { Node::Leaf(partial, _) => { prefix.append_partial(partial.right()); - - println!("prefix after append: {:?}", prefix); }, Node::Branch(_, value) => if value.is_none() { @@ -750,12 +742,9 @@ impl TrieDBRawIterator { let key = key_slice.to_vec(); if let Some(extra_nibble) = maybe_extra_nibble { - println!("extra nibble: {:?}", extra_nibble); return Some(Err(Box::new(TrieError::ValueAtIncompleteKey(key, extra_nibble)))) } - println!("key: {:?}", key); - return Some(Ok(key)) } None diff --git a/trie-db/test/src/triedb.rs b/trie-db/test/src/triedb.rs index ec51ef27..2e9e0bd3 100644 --- a/trie-db/test/src/triedb.rs +++ b/trie-db/test/src/triedb.rs @@ -18,7 +18,7 @@ use hash_db::{HashDB, Hasher, EMPTY_PREFIX}; use hex_literal::hex; use memory_db::{HashKey, MemoryDB, PrefixedKey}; use reference_trie::{ - test_layouts, test_layouts_substrate, HashedValueNoExtThreshold, TestTrieCache, + test_layouts, test_layouts_substrate, ExtensionLayout, HashedValueNoExtThreshold, TestTrieCache, }; use trie_db::{ encode_compact, CachedValue, DBValue, Lookup, NibbleSlice, RecordedForKey, Recorder, Trie, @@ -94,14 +94,49 @@ fn iterator_seek_works_internal() { ); } +#[test] +fn double_ended_iterator_simple_extension_layout() { + let pairs = vec![ + (hex!("01").to_vec(), hex!("01").to_vec()), + (hex!("02").to_vec(), hex!("02").to_vec()), + (hex!("03").to_vec(), hex!("03").to_vec()), + (hex!("10").to_vec(), hex!("10").to_vec()), + (hex!("11").to_vec(), hex!("11").to_vec()), + ]; + + let mut memdb = + MemoryDB::<::Hash, PrefixedKey<_>, DBValue>::default(); + let mut root = Default::default(); + { + let mut t = TrieDBMutBuilder::::new(&mut memdb, &mut root).build(); + for (x, y) in &pairs { + t.insert(x, y).unwrap(); + } + } + + let t = TrieDBBuilder::::new(&memdb, &root).build(); + assert_eq!(pairs, t.iter().unwrap().map(|x| x.unwrap()).collect::>()); + + let t = TrieDBBuilder::::new(&memdb, &root).build(); + + let mut iter = t.iter().unwrap(); + + assert_eq!(iter.next().unwrap().unwrap(), (vec![1], hex!("01").to_vec(),)); + assert_eq!(iter.next_back().unwrap().unwrap(), (vec![1, 17], hex!("11").to_vec(),)); + assert_eq!(iter.next_back().unwrap().unwrap(), (vec![1, 16], hex!("10").to_vec(),)); +} + test_layouts!(double_ended_iterator, double_ended_iterator_internal); fn double_ended_iterator_internal() { let pairs = vec![ - (hex!("00").to_vec(), hex!("00").to_vec()), (hex!("01").to_vec(), hex!("01").to_vec()), + (hex!("02").to_vec(), hex!("02").to_vec()), + (hex!("03").to_vec(), hex!("03").to_vec()), + (hex!("10").to_vec(), hex!("10").to_vec()), + (hex!("11").to_vec(), hex!("11").to_vec()), ]; - let mut memdb = MemoryDB::, DBValue>::default(); + let mut memdb = MemoryDB::<::Hash, PrefixedKey<_>, DBValue>::default(); let mut root = Default::default(); { let mut t = TrieDBMutBuilder::::new(&mut memdb, &mut root).build(); @@ -110,12 +145,16 @@ fn double_ended_iterator_internal() { } } + let t = TrieDBBuilder::::new(&memdb, &root).build(); + assert_eq!(pairs, t.iter().unwrap().map(|x| x.unwrap()).collect::>()); + let t = TrieDBBuilder::::new(&memdb, &root).build(); let mut iter = t.iter().unwrap(); - assert_eq!(iter.next().unwrap().unwrap(), (hex!("00").to_vec(), hex!("00").to_vec(),)); - assert_eq!(iter.next_back().unwrap().unwrap(), (hex!("01").to_vec(), hex!("01").to_vec(),)); + assert_eq!(iter.next().unwrap().unwrap(), (vec![1], hex!("01").to_vec(),)); + assert_eq!(iter.next_back().unwrap().unwrap(), (vec![1, 17], hex!("11").to_vec(),)); + assert_eq!(iter.next_back().unwrap().unwrap(), (vec![1, 16], hex!("10").to_vec(),)); } test_layouts!(iterator, iterator_internal); From c311283f76cca2037636f95b7a2fc27c7ba8f533 Mon Sep 17 00:00:00 2001 From: Snowmead Date: Wed, 27 Dec 2023 13:36:55 -0500 Subject: [PATCH 03/16] fix: add `back_key_nibbles` to `TrieDBRawIterator` --- trie-db/src/iterator.rs | 40 +++++++++++++++++++++++--------------- trie-db/test/src/triedb.rs | 38 ++++-------------------------------- 2 files changed, 28 insertions(+), 50 deletions(-) diff --git a/trie-db/src/iterator.rs b/trie-db/src/iterator.rs index 1155bb33..acef6e92 100644 --- a/trie-db/src/iterator.rs +++ b/trie-db/src/iterator.rs @@ -78,24 +78,32 @@ impl Crumb { pub struct TrieDBRawIterator { /// Forward trail of nodes to visit. trail: Vec>, + /// Forward iteration key nibbles of the current node. + key_nibbles: NibbleVec, /// Backward trail of nodes to visit. back_trail: Vec>, - /// The key nibbles of the current node. - key_nibbles: NibbleVec, + /// Backward iteration key nibbles of the current node. + back_key_nibbles: NibbleVec, } impl TrieDBRawIterator { /// Create a new empty iterator. pub fn empty() -> Self { - Self { trail: Vec::new(), back_trail: Vec::new(), key_nibbles: NibbleVec::new() } + Self { + trail: Vec::new(), + key_nibbles: NibbleVec::new(), + back_trail: Vec::new(), + back_key_nibbles: NibbleVec::new(), + } } /// Create a new iterator. pub fn new(db: &TrieDB) -> Result, CError> { let mut r = TrieDBRawIterator { trail: Vec::with_capacity(8), - back_trail: Vec::with_capacity(8), key_nibbles: NibbleVec::new(), + back_trail: Vec::with_capacity(8), + back_key_nibbles: NibbleVec::new(), }; let (root_node, root_hash) = db.get_raw_or_lookup( *db.root(), @@ -500,19 +508,19 @@ impl TrieDBRawIterator { // This is only necessary due to current borrow checker's limitation. let crumb = self.back_trail.last_mut().expect("we've just fetched the last element using `last_mut` so this cannot fail; qed"); crumb.decrement(); - return Some(Ok((&self.key_nibbles, crumb.hash.as_ref(), &crumb.node))) + return Some(Ok((&self.back_key_nibbles, crumb.hash.as_ref(), &crumb.node))) }, (Status::Exiting, node) => { match node { NodePlan::Empty | NodePlan::Leaf { .. } => {}, NodePlan::Extension { partial, .. } => { - self.key_nibbles.drop_lasts(partial.len()); + self.back_key_nibbles.drop_lasts(partial.len()); }, NodePlan::Branch { .. } => { - self.key_nibbles.pop(); + self.back_key_nibbles.pop(); }, NodePlan::NibbledBranch { partial, .. } => { - self.key_nibbles.drop_lasts(partial.len() + 1); + self.back_key_nibbles.drop_lasts(partial.len() + 1); }, } self.back_trail.pop().expect("we've just fetched the last element using `last_mut` so this cannot fail; qed"); @@ -520,12 +528,12 @@ impl TrieDBRawIterator { }, (Status::At, NodePlan::Extension { partial: partial_plan, child }) => { let partial = partial_plan.build(node_data); - self.key_nibbles.append_partial(partial.right()); + self.back_key_nibbles.append_partial(partial.right()); match db.get_raw_or_lookup( crumb.hash.unwrap_or_default(), child.build(node_data), - self.key_nibbles.as_prefix(), + self.back_key_nibbles.as_prefix(), true, ) { Ok((node, node_hash)) => { @@ -538,25 +546,25 @@ impl TrieDBRawIterator { } }, (Status::At, NodePlan::Branch { .. }) => { - self.key_nibbles.push(15); + self.back_key_nibbles.push(15); crumb.decrement(); }, (Status::At, NodePlan::NibbledBranch { partial: partial_plan, .. }) => { let partial = partial_plan.build(node_data); - self.key_nibbles.append_partial(partial.right()); - self.key_nibbles.push(15); + self.back_key_nibbles.append_partial(partial.right()); + self.back_key_nibbles.push(15); crumb.decrement(); }, (Status::AtChild(i), NodePlan::Branch { children, .. }) | (Status::AtChild(i), NodePlan::NibbledBranch { children, .. }) => { if let Some(child) = &children[i] { - self.key_nibbles.pop(); - self.key_nibbles.push(i as u8); + self.back_key_nibbles.pop(); + self.back_key_nibbles.push(i as u8); match db.get_raw_or_lookup( crumb.hash.unwrap_or_default(), child.build(node_data), - self.key_nibbles.as_prefix(), + self.back_key_nibbles.as_prefix(), true, ) { Ok((node, node_hash)) => { diff --git a/trie-db/test/src/triedb.rs b/trie-db/test/src/triedb.rs index 2e9e0bd3..9f27faa3 100644 --- a/trie-db/test/src/triedb.rs +++ b/trie-db/test/src/triedb.rs @@ -94,38 +94,6 @@ fn iterator_seek_works_internal() { ); } -#[test] -fn double_ended_iterator_simple_extension_layout() { - let pairs = vec![ - (hex!("01").to_vec(), hex!("01").to_vec()), - (hex!("02").to_vec(), hex!("02").to_vec()), - (hex!("03").to_vec(), hex!("03").to_vec()), - (hex!("10").to_vec(), hex!("10").to_vec()), - (hex!("11").to_vec(), hex!("11").to_vec()), - ]; - - let mut memdb = - MemoryDB::<::Hash, PrefixedKey<_>, DBValue>::default(); - let mut root = Default::default(); - { - let mut t = TrieDBMutBuilder::::new(&mut memdb, &mut root).build(); - for (x, y) in &pairs { - t.insert(x, y).unwrap(); - } - } - - let t = TrieDBBuilder::::new(&memdb, &root).build(); - assert_eq!(pairs, t.iter().unwrap().map(|x| x.unwrap()).collect::>()); - - let t = TrieDBBuilder::::new(&memdb, &root).build(); - - let mut iter = t.iter().unwrap(); - - assert_eq!(iter.next().unwrap().unwrap(), (vec![1], hex!("01").to_vec(),)); - assert_eq!(iter.next_back().unwrap().unwrap(), (vec![1, 17], hex!("11").to_vec(),)); - assert_eq!(iter.next_back().unwrap().unwrap(), (vec![1, 16], hex!("10").to_vec(),)); -} - test_layouts!(double_ended_iterator, double_ended_iterator_internal); fn double_ended_iterator_internal() { let pairs = vec![ @@ -152,9 +120,11 @@ fn double_ended_iterator_internal() { let mut iter = t.iter().unwrap(); + assert_eq!(iter.next_back().unwrap().unwrap(), (vec![17], hex!("11").to_vec(),)); + assert_eq!(iter.next_back().unwrap().unwrap(), (vec![16], hex!("10").to_vec(),)); assert_eq!(iter.next().unwrap().unwrap(), (vec![1], hex!("01").to_vec(),)); - assert_eq!(iter.next_back().unwrap().unwrap(), (vec![1, 17], hex!("11").to_vec(),)); - assert_eq!(iter.next_back().unwrap().unwrap(), (vec![1, 16], hex!("10").to_vec(),)); + assert_eq!(iter.next().unwrap().unwrap(), (vec![2], hex!("02").to_vec(),)); + assert_eq!(iter.next_back().unwrap().unwrap(), (vec![3], hex!("03").to_vec(),)); } test_layouts!(iterator, iterator_internal); From 466867ba2abb4d8b15c13bb19e4c2bf4a66ea251 Mon Sep 17 00:00:00 2001 From: Snowmead Date: Wed, 27 Dec 2023 14:02:47 -0500 Subject: [PATCH 04/16] refactor test --- trie-db/src/lib.rs | 2 +- trie-db/test/src/triedb.rs | 12 +++++++----- 2 files changed, 8 insertions(+), 6 deletions(-) diff --git a/trie-db/src/lib.rs b/trie-db/src/lib.rs index b9977fa2..1f3bf282 100644 --- a/trie-db/src/lib.rs +++ b/trie-db/src/lib.rs @@ -352,7 +352,7 @@ pub trait TrieMut { fn remove(&mut self, key: &[u8]) -> Result>, TrieHash, CError>; } -/// A trie iterator that also supports random access (`seek()`). +/// A double ended trie iterator that also supports random access (`seek()`). pub trait TrieIterator: Iterator + DoubleEndedIterator { /// Position the iterator on the first element with key >= `key` fn seek(&mut self, key: &[u8]) -> Result<(), TrieHash, CError>; diff --git a/trie-db/test/src/triedb.rs b/trie-db/test/src/triedb.rs index 9f27faa3..5f60f57a 100644 --- a/trie-db/test/src/triedb.rs +++ b/trie-db/test/src/triedb.rs @@ -120,11 +120,13 @@ fn double_ended_iterator_internal() { let mut iter = t.iter().unwrap(); - assert_eq!(iter.next_back().unwrap().unwrap(), (vec![17], hex!("11").to_vec(),)); - assert_eq!(iter.next_back().unwrap().unwrap(), (vec![16], hex!("10").to_vec(),)); - assert_eq!(iter.next().unwrap().unwrap(), (vec![1], hex!("01").to_vec(),)); - assert_eq!(iter.next().unwrap().unwrap(), (vec![2], hex!("02").to_vec(),)); - assert_eq!(iter.next_back().unwrap().unwrap(), (vec![3], hex!("03").to_vec(),)); + assert_eq!(iter.next().unwrap().unwrap(), pairs.first().unwrap().clone()); + assert_eq!(iter.next_back().unwrap().unwrap(), pairs.last().unwrap().clone()); + assert_eq!(iter.next_back().unwrap().unwrap(), pairs[pairs.len() - 2].clone()); + assert_eq!(iter.next_back().unwrap().unwrap(), pairs[2].clone()); + assert_eq!(iter.next().unwrap().unwrap(), pairs[1].clone()); + assert!(iter.next().is_none()); + assert!(iter.next_back().is_none()); } test_layouts!(iterator, iterator_internal); From fe3ad110c4d5fa73247e143749df7184b2770f96 Mon Sep 17 00:00:00 2001 From: Snowmead Date: Wed, 27 Dec 2023 14:29:37 -0500 Subject: [PATCH 05/16] remove is_none asserts for double ended iterator --- trie-db/test/src/triedb.rs | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/trie-db/test/src/triedb.rs b/trie-db/test/src/triedb.rs index 5f60f57a..43d8b0a4 100644 --- a/trie-db/test/src/triedb.rs +++ b/trie-db/test/src/triedb.rs @@ -18,7 +18,7 @@ use hash_db::{HashDB, Hasher, EMPTY_PREFIX}; use hex_literal::hex; use memory_db::{HashKey, MemoryDB, PrefixedKey}; use reference_trie::{ - test_layouts, test_layouts_substrate, ExtensionLayout, HashedValueNoExtThreshold, TestTrieCache, + test_layouts, test_layouts_substrate, HashedValueNoExtThreshold, TestTrieCache, }; use trie_db::{ encode_compact, CachedValue, DBValue, Lookup, NibbleSlice, RecordedForKey, Recorder, Trie, @@ -125,8 +125,6 @@ fn double_ended_iterator_internal() { assert_eq!(iter.next_back().unwrap().unwrap(), pairs[pairs.len() - 2].clone()); assert_eq!(iter.next_back().unwrap().unwrap(), pairs[2].clone()); assert_eq!(iter.next().unwrap().unwrap(), pairs[1].clone()); - assert!(iter.next().is_none()); - assert!(iter.next_back().is_none()); } test_layouts!(iterator, iterator_internal); From 3bda42e1048cc9e77222f50da0f5a641e1fa7baf Mon Sep 17 00:00:00 2001 From: Michael Assaf <94772640+snowmead@users.noreply.github.com> Date: Thu, 28 Dec 2023 08:33:02 -0500 Subject: [PATCH 06/16] use nibble length instead of static 15 Co-authored-by: cheme --- trie-db/src/iterator.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/trie-db/src/iterator.rs b/trie-db/src/iterator.rs index acef6e92..40ffd33b 100644 --- a/trie-db/src/iterator.rs +++ b/trie-db/src/iterator.rs @@ -64,7 +64,7 @@ impl Crumb { (Status::Entering, NodePlan::Branch { .. }) | (Status::Entering, NodePlan::NibbledBranch { .. }) => Status::At, (Status::At, NodePlan::Branch { .. }) | - (Status::At, NodePlan::NibbledBranch { .. }) => Status::AtChild(15), + (Status::At, NodePlan::NibbledBranch { .. }) => Status::AtChild(nibble_ops::NIBBLE_LENGTH - 1), (Status::AtChild(x), NodePlan::Branch { .. }) | (Status::AtChild(x), NodePlan::NibbledBranch { .. }) if x > 0 => From 8e1d3383d5290d9e582dfc3f16d69c0be7c60375 Mon Sep 17 00:00:00 2001 From: Snowmead Date: Thu, 28 Dec 2023 14:12:05 -0500 Subject: [PATCH 07/16] TrieDoubleEndedIterator trait + struct impls, debup internal iteration methods, remove back_trail & back_key_nibbles, remove clone from OwnedNode --- trie-db/src/fatdb.rs | 49 ++++- trie-db/src/iterator.rs | 354 ++++++++++++------------------------- trie-db/src/lib.rs | 10 +- trie-db/src/node.rs | 2 +- trie-db/src/trie_codec.rs | 2 +- trie-db/src/triedb.rs | 130 ++++++++++++-- trie-db/test/src/triedb.rs | 14 +- trie-root/src/lib.rs | 6 +- 8 files changed, 292 insertions(+), 275 deletions(-) diff --git a/trie-db/src/fatdb.rs b/trie-db/src/fatdb.rs index 5132c4f0..f435f980 100644 --- a/trie-db/src/fatdb.rs +++ b/trie-db/src/fatdb.rs @@ -18,7 +18,7 @@ use super::{ }; use hash_db::{HashDBRef, Hasher}; -use crate::{rstd::boxed::Box, MerkleValue, TrieDBBuilder}; +use crate::{rstd::boxed::Box, triedb::TrieDBDoubleEndedIterator, MerkleValue, TrieDBBuilder}; /// A `Trie` implementation which hashes keys and uses a generic `HashDB` backing database. /// Additionaly it stores inserted hash-key mappings for later retrieval. @@ -109,6 +109,22 @@ where trie: &'db TrieDB<'db, 'cache, L>, } +/// Double ended iterator over inserted pairs of key values. +pub struct FatDBDoubleEndedIterator<'db, 'cache, L> +where + L: TrieLayout, +{ + trie_iterator: TrieDBDoubleEndedIterator<'db, 'cache, L>, + trie: &'db TrieDB<'db, 'cache, L>, +} + +impl<'a, 'cache, L: TrieLayout> FatDBDoubleEndedIterator<'a, 'cache, L> { + /// Create a new double ended iterator. + pub fn new(db: &'a TrieDB<'a, 'cache, L>) -> Result, CError> { + Ok(Self { trie_iterator: TrieDBDoubleEndedIterator::new(db)?, trie: db }) + } +} + impl<'db, 'cache, L> FatDBIterator<'db, 'cache, L> where L: TrieLayout, @@ -148,7 +164,36 @@ where } } -impl<'db, 'cache, L> DoubleEndedIterator for FatDBIterator<'db, 'cache, L> +impl<'db, 'cache, L> TrieIterator for FatDBDoubleEndedIterator<'db, 'cache, L> +where + L: TrieLayout, +{ + fn seek(&mut self, key: &[u8]) -> Result<(), TrieHash, CError> { + let hashed_key = L::Hash::hash(key); + self.trie_iterator.seek(hashed_key.as_ref()) + } +} + +impl<'db, 'cache, L> Iterator for FatDBDoubleEndedIterator<'db, 'cache, L> +where + L: TrieLayout, +{ + type Item = TrieItem, CError>; + + fn next(&mut self) -> Option { + self.trie_iterator.next().map(|res| { + res.map(|(hash, value)| { + let aux_hash = L::Hash::hash(&hash); + ( + self.trie.db().get(&aux_hash, Default::default()).expect("Missing fatdb hash"), + value, + ) + }) + }) + } +} + +impl<'db, 'cache, L> DoubleEndedIterator for FatDBDoubleEndedIterator<'db, 'cache, L> where L: TrieLayout, { diff --git a/trie-db/src/iterator.rs b/trie-db/src/iterator.rs index 40ffd33b..63a42999 100644 --- a/trie-db/src/iterator.rs +++ b/trie-db/src/iterator.rs @@ -17,7 +17,7 @@ use crate::{ nibble::{nibble_ops, NibbleSlice, NibbleVec}, node::{Node, NodeHandle, NodePlan, OwnedNode, Value}, triedb::TrieDB, - TrieError, TrieItem, TrieKeyItem, + TrieDoubleEndedIterator, TrieError, TrieItem, TrieKeyItem, }; use hash_db::{Hasher, Prefix, EMPTY_PREFIX}; @@ -41,33 +41,26 @@ struct Crumb { } impl Crumb { - /// Move on to next status in the node's sequence in forward direction. - fn increment(&mut self) { + /// Move on to the next status in the node's sequence in a direction. + fn step(&mut self, fwd: bool) { self.status = match (self.status, self.node.node_plan()) { (Status::Entering, NodePlan::Extension { .. }) => Status::At, (Status::Entering, NodePlan::Branch { .. }) | (Status::Entering, NodePlan::NibbledBranch { .. }) => Status::At, (Status::At, NodePlan::Branch { .. }) | - (Status::At, NodePlan::NibbledBranch { .. }) => Status::AtChild(0), + (Status::At, NodePlan::NibbledBranch { .. }) => + if fwd { + Status::AtChild(0) + } else { + Status::AtChild(nibble_ops::NIBBLE_LENGTH - 1) + }, (Status::AtChild(x), NodePlan::Branch { .. }) | (Status::AtChild(x), NodePlan::NibbledBranch { .. }) - if x < (nibble_ops::NIBBLE_LENGTH - 1) => + if fwd && x < (nibble_ops::NIBBLE_LENGTH - 1) => Status::AtChild(x + 1), - _ => Status::Exiting, - } - } - - /// Move on to next status in the node's sequence in backward direction. - fn decrement(&mut self) { - self.status = match (self.status, self.node.node_plan()) { - (Status::Entering, NodePlan::Extension { .. }) => Status::At, - (Status::Entering, NodePlan::Branch { .. }) | - (Status::Entering, NodePlan::NibbledBranch { .. }) => Status::At, - (Status::At, NodePlan::Branch { .. }) | - (Status::At, NodePlan::NibbledBranch { .. }) => Status::AtChild(nibble_ops::NIBBLE_LENGTH - 1), (Status::AtChild(x), NodePlan::Branch { .. }) | (Status::AtChild(x), NodePlan::NibbledBranch { .. }) - if x > 0 => + if !fwd && x > 0 => Status::AtChild(x - 1), _ => Status::Exiting, } @@ -80,31 +73,18 @@ pub struct TrieDBRawIterator { trail: Vec>, /// Forward iteration key nibbles of the current node. key_nibbles: NibbleVec, - /// Backward trail of nodes to visit. - back_trail: Vec>, - /// Backward iteration key nibbles of the current node. - back_key_nibbles: NibbleVec, } impl TrieDBRawIterator { /// Create a new empty iterator. pub fn empty() -> Self { - Self { - trail: Vec::new(), - key_nibbles: NibbleVec::new(), - back_trail: Vec::new(), - back_key_nibbles: NibbleVec::new(), - } + Self { trail: Vec::new(), key_nibbles: NibbleVec::new() } } /// Create a new iterator. pub fn new(db: &TrieDB) -> Result, CError> { - let mut r = TrieDBRawIterator { - trail: Vec::with_capacity(8), - key_nibbles: NibbleVec::new(), - back_trail: Vec::with_capacity(8), - back_key_nibbles: NibbleVec::new(), - }; + let mut r = + TrieDBRawIterator { trail: Vec::with_capacity(8), key_nibbles: NibbleVec::new() }; let (root_node, root_hash) = db.get_raw_or_lookup( *db.root(), NodeHandle::Hash(db.root().as_ref()), @@ -112,8 +92,7 @@ impl TrieDBRawIterator { true, )?; - r.descend(root_node.clone(), root_hash); - r.descend_dec(root_node, root_hash); + r.descend(root_node, root_hash); Ok(r) } @@ -138,21 +117,12 @@ impl TrieDBRawIterator { Ok(iter) } - /// Descend forward into a node. + /// Descend into a node. fn descend(&mut self, node: OwnedNode, node_hash: Option>) { self.trail .push(Crumb { hash: node_hash, status: Status::Entering, node: Arc::new(node) }); } - /// Descend backward into a node. - fn descend_dec(&mut self, node: OwnedNode, node_hash: Option>) { - self.back_trail.push(Crumb { - hash: node_hash, - status: Status::Entering, - node: Arc::new(node), - }); - } - /// Fetch value by hash at a current node height pub(crate) fn fetch_value( db: &TrieDB, @@ -391,9 +361,12 @@ impl TrieDBRawIterator { /// Fetches the next raw item. // /// Must be called with the same `db` as when the iterator was created. + /// + /// Specify `fwd` to indicate the direction of the iteration (`true` for forward). pub(crate) fn next_raw_item( &mut self, db: &TrieDB, + fwd: bool, ) -> Option< Result< (&NibbleVec, Option<&TrieHash>, &Arc>), @@ -409,7 +382,7 @@ impl TrieDBRawIterator { (Status::Entering, _) => { // This is only necessary due to current borrow checker's limitation. let crumb = self.trail.last_mut().expect("we've just fetched the last element using `last_mut` so this cannot fail; qed"); - crumb.increment(); + crumb.step(fwd); return Some(Ok((&self.key_nibbles, crumb.hash.as_ref(), &crumb.node))) }, (Status::Exiting, node) => { @@ -426,7 +399,7 @@ impl TrieDBRawIterator { }, } self.trail.pop().expect("we've just fetched the last element using `last_mut` so this cannot fail; qed"); - self.trail.last_mut()?.increment(); + self.trail.last_mut()?.step(fwd); }, (Status::At, NodePlan::Extension { partial: partial_plan, child }) => { let partial = partial_plan.build(node_data); @@ -442,20 +415,28 @@ impl TrieDBRawIterator { self.descend(node, node_hash); }, Err(err) => { - crumb.increment(); + crumb.step(fwd); return Some(Err(err)) }, } }, (Status::At, NodePlan::Branch { .. }) => { - self.key_nibbles.push(0); - crumb.increment(); + self.key_nibbles.push(if fwd { + 0 + } else { + (nibble_ops::NIBBLE_LENGTH - 1) as u8 + }); + crumb.step(fwd); }, (Status::At, NodePlan::NibbledBranch { partial: partial_plan, .. }) => { let partial = partial_plan.build(node_data); self.key_nibbles.append_partial(partial.right()); - self.key_nibbles.push(0); - crumb.increment(); + self.key_nibbles.push(if fwd { + 0 + } else { + (nibble_ops::NIBBLE_LENGTH - 1) as u8 + }); + crumb.step(fwd); }, (Status::AtChild(i), NodePlan::Branch { children, .. }) | (Status::AtChild(i), NodePlan::NibbledBranch { children, .. }) => { @@ -473,114 +454,16 @@ impl TrieDBRawIterator { self.descend(node, node_hash); }, Err(err) => { - crumb.increment(); - return Some(Err(err)) - }, - } - } else { - crumb.increment(); - } - }, - _ => panic!( - "Crumb::increment and TrieDBNodeIterator are implemented so that \ - the above arms are the only possible states" - ), - } - } - } - - fn next_back_raw_item( - &mut self, - db: &TrieDB, - ) -> Option< - Result< - (&NibbleVec, Option<&TrieHash>, &Arc>), - TrieHash, - CError, - >, - > { - loop { - let crumb = self.back_trail.last_mut()?; - let node_data = crumb.node.data(); - - match (crumb.status, crumb.node.node_plan()) { - (Status::Entering, _) => { - // This is only necessary due to current borrow checker's limitation. - let crumb = self.back_trail.last_mut().expect("we've just fetched the last element using `last_mut` so this cannot fail; qed"); - crumb.decrement(); - return Some(Ok((&self.back_key_nibbles, crumb.hash.as_ref(), &crumb.node))) - }, - (Status::Exiting, node) => { - match node { - NodePlan::Empty | NodePlan::Leaf { .. } => {}, - NodePlan::Extension { partial, .. } => { - self.back_key_nibbles.drop_lasts(partial.len()); - }, - NodePlan::Branch { .. } => { - self.back_key_nibbles.pop(); - }, - NodePlan::NibbledBranch { partial, .. } => { - self.back_key_nibbles.drop_lasts(partial.len() + 1); - }, - } - self.back_trail.pop().expect("we've just fetched the last element using `last_mut` so this cannot fail; qed"); - self.back_trail.last_mut()?.decrement(); - }, - (Status::At, NodePlan::Extension { partial: partial_plan, child }) => { - let partial = partial_plan.build(node_data); - self.back_key_nibbles.append_partial(partial.right()); - - match db.get_raw_or_lookup( - crumb.hash.unwrap_or_default(), - child.build(node_data), - self.back_key_nibbles.as_prefix(), - true, - ) { - Ok((node, node_hash)) => { - self.descend_dec(node, node_hash); - }, - Err(err) => { - crumb.decrement(); - return Some(Err(err)) - }, - } - }, - (Status::At, NodePlan::Branch { .. }) => { - self.back_key_nibbles.push(15); - crumb.decrement(); - }, - (Status::At, NodePlan::NibbledBranch { partial: partial_plan, .. }) => { - let partial = partial_plan.build(node_data); - self.back_key_nibbles.append_partial(partial.right()); - self.back_key_nibbles.push(15); - crumb.decrement(); - }, - (Status::AtChild(i), NodePlan::Branch { children, .. }) | - (Status::AtChild(i), NodePlan::NibbledBranch { children, .. }) => { - if let Some(child) = &children[i] { - self.back_key_nibbles.pop(); - self.back_key_nibbles.push(i as u8); - - match db.get_raw_or_lookup( - crumb.hash.unwrap_or_default(), - child.build(node_data), - self.back_key_nibbles.as_prefix(), - true, - ) { - Ok((node, node_hash)) => { - self.descend_dec(node, node_hash); - }, - Err(err) => { - crumb.decrement(); + crumb.step(fwd); return Some(Err(err)) }, } } else { - crumb.decrement(); + crumb.step(fwd); } }, _ => panic!( - "Crumb::increment and TrieDBNodeIterator are implemented so that \ + "Crumb::step and TrieDBNodeIterator are implemented so that \ the above arms are the only possible states" ), } @@ -590,54 +473,15 @@ impl TrieDBRawIterator { /// Fetches the next trie item. /// /// Must be called with the same `db` as when the iterator was created. - pub fn next_item(&mut self, db: &TrieDB) -> Option, CError>> { - while let Some(raw_item) = self.next_raw_item(db) { - let (prefix, _, node) = match raw_item { - Ok(raw_item) => raw_item, - Err(err) => return Some(Err(err)), - }; - - let mut prefix = prefix.clone(); - let value = match node.node() { - Node::Leaf(partial, value) => { - prefix.append_partial(partial.right()); - value - }, - Node::Branch(_, value) => match value { - Some(value) => value, - None => continue, - }, - Node::NibbledBranch(partial, _, value) => { - prefix.append_partial(partial.right()); - match value { - Some(value) => value, - None => continue, - } - }, - _ => continue, - }; - - let (key_slice, maybe_extra_nibble) = prefix.as_prefix(); - let key = key_slice.to_vec(); - if let Some(extra_nibble) = maybe_extra_nibble { - return Some(Err(Box::new(TrieError::ValueAtIncompleteKey(key, extra_nibble)))) - } - - let value = match value { - Value::Node(hash) => match Self::fetch_value(db, &hash, (key_slice, None)) { - Ok(value) => value, - Err(err) => return Some(Err(err)), - }, - Value::Inline(value) => value.to_vec(), - }; - - return Some(Ok((key, value))) - } - None - } - - pub fn next_back_item(&mut self, db: &TrieDB) -> Option, CError>> { - while let Some(raw_item) = self.next_back_raw_item(db) { + /// + /// Specify `fwd` to indicate the direction of the iteration (`true` for forward, `false` for + /// backward). + pub fn next_item( + &mut self, + db: &TrieDB, + fwd: bool, + ) -> Option, CError>> { + while let Some(raw_item) = self.next_raw_item(db, fwd) { let (prefix, _, node) = match raw_item { Ok(raw_item) => raw_item, Err(err) => return Some(Err(err)), @@ -682,47 +526,17 @@ impl TrieDBRawIterator { None } - /// Fetches the next key. + /// Fetches the next key in /// /// Must be called with the same `db` as when the iterator was created. - pub fn next_key(&mut self, db: &TrieDB) -> Option, CError>> { - while let Some(raw_item) = self.next_raw_item(db) { - let (prefix, _, node) = match raw_item { - Ok(raw_item) => raw_item, - Err(err) => return Some(Err(err)), - }; - - let mut prefix = prefix.clone(); - match node.node() { - Node::Leaf(partial, _) => { - prefix.append_partial(partial.right()); - }, - Node::Branch(_, value) => - if value.is_none() { - continue - }, - Node::NibbledBranch(partial, _, value) => { - prefix.append_partial(partial.right()); - if value.is_none() { - continue - } - }, - _ => continue, - }; - - let (key_slice, maybe_extra_nibble) = prefix.as_prefix(); - let key = key_slice.to_vec(); - if let Some(extra_nibble) = maybe_extra_nibble { - return Some(Err(Box::new(TrieError::ValueAtIncompleteKey(key, extra_nibble)))) - } - - return Some(Ok(key)) - } - None - } - - pub fn next_back_key(&mut self, db: &TrieDB) -> Option, CError>> { - while let Some(raw_item) = self.next_back_raw_item(db) { + /// + /// Specify `fwd` to indicate the direction of the iteration (`true` for forward, `false` for + pub fn next_key( + &mut self, + db: &TrieDB, + fwd: bool, + ) -> Option, CError>> { + while let Some(raw_item) = self.next_raw_item(db, fwd) { let (prefix, _, node) = match raw_item { Ok(raw_item) => raw_item, Err(err) => return Some(Err(err)), @@ -760,6 +574,10 @@ impl TrieDBRawIterator { } /// Iterator for going through all nodes in the trie in pre-order traversal order. +/// +/// You can reduce the number of iterations and simultaneously iterate in both directions with two +/// cursors by using `TrieDBNodeDoubleEndedIterator`. You can convert this iterator into a double +/// ended iterator with `into_double_ended_iter`. pub struct TrieDBNodeIterator<'a, 'cache, L: TrieLayout> { db: &'a TrieDB<'a, 'cache, L>, raw_iter: TrieDBRawIterator, @@ -781,6 +599,15 @@ impl<'a, 'cache, L: TrieLayout> TrieDBNodeIterator<'a, 'cache, L> { self.raw_iter } + /// Convert the iterator to a double ended iterator. + pub fn into_double_ended_iter(self) -> TrieDBNodeDoubleEndedIterator<'a, 'cache, L> { + TrieDBNodeDoubleEndedIterator { + db: self.db, + raw_iter: self.raw_iter, + back_raw_iter: TrieDBRawIterator::new(self.db).unwrap(), + } + } + /// Fetch value by hash at a current node height pub fn fetch_value( &self, @@ -823,15 +650,54 @@ impl<'a, 'cache, L: TrieLayout> Iterator for TrieDBNodeIterator<'a, 'cache, L> { Result<(NibbleVec, Option>, Arc>), TrieHash, CError>; fn next(&mut self) -> Option { - self.raw_iter.next_raw_item(self.db).map(|result| { + self.raw_iter.next_raw_item(self.db, true).map(|result| { + result.map(|(nibble, hash, node)| (nibble.clone(), hash.cloned(), node.clone())) + }) + } +} + +/// Double ended iterator for going through all nodes in the trie in pre-order traversal order. +pub struct TrieDBNodeDoubleEndedIterator<'a, 'cache, L: TrieLayout> { + db: &'a TrieDB<'a, 'cache, L>, + raw_iter: TrieDBRawIterator, + back_raw_iter: TrieDBRawIterator, +} + +impl<'a, 'cache, L: TrieLayout> TrieDBNodeDoubleEndedIterator<'a, 'cache, L> { + /// Create a new double ended iterator. + pub fn new(db: &'a TrieDB<'a, 'cache, L>) -> Result, CError> { + Ok(Self { + db, + raw_iter: TrieDBRawIterator::new(db)?, + back_raw_iter: TrieDBRawIterator::new(db)?, + }) + } +} + +impl TrieDoubleEndedIterator for TrieDBNodeDoubleEndedIterator<'_, '_, L> {} + +impl<'a, 'cache, L: TrieLayout> TrieIterator for TrieDBNodeDoubleEndedIterator<'a, 'cache, L> { + fn seek(&mut self, key: &[u8]) -> Result<(), TrieHash, CError> { + self.raw_iter.seek(self.db, key).map(|_| ()) + } +} + +impl<'a, 'cache, L: TrieLayout> Iterator for TrieDBNodeDoubleEndedIterator<'a, 'cache, L> { + type Item = + Result<(NibbleVec, Option>, Arc>), TrieHash, CError>; + + fn next(&mut self) -> Option { + self.raw_iter.next_raw_item(self.db, true).map(|result| { result.map(|(nibble, hash, node)| (nibble.clone(), hash.cloned(), node.clone())) }) } } -impl<'a, 'cache, L: TrieLayout> DoubleEndedIterator for TrieDBNodeIterator<'a, 'cache, L> { +impl<'a, 'cache, L: TrieLayout> DoubleEndedIterator + for TrieDBNodeDoubleEndedIterator<'a, 'cache, L> +{ fn next_back(&mut self) -> Option { - self.raw_iter.next_back_raw_item(self.db).map(|result| { + self.back_raw_iter.next_raw_item(self.db, false).map(|result| { result.map(|(nibble, hash, node)| (nibble.clone(), hash.cloned(), node.clone())) }) } diff --git a/trie-db/src/lib.rs b/trie-db/src/lib.rs index 1f3bf282..2c091eaa 100644 --- a/trie-db/src/lib.rs +++ b/trie-db/src/lib.rs @@ -25,7 +25,7 @@ mod rstd { collections::{BTreeMap, VecDeque}, convert, error::Error, - fmt, hash, iter, marker, mem, ops, rc, result, sync, vec, + fmt, hash, iter, marker, mem, ops, result, sync, vec, }; } @@ -46,6 +46,7 @@ use self::rstd::{fmt, Error}; use self::rstd::{boxed::Box, vec::Vec}; use hash_db::MaybeDebug; +pub use iterator::TrieDBNodeDoubleEndedIterator; use node::NodeOwned; pub mod node; @@ -352,12 +353,15 @@ pub trait TrieMut { fn remove(&mut self, key: &[u8]) -> Result>, TrieHash, CError>; } -/// A double ended trie iterator that also supports random access (`seek()`). -pub trait TrieIterator: Iterator + DoubleEndedIterator { +/// A trie iterator that also supports random access (`seek()`). +pub trait TrieIterator: Iterator { /// Position the iterator on the first element with key >= `key` fn seek(&mut self, key: &[u8]) -> Result<(), TrieHash, CError>; } +/// Extending the `TrieIterator` trait with `DoubleEndedIterator` trait. +pub trait TrieDoubleEndedIterator: TrieIterator + DoubleEndedIterator {} + /// Trie types #[derive(PartialEq, Clone)] #[cfg_attr(feature = "std", derive(Debug))] diff --git a/trie-db/src/node.rs b/trie-db/src/node.rs index 457c9b33..19ed9162 100644 --- a/trie-db/src/node.rs +++ b/trie-db/src/node.rs @@ -582,7 +582,7 @@ impl NodePlan { /// An `OwnedNode` is an owned type from which a `Node` can be constructed which borrows data from /// the `OwnedNode`. This is useful for trie iterators. #[cfg_attr(feature = "std", derive(Debug))] -#[derive(PartialEq, Eq, Clone)] +#[derive(PartialEq, Eq)] pub struct OwnedNode> { data: D, plan: NodePlan, diff --git a/trie-db/src/trie_codec.rs b/trie-db/src/trie_codec.rs index 9a1f51b3..22faf448 100644 --- a/trie-db/src/trie_codec.rs +++ b/trie-db/src/trie_codec.rs @@ -236,7 +236,7 @@ where // iteration of the loop below, the stack always has at least one entry and the bottom (front) // of the stack is the root node, which is not inline. Furthermore, the iterator is not empty, // so at least one iteration always occurs. - while let Some(item) = iter.next_raw_item(db) { + while let Some(item) = iter.next_raw_item(db, true) { match item { Ok((prefix, node_hash, node)) => { // Skip inline nodes, as they cannot contain hash references to other nodes by diff --git a/trie-db/src/triedb.rs b/trie-db/src/triedb.rs index 9008b1ad..61277a51 100644 --- a/trie-db/src/triedb.rs +++ b/trie-db/src/triedb.rs @@ -13,13 +13,15 @@ // limitations under the License. use crate::{ - iterator::TrieDBRawIterator, + fatdb::FatDBDoubleEndedIterator, + iterator::{TrieDBNodeDoubleEndedIterator, TrieDBRawIterator}, lookup::Lookup, nibble::NibbleSlice, node::{decode_hash, NodeHandle, OwnedNode}, rstd::boxed::Box, - CError, DBValue, MerkleValue, Query, Result, Trie, TrieAccess, TrieCache, TrieError, TrieHash, - TrieItem, TrieIterator, TrieKeyItem, TrieLayout, TrieRecorder, + CError, DBValue, MerkleValue, Query, Result, Trie, TrieAccess, TrieCache, + TrieDoubleEndedIterator, TrieError, TrieHash, TrieItem, TrieIterator, TrieKeyItem, TrieLayout, + TrieRecorder, }; #[cfg(feature = "std")] use crate::{ @@ -136,6 +138,34 @@ where self.db } + /// Create `TrieDBDoubleEndedIterator` from `TrieDB`. + pub fn into_double_ended_iter( + &'db self, + ) -> Result, TrieHash, CError> { + TrieDBDoubleEndedIterator::new(&self) + } + + /// Create `TrieDBNodeDoubleEndedIterator` from `TrieDB`. + pub fn into_node_double_ended_iter( + &'db self, + ) -> Result, TrieHash, CError> { + TrieDBNodeDoubleEndedIterator::new(&self) + } + + /// create `TrieDBKeyDoubleEndedIterator` from `TrieDB`. + pub fn into_key_double_ended_iter( + &'db self, + ) -> Result, TrieHash, CError> { + TrieDBKeyDoubleEndedIterator::new(&self) + } + + /// create `FatDBDoubleEndedIterator` from `TrieDB`. + pub fn into_fat_double_ended_iter( + &'db self, + ) -> Result, TrieHash, CError> { + FatDBDoubleEndedIterator::new(&self) + } + /// Given some node-describing data `node`, and node key return the actual node RLP. /// This could be a simple identity operation in the case that the node is sufficiently small, /// but may require a database lookup. @@ -431,6 +461,45 @@ pub struct TrieDBKeyIterator<'a, 'cache, L: TrieLayout> { raw_iter: TrieDBRawIterator, } +/// Double ended iterator for going through all of key with values in the trie in pre-order +/// traversal order. +pub struct TrieDBKeyDoubleEndedIterator<'a, 'cache, L: TrieLayout> { + db: &'a TrieDB<'a, 'cache, L>, + raw_iter: TrieDBRawIterator, + back_raw_iter: TrieDBRawIterator, +} + +impl<'a, 'cache, L: TrieLayout> TrieDBKeyDoubleEndedIterator<'a, 'cache, L> { + /// Create a new double ended iterator. + pub fn new(db: &'a TrieDB<'a, 'cache, L>) -> Result, CError> { + Ok(Self { + db, + raw_iter: TrieDBRawIterator::new(db)?, + back_raw_iter: TrieDBRawIterator::new(db)?, + }) + } +} + +/// Double ended iterator for going through all values in the trie in pre-order traversal order. +pub struct TrieDBDoubleEndedIterator<'a, 'cache, L: TrieLayout> { + db: &'a TrieDB<'a, 'cache, L>, + raw_iter: TrieDBRawIterator, + back_raw_iter: TrieDBRawIterator, +} + +impl<'a, 'cache, L: TrieLayout> TrieDBDoubleEndedIterator<'a, 'cache, L> { + /// Create a new double ended iterator. + pub fn new(db: &'a TrieDB<'a, 'cache, L>) -> Result, CError> { + Ok(Self { + db, + raw_iter: TrieDBRawIterator::new(db)?, + back_raw_iter: TrieDBRawIterator::new(db)?, + }) + } +} + +impl TrieDoubleEndedIterator for TrieDBDoubleEndedIterator<'_, '_, L> {} + impl<'a, 'cache, L: TrieLayout> TrieDBIterator<'a, 'cache, L> { /// Create a new iterator. pub fn new(db: &'a TrieDB<'a, 'cache, L>) -> Result, CError> { @@ -474,6 +543,34 @@ impl<'a, 'cache, L: TrieLayout> TrieIterator for TrieDBIterator<'a, 'cache, L } } +impl<'a, 'cache, L: TrieLayout> Iterator for TrieDBIterator<'a, 'cache, L> { + type Item = TrieItem, CError>; + + fn next(&mut self) -> Option { + self.raw_iter.next_item(self.db, true) + } +} + +impl<'a, 'cache, L: TrieLayout> TrieIterator for TrieDBDoubleEndedIterator<'a, 'cache, L> { + fn seek(&mut self, key: &[u8]) -> Result<(), TrieHash, CError> { + self.raw_iter.seek(self.db, key).map(|_| ()) + } +} + +impl<'a, 'cache, L: TrieLayout> Iterator for TrieDBDoubleEndedIterator<'a, 'cache, L> { + type Item = TrieItem, CError>; + + fn next(&mut self) -> Option { + self.raw_iter.next_item(self.db, true) + } +} + +impl<'a, 'cache, L: TrieLayout> DoubleEndedIterator for TrieDBDoubleEndedIterator<'a, 'cache, L> { + fn next_back(&mut self) -> Option { + self.back_raw_iter.next_item(self.db, false) + } +} + impl<'a, 'cache, L: TrieLayout> TrieDBKeyIterator<'a, 'cache, L> { /// Create a new iterator. pub fn new(db: &'a TrieDB<'a, 'cache, L>) -> Result, CError> { @@ -517,30 +614,39 @@ impl<'a, 'cache, L: TrieLayout> TrieIterator for TrieDBKeyIterator<'a, 'cache } } -impl<'a, 'cache, L: TrieLayout> Iterator for TrieDBIterator<'a, 'cache, L> { - type Item = TrieItem, CError>; +impl<'a, 'cache, L: TrieLayout> Iterator for TrieDBKeyIterator<'a, 'cache, L> { + type Item = TrieKeyItem, CError>; fn next(&mut self) -> Option { - self.raw_iter.next_item(self.db) + self.raw_iter.next_key(self.db, true) } } -impl<'a, 'cache, L: TrieLayout> DoubleEndedIterator for TrieDBIterator<'a, 'cache, L> { +impl<'a, 'cache, L: TrieLayout> DoubleEndedIterator for TrieDBKeyIterator<'a, 'cache, L> { fn next_back(&mut self) -> Option { - self.raw_iter.next_back_item(self.db) + self.raw_iter.next_key(self.db, false) } } -impl<'a, 'cache, L: TrieLayout> Iterator for TrieDBKeyIterator<'a, 'cache, L> { +impl<'a, 'cache, L: TrieLayout> TrieIterator for TrieDBKeyDoubleEndedIterator<'a, 'cache, L> { + /// Position the iterator on the first element with key >= `key` + fn seek(&mut self, key: &[u8]) -> Result<(), TrieHash, CError> { + self.raw_iter.seek(self.db, key).map(|_| ()) + } +} + +impl<'a, 'cache, L: TrieLayout> Iterator for TrieDBKeyDoubleEndedIterator<'a, 'cache, L> { type Item = TrieKeyItem, CError>; fn next(&mut self) -> Option { - self.raw_iter.next_key(self.db) + self.raw_iter.next_key(self.db, true) } } -impl<'a, 'cache, L: TrieLayout> DoubleEndedIterator for TrieDBKeyIterator<'a, 'cache, L> { +impl<'a, 'cache, L: TrieLayout> DoubleEndedIterator + for TrieDBKeyDoubleEndedIterator<'a, 'cache, L> +{ fn next_back(&mut self) -> Option { - self.raw_iter.next_back_key(self.db) + self.back_raw_iter.next_key(self.db, false) } } diff --git a/trie-db/test/src/triedb.rs b/trie-db/test/src/triedb.rs index 43d8b0a4..0eda38e2 100644 --- a/trie-db/test/src/triedb.rs +++ b/trie-db/test/src/triedb.rs @@ -116,15 +116,15 @@ fn double_ended_iterator_internal() { let t = TrieDBBuilder::::new(&memdb, &root).build(); assert_eq!(pairs, t.iter().unwrap().map(|x| x.unwrap()).collect::>()); - let t = TrieDBBuilder::::new(&memdb, &root).build(); + let mut iter = t.into_double_ended_iter().unwrap(); - let mut iter = t.iter().unwrap(); + for i in 0..pairs.len() { + assert_eq!(iter.next().unwrap().unwrap(), pairs[i].clone()); + assert_eq!(iter.next_back().unwrap().unwrap(), pairs[pairs.len() - i - 1].clone()); + } - assert_eq!(iter.next().unwrap().unwrap(), pairs.first().unwrap().clone()); - assert_eq!(iter.next_back().unwrap().unwrap(), pairs.last().unwrap().clone()); - assert_eq!(iter.next_back().unwrap().unwrap(), pairs[pairs.len() - 2].clone()); - assert_eq!(iter.next_back().unwrap().unwrap(), pairs[2].clone()); - assert_eq!(iter.next().unwrap().unwrap(), pairs[1].clone()); + assert!(iter.next().is_none()); + assert!(iter.next_back().is_none()); } test_layouts!(iterator, iterator_internal); diff --git a/trie-root/src/lib.rs b/trie-root/src/lib.rs index e184cfbb..b827abb6 100644 --- a/trie-root/src/lib.rs +++ b/trie-root/src/lib.rs @@ -23,11 +23,7 @@ extern crate alloc; #[cfg(feature = "std")] mod rstd { - pub use std::{ - cmp, - collections::{BTreeMap, VecDeque}, - vec::Vec, - }; + pub use std::{cmp, collections::BTreeMap, vec::Vec}; } #[cfg(not(feature = "std"))] From 416008283ce4815fb0fbe6e120d601a529414ccf Mon Sep 17 00:00:00 2001 From: Snowmead Date: Thu, 28 Dec 2023 14:18:09 -0500 Subject: [PATCH 08/16] remove unused fn --- trie-db/src/iterator.rs | 9 --------- 1 file changed, 9 deletions(-) diff --git a/trie-db/src/iterator.rs b/trie-db/src/iterator.rs index 63a42999..d9db37c3 100644 --- a/trie-db/src/iterator.rs +++ b/trie-db/src/iterator.rs @@ -599,15 +599,6 @@ impl<'a, 'cache, L: TrieLayout> TrieDBNodeIterator<'a, 'cache, L> { self.raw_iter } - /// Convert the iterator to a double ended iterator. - pub fn into_double_ended_iter(self) -> TrieDBNodeDoubleEndedIterator<'a, 'cache, L> { - TrieDBNodeDoubleEndedIterator { - db: self.db, - raw_iter: self.raw_iter, - back_raw_iter: TrieDBRawIterator::new(self.db).unwrap(), - } - } - /// Fetch value by hash at a current node height pub fn fetch_value( &self, From 59ebe3195dfb50f8b31f9975713f4a1175ca7d4a Mon Sep 17 00:00:00 2001 From: Snowmead Date: Thu, 28 Dec 2023 23:46:32 -0500 Subject: [PATCH 09/16] remove double ended iterator for FatDBKeyIterator, --- trie-db/src/fatdb.rs | 14 -------------- 1 file changed, 14 deletions(-) diff --git a/trie-db/src/fatdb.rs b/trie-db/src/fatdb.rs index f435f980..ceb6cfaf 100644 --- a/trie-db/src/fatdb.rs +++ b/trie-db/src/fatdb.rs @@ -254,17 +254,3 @@ where }) } } - -impl<'db, 'cache, L> DoubleEndedIterator for FatDBKeyIterator<'db, 'cache, L> -where - L: TrieLayout, -{ - fn next_back(&mut self) -> Option { - self.trie_iterator.next_back().map(|res| { - res.map(|hash| { - let aux_hash = L::Hash::hash(&hash); - self.trie.db().get(&aux_hash, Default::default()).expect("Missing fatdb hash") - }) - }) - } -} From e705afa78a26c5b13d72917682de2c4c4a8362fb Mon Sep 17 00:00:00 2001 From: Snowmead Date: Fri, 29 Dec 2023 12:52:17 -0500 Subject: [PATCH 10/16] prev_item & prev_key functions, remove fwd from next_item & next_key, add double ended iterator test mod --- trie-db/src/iterator.rs | 161 +++++++++++++--------- trie-db/src/triedb.rs | 18 +-- trie-db/test/src/double_ended_iterator.rs | 152 ++++++++++++++++++++ trie-db/test/src/iterator.rs | 4 +- trie-db/test/src/lib.rs | 2 + trie-db/test/src/triedb.rs | 6 +- 6 files changed, 264 insertions(+), 79 deletions(-) create mode 100644 trie-db/test/src/double_ended_iterator.rs diff --git a/trie-db/src/iterator.rs b/trie-db/src/iterator.rs index d9db37c3..8a3f80f7 100644 --- a/trie-db/src/iterator.rs +++ b/trie-db/src/iterator.rs @@ -473,48 +473,48 @@ impl TrieDBRawIterator { /// Fetches the next trie item. /// /// Must be called with the same `db` as when the iterator was created. - /// - /// Specify `fwd` to indicate the direction of the iteration (`true` for forward, `false` for - /// backward). - pub fn next_item( - &mut self, - db: &TrieDB, - fwd: bool, - ) -> Option, CError>> { - while let Some(raw_item) = self.next_raw_item(db, fwd) { - let (prefix, _, node) = match raw_item { - Ok(raw_item) => raw_item, - Err(err) => return Some(Err(err)), + pub fn next_item(&mut self, db: &TrieDB) -> Option, CError>> { + while let Some(raw_item) = self.next_raw_item(db, true) { + let (key, maybe_extra_nibble, value) = match Self::extract_key_from_raw_item(raw_item) { + Some(Ok(k)) => k, + Some(Err(err)) => return Some(Err(err)), + None => continue, }; - let mut prefix = prefix.clone(); - let value = match node.node() { - Node::Leaf(partial, value) => { - prefix.append_partial(partial.right()); - value - }, - Node::Branch(_, value) => match value { - Some(value) => value, - None => continue, - }, - Node::NibbledBranch(partial, _, value) => { - prefix.append_partial(partial.right()); - match value { - Some(value) => value, - None => continue, - } + if let Some(extra_nibble) = maybe_extra_nibble { + return Some(Err(Box::new(TrieError::ValueAtIncompleteKey(key, extra_nibble)))) + } + + let value = match value { + Value::Node(hash) => match Self::fetch_value(db, &hash, (key.as_slice(), None)) { + Ok(value) => value, + Err(err) => return Some(Err(err)), }, - _ => continue, + Value::Inline(value) => value.to_vec(), + }; + + return Some(Ok((key, value))) + } + None + } + + /// Fetches the previous trie item. + /// + /// Must be called with the same `db` as when the iterator was created. + pub fn prev_item(&mut self, db: &TrieDB) -> Option, CError>> { + while let Some(raw_item) = self.next_raw_item(db, false) { + let (key, maybe_extra_nibble, value) = match Self::extract_key_from_raw_item(raw_item) { + Some(Ok(k)) => k, + Some(Err(err)) => return Some(Err(err)), + None => continue, }; - let (key_slice, maybe_extra_nibble) = prefix.as_prefix(); - let key = key_slice.to_vec(); if let Some(extra_nibble) = maybe_extra_nibble { return Some(Err(Box::new(TrieError::ValueAtIncompleteKey(key, extra_nibble)))) } let value = match value { - Value::Node(hash) => match Self::fetch_value(db, &hash, (key_slice, None)) { + Value::Node(hash) => match Self::fetch_value(db, &hash, (key.as_slice(), None)) { Ok(value) => value, Err(err) => return Some(Err(err)), }, @@ -526,42 +526,36 @@ impl TrieDBRawIterator { None } - /// Fetches the next key in + /// Fetches the next key. /// /// Must be called with the same `db` as when the iterator was created. - /// - /// Specify `fwd` to indicate the direction of the iteration (`true` for forward, `false` for - pub fn next_key( - &mut self, - db: &TrieDB, - fwd: bool, - ) -> Option, CError>> { - while let Some(raw_item) = self.next_raw_item(db, fwd) { - let (prefix, _, node) = match raw_item { - Ok(raw_item) => raw_item, - Err(err) => return Some(Err(err)), + pub fn next_key(&mut self, db: &TrieDB) -> Option, CError>> { + while let Some(raw_item) = self.next_raw_item(db, true) { + let (key, maybe_extra_nibble, _) = match Self::extract_key_from_raw_item(raw_item) { + Some(Ok(k)) => k, + Some(Err(err)) => return Some(Err(err)), + None => continue, }; - let mut prefix = prefix.clone(); - match node.node() { - Node::Leaf(partial, _) => { - prefix.append_partial(partial.right()); - }, - Node::Branch(_, value) => - if value.is_none() { - continue - }, - Node::NibbledBranch(partial, _, value) => { - prefix.append_partial(partial.right()); - if value.is_none() { - continue - } - }, - _ => continue, - }; + if let Some(extra_nibble) = maybe_extra_nibble { + return Some(Err(Box::new(TrieError::ValueAtIncompleteKey(key, extra_nibble)))) + } - let (key_slice, maybe_extra_nibble) = prefix.as_prefix(); - let key = key_slice.to_vec(); + return Some(Ok(key)) + } + None + } + + /// Fetches the previous key. + /// + /// Must be called with the same `db` as when the iterator was created. + pub fn prev_key(&mut self, db: &TrieDB) -> Option, CError>> { + while let Some(raw_item) = self.next_raw_item(db, false) { + let (key, maybe_extra_nibble, _) = match Self::extract_key_from_raw_item(raw_item) { + Some(Ok(k)) => k, + Some(Err(err)) => return Some(Err(err)), + None => continue, + }; if let Some(extra_nibble) = maybe_extra_nibble { return Some(Err(Box::new(TrieError::ValueAtIncompleteKey(key, extra_nibble)))) @@ -571,6 +565,47 @@ impl TrieDBRawIterator { } None } + + /// Extracts the key from the result of a raw item retrieval. + /// + /// Given a raw item, it extracts the key information, including the key bytes, an optional + /// extra nibble (prefix padding), and the node value. + fn extract_key_from_raw_item<'a>( + raw_item: Result< + (&NibbleVec, Option<&TrieHash>, &'a Arc>), + TrieHash, + CError, + >, + ) -> Option, Option, Value<'a>), TrieHash, CError>> { + let (prefix, _, node) = match raw_item { + Ok(raw_item) => raw_item, + Err(err) => return Some(Err(err)), + }; + + let mut prefix = prefix.clone(); + let value = match node.node() { + Node::Leaf(partial, value) => { + prefix.append_partial(partial.right()); + value + }, + Node::Branch(_, value) => match value { + Some(value) => value, + None => return None, + }, + Node::NibbledBranch(partial, _, value) => { + prefix.append_partial(partial.right()); + match value { + Some(value) => value, + None => return None, + } + }, + _ => return None, + }; + + let (key_slice, maybe_extra_nibble) = prefix.as_prefix(); + + Some(Ok((key_slice.to_vec(), maybe_extra_nibble, value))) + } } /// Iterator for going through all nodes in the trie in pre-order traversal order. diff --git a/trie-db/src/triedb.rs b/trie-db/src/triedb.rs index 61277a51..651bc463 100644 --- a/trie-db/src/triedb.rs +++ b/trie-db/src/triedb.rs @@ -547,7 +547,7 @@ impl<'a, 'cache, L: TrieLayout> Iterator for TrieDBIterator<'a, 'cache, L> { type Item = TrieItem, CError>; fn next(&mut self) -> Option { - self.raw_iter.next_item(self.db, true) + self.raw_iter.next_item(self.db) } } @@ -561,13 +561,13 @@ impl<'a, 'cache, L: TrieLayout> Iterator for TrieDBDoubleEndedIterator<'a, 'cach type Item = TrieItem, CError>; fn next(&mut self) -> Option { - self.raw_iter.next_item(self.db, true) + self.raw_iter.next_item(self.db) } } impl<'a, 'cache, L: TrieLayout> DoubleEndedIterator for TrieDBDoubleEndedIterator<'a, 'cache, L> { fn next_back(&mut self) -> Option { - self.back_raw_iter.next_item(self.db, false) + self.back_raw_iter.prev_item(self.db) } } @@ -618,13 +618,7 @@ impl<'a, 'cache, L: TrieLayout> Iterator for TrieDBKeyIterator<'a, 'cache, L> { type Item = TrieKeyItem, CError>; fn next(&mut self) -> Option { - self.raw_iter.next_key(self.db, true) - } -} - -impl<'a, 'cache, L: TrieLayout> DoubleEndedIterator for TrieDBKeyIterator<'a, 'cache, L> { - fn next_back(&mut self) -> Option { - self.raw_iter.next_key(self.db, false) + self.raw_iter.next_key(self.db) } } @@ -639,7 +633,7 @@ impl<'a, 'cache, L: TrieLayout> Iterator for TrieDBKeyDoubleEndedIterator<'a, 'c type Item = TrieKeyItem, CError>; fn next(&mut self) -> Option { - self.raw_iter.next_key(self.db, true) + self.raw_iter.next_key(self.db) } } @@ -647,6 +641,6 @@ impl<'a, 'cache, L: TrieLayout> DoubleEndedIterator for TrieDBKeyDoubleEndedIterator<'a, 'cache, L> { fn next_back(&mut self) -> Option { - self.back_raw_iter.next_key(self.db, false) + self.back_raw_iter.prev_key(self.db) } } diff --git a/trie-db/test/src/double_ended_iterator.rs b/trie-db/test/src/double_ended_iterator.rs new file mode 100644 index 00000000..9df9d594 --- /dev/null +++ b/trie-db/test/src/double_ended_iterator.rs @@ -0,0 +1,152 @@ +// Copyright 2017, 2020 Parity Technologies +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +use hash_db::Hasher; +use hex_literal::hex; +use reference_trie::test_layouts; +use trie_db::{node::Node, NibbleSlice, TrieDBBuilder, TrieDBNodeDoubleEndedIterator, TrieLayout}; + +use crate::iterator::{build_trie_db, nibble_vec}; + +test_layouts!(node_double_ended_iterator_works, node_double_ended_iterator); +fn node_double_ended_iterator() { + let pairs = vec![ + (hex!("01").to_vec(), b"aaaa".to_vec()), + (hex!("0123").to_vec(), b"bbbb".to_vec()), + (hex!("02").to_vec(), vec![1; 32]), + ]; + + let (memdb, root) = build_trie_db::(&pairs); + let trie = TrieDBBuilder::::new(&memdb, &root).build(); + let mut iter = TrieDBNodeDoubleEndedIterator::new(&trie).unwrap(); + + if T::USE_EXTENSION { + match iter.next_back() { + Some(Ok((prefix, Some(_), node))) => { + assert_eq!(prefix, nibble_vec(hex!(""), 0)); + match node.node() { + Node::Extension(partial, _) => + assert_eq!(partial, NibbleSlice::new_offset(&hex!("00")[..], 1)), + _ => panic!("unexpected node"), + } + }, + _ => panic!("unexpected item"), + } + + match iter.next_back() { + Some(Ok((prefix, Some(_), node))) => { + assert_eq!(prefix, nibble_vec(hex!("00"), 1)); + match node.node() { + Node::Branch(_, _) => {}, + _ => panic!("unexpected node"), + } + }, + _ => panic!("unexpected item"), + } + match iter.next_back() { + Some(Ok((prefix, Some(_), node))) => { + assert_eq!(prefix, nibble_vec(hex!("02"), 2)); + match node.node() { + Node::Leaf(partial, _) => assert_eq!(partial, NibbleSlice::new(&hex!("")[..])), + _ => panic!("unexpected node"), + } + }, + _ => panic!("unexpected item"), + } + + match iter.next_back() { + Some(Ok((prefix, None, node))) => { + assert_eq!(prefix, nibble_vec(hex!("01"), 2)); + match node.node() { + Node::Branch(_, _) => {}, + _ => panic!("unexpected node"), + } + }, + _ => panic!("unexpected item"), + } + + match iter.next_back() { + Some(Ok((prefix, None, node))) => { + assert_eq!(prefix, nibble_vec(hex!("0120"), 3)); + match node.node() { + Node::Leaf(partial, _) => + assert_eq!(partial, NibbleSlice::new_offset(&hex!("03")[..], 1)), + _ => panic!("unexpected node"), + } + }, + _ => panic!("unexpected item"), + } + + assert!(iter.next_back().is_none()); + } else { + let can_expand = + T::MAX_INLINE_VALUE.unwrap_or(T::Hash::LENGTH as u32) < T::Hash::LENGTH as u32; + + match iter.next_back() { + Some(Ok((prefix, Some(_), node))) => { + assert_eq!(prefix, nibble_vec(hex!(""), 0)); + match node.node() { + Node::NibbledBranch(partial, _, _) => + assert_eq!(partial, NibbleSlice::new_offset(&hex!("00")[..], 1)), + _ => panic!("unexpected node"), + } + }, + _ => panic!("unexpected item"), + } + + // Start from the last element and move backwards + match iter.next_back() { + Some(Ok((prefix, Some(_), node))) => { + assert_eq!(prefix, nibble_vec(hex!("02"), 2)); + match node.node() { + Node::Leaf(partial, _) => assert_eq!(partial, NibbleSlice::new(&hex!("")[..])), + _ => panic!("unexpected node"), + } + }, + _ => panic!("unexpected item"), + } + + match iter.next_back() { + Some(Ok((prefix, hash, node))) => { + if !can_expand { + assert!(hash.is_none()); + } + assert_eq!(prefix, nibble_vec(hex!("01"), 2)); + match node.node() { + Node::NibbledBranch(partial, _, _) => + assert_eq!(partial, NibbleSlice::new(&hex!("")[..])), + _ => panic!("unexpected node"), + } + }, + _ => panic!("unexpected item"), + } + + match iter.next_back() { + Some(Ok((prefix, hash, node))) => { + if !can_expand { + assert!(hash.is_none()); + } + assert_eq!(prefix, nibble_vec(hex!("0120"), 3)); + match node.node() { + Node::Leaf(partial, _) => + assert_eq!(partial, NibbleSlice::new_offset(&hex!("03")[..], 1)), + _ => panic!("unexpected node"), + } + }, + _ => panic!("unexpected item"), + } + + assert!(iter.next_back().is_none()); + } +} diff --git a/trie-db/test/src/iterator.rs b/trie-db/test/src/iterator.rs index e36ef6d0..961a5eb9 100644 --- a/trie-db/test/src/iterator.rs +++ b/trie-db/test/src/iterator.rs @@ -27,7 +27,7 @@ type MemoryDB = memory_db::MemoryDB< DBValue, >; -fn build_trie_db( +pub(crate) fn build_trie_db( pairs: &[(Vec, Vec)], ) -> (MemoryDB, ::Out) { let mut memdb = MemoryDB::::default(); @@ -41,7 +41,7 @@ fn build_trie_db( (memdb, root) } -fn nibble_vec>(bytes: T, len: usize) -> NibbleVec { +pub(crate) fn nibble_vec>(bytes: T, len: usize) -> NibbleVec { let slice = NibbleSlice::new(bytes.as_ref()); let mut v = NibbleVec::new(); diff --git a/trie-db/test/src/lib.rs b/trie-db/test/src/lib.rs index 7802247e..9f0eebab 100644 --- a/trie-db/test/src/lib.rs +++ b/trie-db/test/src/lib.rs @@ -14,6 +14,8 @@ //! Tests for trie-db crate. +#[cfg(test)] +mod double_ended_iterator; #[cfg(test)] mod fatdb; #[cfg(test)] diff --git a/trie-db/test/src/triedb.rs b/trie-db/test/src/triedb.rs index 0eda38e2..6589d99d 100644 --- a/trie-db/test/src/triedb.rs +++ b/trie-db/test/src/triedb.rs @@ -120,10 +120,12 @@ fn double_ended_iterator_internal() { for i in 0..pairs.len() { assert_eq!(iter.next().unwrap().unwrap(), pairs[i].clone()); - assert_eq!(iter.next_back().unwrap().unwrap(), pairs[pairs.len() - i - 1].clone()); } - assert!(iter.next().is_none()); + + for i in (0..pairs.len()).rev() { + assert_eq!(iter.next_back().unwrap().unwrap(), pairs[i].clone()); + } assert!(iter.next_back().is_none()); } From 965c7bab6b9b9c7aa341ce38009e8700d55357c8 Mon Sep 17 00:00:00 2001 From: Snowmead Date: Wed, 3 Jan 2024 10:42:48 -0500 Subject: [PATCH 11/16] seek back raw iter --- trie-db/src/iterator.rs | 3 +- trie-db/src/triedb.rs | 6 +- trie-db/test/src/double_ended_iterator.rs | 95 ++++++++++++++++++++++- 3 files changed, 100 insertions(+), 4 deletions(-) diff --git a/trie-db/src/iterator.rs b/trie-db/src/iterator.rs index 8a3f80f7..c3213140 100644 --- a/trie-db/src/iterator.rs +++ b/trie-db/src/iterator.rs @@ -704,7 +704,8 @@ impl TrieDoubleEndedIterator for TrieDBNodeDoubleEndedIterator impl<'a, 'cache, L: TrieLayout> TrieIterator for TrieDBNodeDoubleEndedIterator<'a, 'cache, L> { fn seek(&mut self, key: &[u8]) -> Result<(), TrieHash, CError> { - self.raw_iter.seek(self.db, key).map(|_| ()) + self.raw_iter.seek(self.db, key).map(|_| ())?; + self.back_raw_iter.seek(self.db, key).map(|_| ()) } } diff --git a/trie-db/src/triedb.rs b/trie-db/src/triedb.rs index 651bc463..8a5d547a 100644 --- a/trie-db/src/triedb.rs +++ b/trie-db/src/triedb.rs @@ -553,7 +553,8 @@ impl<'a, 'cache, L: TrieLayout> Iterator for TrieDBIterator<'a, 'cache, L> { impl<'a, 'cache, L: TrieLayout> TrieIterator for TrieDBDoubleEndedIterator<'a, 'cache, L> { fn seek(&mut self, key: &[u8]) -> Result<(), TrieHash, CError> { - self.raw_iter.seek(self.db, key).map(|_| ()) + self.raw_iter.seek(self.db, key).map(|_| ())?; + self.back_raw_iter.seek(self.db, key).map(|_| ()) } } @@ -625,7 +626,8 @@ impl<'a, 'cache, L: TrieLayout> Iterator for TrieDBKeyIterator<'a, 'cache, L> { impl<'a, 'cache, L: TrieLayout> TrieIterator for TrieDBKeyDoubleEndedIterator<'a, 'cache, L> { /// Position the iterator on the first element with key >= `key` fn seek(&mut self, key: &[u8]) -> Result<(), TrieHash, CError> { - self.raw_iter.seek(self.db, key).map(|_| ()) + self.raw_iter.seek(self.db, key).map(|_| ())?; + self.back_raw_iter.seek(self.db, key).map(|_| ()) } } diff --git a/trie-db/test/src/double_ended_iterator.rs b/trie-db/test/src/double_ended_iterator.rs index 9df9d594..381c12cd 100644 --- a/trie-db/test/src/double_ended_iterator.rs +++ b/trie-db/test/src/double_ended_iterator.rs @@ -15,7 +15,10 @@ use hash_db::Hasher; use hex_literal::hex; use reference_trie::test_layouts; -use trie_db::{node::Node, NibbleSlice, TrieDBBuilder, TrieDBNodeDoubleEndedIterator, TrieLayout}; +use trie_db::{ + node::Node, NibbleSlice, TrieDBBuilder, TrieDBNodeDoubleEndedIterator, TrieDoubleEndedIterator, + TrieLayout, +}; use crate::iterator::{build_trie_db, nibble_vec}; @@ -150,3 +153,93 @@ fn node_double_ended_iterator() { assert!(iter.next_back().is_none()); } } + +test_layouts!(seek_over_empty_works, seek_over_empty_works_internal); +fn seek_over_empty_works_internal() { + let (memdb, root) = build_trie_db::(&[]); + let trie = TrieDBBuilder::::new(&memdb, &root).build(); + let mut iter = TrieDBNodeDoubleEndedIterator::new(&trie).unwrap(); + + >::seek(&mut iter, &hex!("")[..]).unwrap(); + match iter.next_back() { + Some(Ok((prefix, _, node))) => { + assert_eq!(prefix, nibble_vec(hex!(""), 0)); + match node.node() { + Node::Empty => {}, + _ => panic!("unexpected node"), + } + }, + _ => panic!("unexpected item"), + } + + >::seek(&mut iter, &hex!("00")[..]).unwrap(); + assert!(iter.next_back().is_none()); +} + +test_layouts!(seek_works, seek_works_internal); +fn seek_works_internal() { + let pairs = vec![ + (hex!("01").to_vec(), b"aaaa".to_vec()), + (hex!("0123").to_vec(), b"bbbb".to_vec()), + (hex!("02").to_vec(), vec![1; 32]), + ]; + + let (memdb, root) = build_trie_db::(&pairs); + let trie = TrieDBBuilder::::new(&memdb, &root).build(); + let mut iter = TrieDBNodeDoubleEndedIterator::new(&trie).unwrap(); + + >::seek(&mut iter, &hex!("")[..]).unwrap(); + match iter.next_back() { + Some(Ok((prefix, _, _))) => assert_eq!(prefix, nibble_vec(hex!(""), 0)), + _ => panic!("unexpected item"), + } + + >::seek(&mut iter, &hex!("03")[..]).unwrap(); + match iter.next_back() { + Some(Ok((prefix, _, _))) => assert_eq!(prefix, nibble_vec(hex!("02"), 2)), + _ => panic!("unexpected item"), + } + + >::seek(&mut iter, &hex!("02")[..]).unwrap(); + match iter.next_back() { + Some(Ok((prefix, _, _))) => assert_eq!(prefix, nibble_vec(hex!("02"), 2)), + _ => panic!("unexpected item"), + } + + match iter.next_back() { + Some(Ok((prefix, _, _))) => assert_eq!(prefix, nibble_vec(hex!("01"), 2)), + _ => panic!("unexpected item"), + } + + match iter.next_back() { + Some(Ok((prefix, _, _))) => assert_eq!(prefix, nibble_vec(hex!("0120"), 3)), + _ => panic!("unexpected item"), + } + + >::seek(&mut iter, &hex!("01")[..]).unwrap(); + match iter.next_back() { + Some(Ok((prefix, _, _))) => { + assert_eq!(prefix, nibble_vec(hex!("01"), 2)); + }, + _ => panic!("unexpected item"), + } + + >::seek(&mut iter, &hex!("0125")[..]).unwrap(); + match iter.next_back() { + Some(Ok((prefix, _, _))) => { + assert_eq!(prefix, nibble_vec(hex!("0120"), 3)); + // match node.node() { + // Node::Leaf(partial, _) => + // assert_eq!(partial, NibbleSlice::new_offset(&hex!("03")[..], 1)), + // _ => panic!("unexpected node"), + // } + }, + _ => panic!("unexpected item"), + } + + >::seek(&mut iter, &hex!("")[..]).unwrap(); + match iter.next_back() { + Some(Ok((prefix, _, _))) => assert_eq!(prefix, nibble_vec(hex!(""), 0)), + _ => panic!("unexpected item"), + } +} From cd77bf45229206d801688ef42f64da84bfd6cb5f Mon Sep 17 00:00:00 2001 From: Snowmead Date: Wed, 3 Jan 2024 15:31:22 -0500 Subject: [PATCH 12/16] add prefix to double ended iter impl --- trie-db/src/iterator.rs | 133 +++++++++++++++------- trie-db/src/triedb.rs | 12 +- trie-db/test/src/double_ended_iterator.rs | 99 ++++++++++++---- 3 files changed, 180 insertions(+), 64 deletions(-) diff --git a/trie-db/src/iterator.rs b/trie-db/src/iterator.rs index c3213140..bc6f276b 100644 --- a/trie-db/src/iterator.rs +++ b/trie-db/src/iterator.rs @@ -99,7 +99,7 @@ impl TrieDBRawIterator { /// Create a new iterator, but limited to a given prefix. pub fn new_prefixed(db: &TrieDB, prefix: &[u8]) -> Result, CError> { let mut iter = TrieDBRawIterator::new(db)?; - iter.prefix(db, prefix)?; + iter.prefix(db, prefix, true)?; Ok(iter) } @@ -144,6 +144,7 @@ impl TrieDBRawIterator { &mut self, db: &TrieDB, key: &[u8], + fwd: bool, ) -> Result, CError> { self.trail.clear(); self.key_nibbles.clear(); @@ -169,11 +170,11 @@ impl TrieDBRawIterator { match crumb.node.node_plan() { NodePlan::Leaf { partial: partial_plan, .. } => { let slice = partial_plan.build(node_data); - if slice < partial { + if (fwd && slice < partial) || (!fwd && slice > partial) { crumb.status = Status::Exiting; - return Ok(false) + return Ok(false); } - return Ok(slice.starts_with(&partial)) + return Ok(slice.starts_with(&partial)); }, NodePlan::Extension { partial: partial_plan, child } => { let slice = partial_plan.build(node_data); @@ -181,9 +182,9 @@ impl TrieDBRawIterator { if slice < partial { crumb.status = Status::Exiting; self.key_nibbles.append_partial(slice.right()); - return Ok(false) + return Ok(false); } - return Ok(slice.starts_with(&partial)) + return Ok(slice.starts_with(&partial)); } full_key_nibbles += slice.len(); @@ -201,7 +202,7 @@ impl TrieDBRawIterator { }, NodePlan::Branch { value: _, children } => { if partial.is_empty() { - return Ok(true) + return Ok(true); } let i = partial.at(0); @@ -220,7 +221,7 @@ impl TrieDBRawIterator { true, )? } else { - return Ok(false) + return Ok(false); } }, NodePlan::NibbledBranch { partial: partial_plan, value: _, children } => { @@ -230,16 +231,16 @@ impl TrieDBRawIterator { crumb.status = Status::Exiting; self.key_nibbles.append_partial(slice.right()); self.key_nibbles.push((nibble_ops::NIBBLE_LENGTH - 1) as u8); - return Ok(false) + return Ok(false); } - return Ok(slice.starts_with(&partial)) + return Ok(slice.starts_with(&partial)); } full_key_nibbles += slice.len(); partial = partial.mid(slice.len()); if partial.is_empty() { - return Ok(true) + return Ok(true); } let i = partial.at(0); @@ -259,15 +260,15 @@ impl TrieDBRawIterator { true, )? } else { - return Ok(false) + return Ok(false); } }, NodePlan::Empty => { if !partial.is_empty() { crumb.status = Status::Exiting; - return Ok(false) + return Ok(false); } - return Ok(true) + return Ok(true); }, } }; @@ -279,8 +280,13 @@ impl TrieDBRawIterator { /// Advance the iterator into a prefix, no value out of the prefix will be accessed /// or returned after this operation. - fn prefix(&mut self, db: &TrieDB, prefix: &[u8]) -> Result<(), TrieHash, CError> { - if self.seek(db, prefix)? { + fn prefix( + &mut self, + db: &TrieDB, + prefix: &[u8], + fwd: bool, + ) -> Result<(), TrieHash, CError> { + if self.seek(db, prefix, fwd)? { if let Some(v) = self.trail.pop() { self.trail.clear(); self.trail.push(v); @@ -302,31 +308,31 @@ impl TrieDBRawIterator { ) -> Result<(), TrieHash, CError> { if prefix.is_empty() { // There's no prefix, so just seek. - return self.seek(db, seek).map(|_| ()) + return self.seek(db, seek, true).map(|_| ()); } if seek.is_empty() || seek <= prefix { // Either we're not supposed to seek anywhere, // or we're supposed to seek *before* the prefix, // so just directly go to the prefix. - return self.prefix(db, prefix) + return self.prefix(db, prefix, true); } if !seek.starts_with(prefix) { // We're supposed to seek *after* the prefix, // so just return an empty iterator. self.trail.clear(); - return Ok(()) + return Ok(()); } - if !self.seek(db, prefix)? { + if !self.seek(db, prefix, true)? { // The database doesn't have a key with such a prefix. self.trail.clear(); - return Ok(()) + return Ok(()); } // Now seek forward again. - self.seek(db, seek)?; + self.seek(db, seek, true)?; let prefix_len = prefix.len() * crate::nibble::nibble_ops::NIBBLE_PER_BYTE; let mut len = 0; @@ -350,7 +356,7 @@ impl TrieDBRawIterator { } if len > prefix_len { self.trail = self.trail.split_off(i); - return Ok(()) + return Ok(()); } } @@ -383,7 +389,7 @@ impl TrieDBRawIterator { // This is only necessary due to current borrow checker's limitation. let crumb = self.trail.last_mut().expect("we've just fetched the last element using `last_mut` so this cannot fail; qed"); crumb.step(fwd); - return Some(Ok((&self.key_nibbles, crumb.hash.as_ref(), &crumb.node))) + return Some(Ok((&self.key_nibbles, crumb.hash.as_ref(), &crumb.node))); }, (Status::Exiting, node) => { match node { @@ -416,7 +422,7 @@ impl TrieDBRawIterator { }, Err(err) => { crumb.step(fwd); - return Some(Err(err)) + return Some(Err(err)); }, } }, @@ -455,7 +461,7 @@ impl TrieDBRawIterator { }, Err(err) => { crumb.step(fwd); - return Some(Err(err)) + return Some(Err(err)); }, } } else { @@ -482,7 +488,7 @@ impl TrieDBRawIterator { }; if let Some(extra_nibble) = maybe_extra_nibble { - return Some(Err(Box::new(TrieError::ValueAtIncompleteKey(key, extra_nibble)))) + return Some(Err(Box::new(TrieError::ValueAtIncompleteKey(key, extra_nibble)))); } let value = match value { @@ -493,7 +499,7 @@ impl TrieDBRawIterator { Value::Inline(value) => value.to_vec(), }; - return Some(Ok((key, value))) + return Some(Ok((key, value))); } None } @@ -510,7 +516,7 @@ impl TrieDBRawIterator { }; if let Some(extra_nibble) = maybe_extra_nibble { - return Some(Err(Box::new(TrieError::ValueAtIncompleteKey(key, extra_nibble)))) + return Some(Err(Box::new(TrieError::ValueAtIncompleteKey(key, extra_nibble)))); } let value = match value { @@ -521,7 +527,7 @@ impl TrieDBRawIterator { Value::Inline(value) => value.to_vec(), }; - return Some(Ok((key, value))) + return Some(Ok((key, value))); } None } @@ -538,10 +544,10 @@ impl TrieDBRawIterator { }; if let Some(extra_nibble) = maybe_extra_nibble { - return Some(Err(Box::new(TrieError::ValueAtIncompleteKey(key, extra_nibble)))) + return Some(Err(Box::new(TrieError::ValueAtIncompleteKey(key, extra_nibble)))); } - return Some(Ok(key)) + return Some(Ok(key)); } None } @@ -558,10 +564,10 @@ impl TrieDBRawIterator { }; if let Some(extra_nibble) = maybe_extra_nibble { - return Some(Err(Box::new(TrieError::ValueAtIncompleteKey(key, extra_nibble)))) + return Some(Err(Box::new(TrieError::ValueAtIncompleteKey(key, extra_nibble)))); } - return Some(Ok(key)) + return Some(Ok(key)); } None } @@ -646,7 +652,7 @@ impl<'a, 'cache, L: TrieLayout> TrieDBNodeIterator<'a, 'cache, L> { /// Advance the iterator into a prefix, no value out of the prefix will be accessed /// or returned after this operation. pub fn prefix(&mut self, prefix: &[u8]) -> Result<(), TrieHash, CError> { - self.raw_iter.prefix(self.db, prefix) + self.raw_iter.prefix(self.db, prefix, true) } /// Advance the iterator into a prefix, no value out of the prefix will be accessed @@ -667,7 +673,7 @@ impl<'a, 'cache, L: TrieLayout> TrieDBNodeIterator<'a, 'cache, L> { impl<'a, 'cache, L: TrieLayout> TrieIterator for TrieDBNodeIterator<'a, 'cache, L> { fn seek(&mut self, key: &[u8]) -> Result<(), TrieHash, CError> { - self.raw_iter.seek(self.db, key).map(|_| ()) + self.raw_iter.seek(self.db, key, true).map(|_| ()) } } @@ -698,14 +704,65 @@ impl<'a, 'cache, L: TrieLayout> TrieDBNodeDoubleEndedIterator<'a, 'cache, L> { back_raw_iter: TrieDBRawIterator::new(db)?, }) } + + /// Restore an iterator from a raw iterators. + pub fn from_raw( + db: &'a TrieDB<'a, 'cache, L>, + raw_iter: TrieDBRawIterator, + back_raw_iter: TrieDBRawIterator, + ) -> Self { + Self { db, raw_iter, back_raw_iter } + } + + /// Convert the iterator to a raw forward iterator. + pub fn into_raw(self) -> TrieDBRawIterator { + self.raw_iter + } + + /// Convert the iterator to a raw backward iterator. + pub fn into_raw_back(self) -> TrieDBRawIterator { + self.back_raw_iter + } + + /// Fetch value by hash at a current node height + pub fn fetch_value( + &self, + key: &[u8], + prefix: Prefix, + ) -> Result, CError> { + TrieDBRawIterator::fetch_value(self.db, key, prefix) + } + + /// Advance the iterator into a prefix, no value out of the prefix will be accessed + /// or returned after this operation. + pub fn prefix(&mut self, prefix: &[u8]) -> Result<(), TrieHash, CError> { + self.raw_iter.prefix(self.db, prefix, true)?; + self.back_raw_iter.prefix(self.db, prefix, false) + } + + /// Advance the iterator into a prefix, no value out of the prefix will be accessed + /// or returned after this operation. + pub fn prefix_then_seek( + &mut self, + prefix: &[u8], + seek: &[u8], + ) -> Result<(), TrieHash, CError> { + self.raw_iter.prefix_then_seek(self.db, prefix, seek)?; + self.back_raw_iter.prefix_then_seek(self.db, prefix, seek) + } + + /// Access inner hash db. + pub fn db(&self) -> &dyn hash_db::HashDBRef { + self.db.db() + } } impl TrieDoubleEndedIterator for TrieDBNodeDoubleEndedIterator<'_, '_, L> {} impl<'a, 'cache, L: TrieLayout> TrieIterator for TrieDBNodeDoubleEndedIterator<'a, 'cache, L> { fn seek(&mut self, key: &[u8]) -> Result<(), TrieHash, CError> { - self.raw_iter.seek(self.db, key).map(|_| ())?; - self.back_raw_iter.seek(self.db, key).map(|_| ()) + self.raw_iter.seek(self.db, key, true).map(|_| ())?; + self.back_raw_iter.seek(self.db, key, false).map(|_| ()) } } diff --git a/trie-db/src/triedb.rs b/trie-db/src/triedb.rs index 8a5d547a..d027688c 100644 --- a/trie-db/src/triedb.rs +++ b/trie-db/src/triedb.rs @@ -539,7 +539,7 @@ impl<'a, 'cache, L: TrieLayout> TrieDBIterator<'a, 'cache, L> { impl<'a, 'cache, L: TrieLayout> TrieIterator for TrieDBIterator<'a, 'cache, L> { /// Position the iterator on the first element with key >= `key` fn seek(&mut self, key: &[u8]) -> Result<(), TrieHash, CError> { - self.raw_iter.seek(self.db, key).map(|_| ()) + self.raw_iter.seek(self.db, key, true).map(|_| ()) } } @@ -553,8 +553,8 @@ impl<'a, 'cache, L: TrieLayout> Iterator for TrieDBIterator<'a, 'cache, L> { impl<'a, 'cache, L: TrieLayout> TrieIterator for TrieDBDoubleEndedIterator<'a, 'cache, L> { fn seek(&mut self, key: &[u8]) -> Result<(), TrieHash, CError> { - self.raw_iter.seek(self.db, key).map(|_| ())?; - self.back_raw_iter.seek(self.db, key).map(|_| ()) + self.raw_iter.seek(self.db, key, true).map(|_| ())?; + self.back_raw_iter.seek(self.db, key, false).map(|_| ()) } } @@ -611,7 +611,7 @@ impl<'a, 'cache, L: TrieLayout> TrieDBKeyIterator<'a, 'cache, L> { impl<'a, 'cache, L: TrieLayout> TrieIterator for TrieDBKeyIterator<'a, 'cache, L> { /// Position the iterator on the first element with key >= `key` fn seek(&mut self, key: &[u8]) -> Result<(), TrieHash, CError> { - self.raw_iter.seek(self.db, key).map(|_| ()) + self.raw_iter.seek(self.db, key, true).map(|_| ()) } } @@ -626,8 +626,8 @@ impl<'a, 'cache, L: TrieLayout> Iterator for TrieDBKeyIterator<'a, 'cache, L> { impl<'a, 'cache, L: TrieLayout> TrieIterator for TrieDBKeyDoubleEndedIterator<'a, 'cache, L> { /// Position the iterator on the first element with key >= `key` fn seek(&mut self, key: &[u8]) -> Result<(), TrieHash, CError> { - self.raw_iter.seek(self.db, key).map(|_| ())?; - self.back_raw_iter.seek(self.db, key).map(|_| ()) + self.raw_iter.seek(self.db, key, true).map(|_| ())?; + self.back_raw_iter.seek(self.db, key, false).map(|_| ()) } } diff --git a/trie-db/test/src/double_ended_iterator.rs b/trie-db/test/src/double_ended_iterator.rs index 381c12cd..29a71877 100644 --- a/trie-db/test/src/double_ended_iterator.rs +++ b/trie-db/test/src/double_ended_iterator.rs @@ -154,8 +154,8 @@ fn node_double_ended_iterator() { } } -test_layouts!(seek_over_empty_works, seek_over_empty_works_internal); -fn seek_over_empty_works_internal() { +test_layouts!(seek_back_over_empty_works, seek_back_over_empty_works_internal); +fn seek_back_over_empty_works_internal() { let (memdb, root) = build_trie_db::(&[]); let trie = TrieDBBuilder::::new(&memdb, &root).build(); let mut iter = TrieDBNodeDoubleEndedIterator::new(&trie).unwrap(); @@ -176,11 +176,12 @@ fn seek_over_empty_works_internal() { assert!(iter.next_back().is_none()); } -test_layouts!(seek_works, seek_works_internal); -fn seek_works_internal() { +test_layouts!(seek_back_works, seek_back_works_internal); +fn seek_back_works_internal() { let pairs = vec![ (hex!("01").to_vec(), b"aaaa".to_vec()), (hex!("0123").to_vec(), b"bbbb".to_vec()), + (hex!("0122").to_vec(), b"cccc".to_vec()), (hex!("02").to_vec(), vec![1; 32]), ]; @@ -206,40 +207,98 @@ fn seek_works_internal() { _ => panic!("unexpected item"), } + >::seek(&mut iter, &hex!("01")[..]).unwrap(); match iter.next_back() { - Some(Ok((prefix, _, _))) => assert_eq!(prefix, nibble_vec(hex!("01"), 2)), + Some(Ok((prefix, _, _))) => { + assert_eq!(prefix, nibble_vec(hex!("01"), 2)); + }, _ => panic!("unexpected item"), } + >::seek(&mut iter, &hex!("0125")[..]).unwrap(); match iter.next_back() { - Some(Ok((prefix, _, _))) => assert_eq!(prefix, nibble_vec(hex!("0120"), 3)), + Some(Ok((prefix, _, _))) => { + assert_eq!(prefix, nibble_vec(hex!("0123"), 4)); + }, _ => panic!("unexpected item"), } - >::seek(&mut iter, &hex!("01")[..]).unwrap(); match iter.next_back() { Some(Ok((prefix, _, _))) => { - assert_eq!(prefix, nibble_vec(hex!("01"), 2)); + assert_eq!(prefix, nibble_vec(hex!("0122"), 4)); }, _ => panic!("unexpected item"), } - >::seek(&mut iter, &hex!("0125")[..]).unwrap(); + >::seek(&mut iter, &hex!("0120")[..]).unwrap(); + assert!(iter.next_back().is_none()); +} + +test_layouts!(prefix_works, prefix_works_internal); +fn prefix_works_internal() { + let can_expand = T::MAX_INLINE_VALUE.unwrap_or(T::Hash::LENGTH as u32) < T::Hash::LENGTH as u32; + let pairs = vec![ + (hex!("01").to_vec(), b"aaaa".to_vec()), + (hex!("0123").to_vec(), b"bbbb".to_vec()), + (hex!("02").to_vec(), vec![1; 32]), + ]; + + let (memdb, root) = build_trie_db::(&pairs); + let trie = TrieDBBuilder::::new(&memdb, &root).build(); + let mut iter = TrieDBNodeDoubleEndedIterator::new(&trie).unwrap(); + + iter.prefix(&hex!("01").to_vec()[..]).unwrap(); + + if T::USE_EXTENSION { + match iter.next_back() { + Some(Ok((prefix, None, node))) => { + assert_eq!(prefix, nibble_vec(hex!("01"), 2)); + match node.node() { + Node::Branch(_, _) => {}, + _ => panic!("unexpected node"), + } + }, + _ => panic!("unexpected item"), + } + } else { + match iter.next_back() { + Some(Ok((prefix, hash, node))) => { + if !can_expand { + debug_assert!(hash.is_none()); + } + assert_eq!(prefix, nibble_vec(hex!("01"), 2)); + match node.node() { + Node::NibbledBranch(partial, _, _) => + assert_eq!(partial, NibbleSlice::new_offset(&hex!("")[..], 0)), + _ => panic!("unexpected node"), + } + }, + _ => panic!("unexpected item"), + } + } + match iter.next_back() { - Some(Ok((prefix, _, _))) => { + Some(Ok((prefix, hash, node))) => { + if !can_expand { + debug_assert!(hash.is_none()); + } assert_eq!(prefix, nibble_vec(hex!("0120"), 3)); - // match node.node() { - // Node::Leaf(partial, _) => - // assert_eq!(partial, NibbleSlice::new_offset(&hex!("03")[..], 1)), - // _ => panic!("unexpected node"), - // } + match node.node() { + Node::Leaf(partial, _) => { + assert_eq!(partial, NibbleSlice::new_offset(&hex!("03")[..], 1)) + }, + _ => panic!("unexpected node"), + } }, _ => panic!("unexpected item"), } - >::seek(&mut iter, &hex!("")[..]).unwrap(); - match iter.next_back() { - Some(Ok((prefix, _, _))) => assert_eq!(prefix, nibble_vec(hex!(""), 0)), - _ => panic!("unexpected item"), - } + assert!(iter.next_back().is_none()); + + let mut iter = TrieDBNodeDoubleEndedIterator::new(&trie).unwrap(); + iter.prefix(&hex!("0010").to_vec()[..]).unwrap(); + assert!(iter.next_back().is_none()); + let mut iter = TrieDBNodeDoubleEndedIterator::new(&trie).unwrap(); + iter.prefix(&hex!("10").to_vec()[..]).unwrap(); + assert!(iter.next_back().is_none()); } From 6e6457d02a3a09e7e9feb97584aa3e5ba4f495db Mon Sep 17 00:00:00 2001 From: Snowmead Date: Thu, 4 Jan 2024 08:00:45 -0500 Subject: [PATCH 13/16] add more to prefix test --- trie-db/test/src/double_ended_iterator.rs | 35 ++++++++++++++++++++++- 1 file changed, 34 insertions(+), 1 deletion(-) diff --git a/trie-db/test/src/double_ended_iterator.rs b/trie-db/test/src/double_ended_iterator.rs index 29a71877..4b76714d 100644 --- a/trie-db/test/src/double_ended_iterator.rs +++ b/trie-db/test/src/double_ended_iterator.rs @@ -240,6 +240,7 @@ fn prefix_works_internal() { let pairs = vec![ (hex!("01").to_vec(), b"aaaa".to_vec()), (hex!("0123").to_vec(), b"bbbb".to_vec()), + (hex!("0122").to_vec(), b"cccc".to_vec()), (hex!("02").to_vec(), vec![1; 32]), ]; @@ -283,9 +284,41 @@ fn prefix_works_internal() { debug_assert!(hash.is_none()); } assert_eq!(prefix, nibble_vec(hex!("0120"), 3)); + match node.node() { + Node::NibbledBranch(partial, _, _) => + assert_eq!(partial, NibbleSlice::new(&hex!("")[..])), + Node::Branch(_, _) => {}, + _ => panic!("unexpected node"), + } + }, + _ => panic!("unexpected item"), + } + + match iter.next_back() { + Some(Ok((prefix, hash, node))) => { + if !can_expand { + debug_assert!(hash.is_none()); + } + assert_eq!(prefix, nibble_vec(hex!("0123"), 4)); + match node.node() { + Node::Leaf(partial, _) => { + assert_eq!(partial, NibbleSlice::new_offset(&hex!("")[..], 0)) + }, + _ => panic!("unexpected node"), + } + }, + _ => panic!("unexpected item"), + } + + match iter.next_back() { + Some(Ok((prefix, hash, node))) => { + if !can_expand { + debug_assert!(hash.is_none()); + } + assert_eq!(prefix, nibble_vec(hex!("0122"), 4)); match node.node() { Node::Leaf(partial, _) => { - assert_eq!(partial, NibbleSlice::new_offset(&hex!("03")[..], 1)) + assert_eq!(partial, NibbleSlice::new_offset(&hex!("")[..], 0)) }, _ => panic!("unexpected node"), } From 6e916c253405c51d72472a6e4d34e06aa3c1c1dc Mon Sep 17 00:00:00 2001 From: Snowmead Date: Thu, 4 Jan 2024 08:25:46 -0500 Subject: [PATCH 14/16] prefix_over_empty_works_internal test --- trie-db/test/src/double_ended_iterator.rs | 24 +++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/trie-db/test/src/double_ended_iterator.rs b/trie-db/test/src/double_ended_iterator.rs index 4b76714d..614ece51 100644 --- a/trie-db/test/src/double_ended_iterator.rs +++ b/trie-db/test/src/double_ended_iterator.rs @@ -335,3 +335,27 @@ fn prefix_works_internal() { iter.prefix(&hex!("10").to_vec()[..]).unwrap(); assert!(iter.next_back().is_none()); } + +test_layouts!(prefix_over_empty_works, prefix_over_empty_works_internal); +fn prefix_over_empty_works_internal() { + let (memdb, root) = build_trie_db::(&[]); + let trie = TrieDBBuilder::::new(&memdb, &root).build(); + let mut iter = TrieDBNodeDoubleEndedIterator::new(&trie).unwrap(); + iter.prefix(&hex!("")[..]).unwrap(); + match iter.next_back() { + Some(Ok((prefix, Some(_), node))) => { + assert_eq!(prefix, nibble_vec(hex!(""), 0)); + match node.node() { + Node::Empty => {}, + _ => panic!("unexpected node"), + } + }, + _ => panic!("unexpected item"), + } + + assert!(iter.next_back().is_none()); + + let mut iter = TrieDBNodeDoubleEndedIterator::new(&trie).unwrap(); + iter.prefix(&hex!("00")[..]).unwrap(); + assert!(iter.next_back().is_none()); +} From cc4ab6762e500803e898e5cdfccaee8948c84c7f Mon Sep 17 00:00:00 2001 From: Snowmead Date: Thu, 4 Jan 2024 11:54:01 -0500 Subject: [PATCH 15/16] renamed test --- trie-db/test/src/double_ended_iterator.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/trie-db/test/src/double_ended_iterator.rs b/trie-db/test/src/double_ended_iterator.rs index 614ece51..dcb83a0d 100644 --- a/trie-db/test/src/double_ended_iterator.rs +++ b/trie-db/test/src/double_ended_iterator.rs @@ -234,8 +234,8 @@ fn seek_back_works_internal() { assert!(iter.next_back().is_none()); } -test_layouts!(prefix_works, prefix_works_internal); -fn prefix_works_internal() { +test_layouts!(prefix_back_works, prefix_back_works_internal); +fn prefix_back_works_internal() { let can_expand = T::MAX_INLINE_VALUE.unwrap_or(T::Hash::LENGTH as u32) < T::Hash::LENGTH as u32; let pairs = vec![ (hex!("01").to_vec(), b"aaaa".to_vec()), From 95e489a3449cc8f6a036125cf0834497f61950b8 Mon Sep 17 00:00:00 2001 From: Snowmead Date: Fri, 5 Jan 2024 11:37:03 -0500 Subject: [PATCH 16/16] new status AftExiting, return middle node in reverse order iteration, fix seek backward iteration, update tests --- trie-db/src/iterator.rs | 27 ++-- trie-db/test/src/double_ended_iterator.rs | 145 ++++++++++++++-------- 2 files changed, 115 insertions(+), 57 deletions(-) diff --git a/trie-db/src/iterator.rs b/trie-db/src/iterator.rs index bc6f276b..1d3319ed 100644 --- a/trie-db/src/iterator.rs +++ b/trie-db/src/iterator.rs @@ -30,6 +30,7 @@ enum Status { At, AtChild(usize), Exiting, + AftExiting, } #[cfg_attr(feature = "std", derive(Debug))] @@ -62,6 +63,7 @@ impl Crumb { (Status::AtChild(x), NodePlan::NibbledBranch { .. }) if !fwd && x > 0 => Status::AtChild(x - 1), + (Status::Exiting, _) => Status::AftExiting, _ => Status::Exiting, } } @@ -179,7 +181,7 @@ impl TrieDBRawIterator { NodePlan::Extension { partial: partial_plan, child } => { let slice = partial_plan.build(node_data); if !partial.starts_with(&slice) { - if slice < partial { + if (fwd && slice < partial) || (!fwd && slice > partial) { crumb.status = Status::Exiting; self.key_nibbles.append_partial(slice.right()); return Ok(false); @@ -227,7 +229,7 @@ impl TrieDBRawIterator { NodePlan::NibbledBranch { partial: partial_plan, value: _, children } => { let slice = partial_plan.build(node_data); if !partial.starts_with(&slice) { - if slice < partial { + if (fwd && slice < partial) || (!fwd && slice > partial) { crumb.status = Status::Exiting; self.key_nibbles.append_partial(slice.right()); self.key_nibbles.push((nibble_ops::NIBBLE_LENGTH - 1) as u8); @@ -385,11 +387,17 @@ impl TrieDBRawIterator { let node_data = crumb.node.data(); match (crumb.status, crumb.node.node_plan()) { - (Status::Entering, _) => { - // This is only necessary due to current borrow checker's limitation. - let crumb = self.trail.last_mut().expect("we've just fetched the last element using `last_mut` so this cannot fail; qed"); - crumb.step(fwd); - return Some(Ok((&self.key_nibbles, crumb.hash.as_ref(), &crumb.node))); + (Status::Entering, _) => + if fwd { + let crumb = self.trail.last_mut().expect("we've just fetched the last element using `last_mut` so this cannot fail; qed"); + crumb.step(fwd); + return Some(Ok((&self.key_nibbles, crumb.hash.as_ref(), &crumb.node))); + } else { + crumb.step(fwd); + }, + (Status::AftExiting, _) => { + self.trail.pop().expect("we've just fetched the last element using `last_mut` so this cannot fail; qed"); + self.trail.last_mut()?.step(fwd); }, (Status::Exiting, node) => { match node { @@ -404,8 +412,11 @@ impl TrieDBRawIterator { self.key_nibbles.drop_lasts(partial.len() + 1); }, } - self.trail.pop().expect("we've just fetched the last element using `last_mut` so this cannot fail; qed"); self.trail.last_mut()?.step(fwd); + if !fwd { + let crumb = self.trail.last_mut().expect("we've just fetched the last element using `last_mut` so this cannot fail; qed"); + return Some(Ok((&self.key_nibbles, crumb.hash.as_ref(), &crumb.node))); + } }, (Status::At, NodePlan::Extension { partial: partial_plan, child }) => { let partial = partial_plan.build(node_data); diff --git a/trie-db/test/src/double_ended_iterator.rs b/trie-db/test/src/double_ended_iterator.rs index dcb83a0d..59c06700 100644 --- a/trie-db/test/src/double_ended_iterator.rs +++ b/trie-db/test/src/double_ended_iterator.rs @@ -37,10 +37,9 @@ fn node_double_ended_iterator() { if T::USE_EXTENSION { match iter.next_back() { Some(Ok((prefix, Some(_), node))) => { - assert_eq!(prefix, nibble_vec(hex!(""), 0)); + assert_eq!(prefix, nibble_vec(hex!("02"), 2)); match node.node() { - Node::Extension(partial, _) => - assert_eq!(partial, NibbleSlice::new_offset(&hex!("00")[..], 1)), + Node::Leaf(partial, _) => assert_eq!(partial, NibbleSlice::new(&hex!("")[..])), _ => panic!("unexpected node"), } }, @@ -48,20 +47,22 @@ fn node_double_ended_iterator() { } match iter.next_back() { - Some(Ok((prefix, Some(_), node))) => { - assert_eq!(prefix, nibble_vec(hex!("00"), 1)); + Some(Ok((prefix, None, node))) => { + assert_eq!(prefix, nibble_vec(hex!("0120"), 3)); match node.node() { - Node::Branch(_, _) => {}, + Node::Leaf(partial, _) => + assert_eq!(partial, NibbleSlice::new_offset(&hex!("03")[..], 1)), _ => panic!("unexpected node"), } }, _ => panic!("unexpected item"), } + match iter.next_back() { - Some(Ok((prefix, Some(_), node))) => { - assert_eq!(prefix, nibble_vec(hex!("02"), 2)); + Some(Ok((prefix, None, node))) => { + assert_eq!(prefix, nibble_vec(hex!("01"), 2)); match node.node() { - Node::Leaf(partial, _) => assert_eq!(partial, NibbleSlice::new(&hex!("")[..])), + Node::Branch(_, _) => {}, _ => panic!("unexpected node"), } }, @@ -69,8 +70,8 @@ fn node_double_ended_iterator() { } match iter.next_back() { - Some(Ok((prefix, None, node))) => { - assert_eq!(prefix, nibble_vec(hex!("01"), 2)); + Some(Ok((prefix, Some(_), node))) => { + assert_eq!(prefix, nibble_vec(hex!("00"), 1)); match node.node() { Node::Branch(_, _) => {}, _ => panic!("unexpected node"), @@ -80,11 +81,11 @@ fn node_double_ended_iterator() { } match iter.next_back() { - Some(Ok((prefix, None, node))) => { - assert_eq!(prefix, nibble_vec(hex!("0120"), 3)); + Some(Ok((prefix, Some(_), node))) => { + assert_eq!(prefix, nibble_vec(hex!(""), 0)); match node.node() { - Node::Leaf(partial, _) => - assert_eq!(partial, NibbleSlice::new_offset(&hex!("03")[..], 1)), + Node::Extension(partial, _) => + assert_eq!(partial, NibbleSlice::new_offset(&hex!("00")[..], 1)), _ => panic!("unexpected node"), } }, @@ -98,22 +99,24 @@ fn node_double_ended_iterator() { match iter.next_back() { Some(Ok((prefix, Some(_), node))) => { - assert_eq!(prefix, nibble_vec(hex!(""), 0)); + assert_eq!(prefix, nibble_vec(hex!("02"), 2)); match node.node() { - Node::NibbledBranch(partial, _, _) => - assert_eq!(partial, NibbleSlice::new_offset(&hex!("00")[..], 1)), + Node::Leaf(partial, _) => assert_eq!(partial, NibbleSlice::new(&hex!("")[..])), _ => panic!("unexpected node"), } }, _ => panic!("unexpected item"), } - // Start from the last element and move backwards match iter.next_back() { - Some(Ok((prefix, Some(_), node))) => { - assert_eq!(prefix, nibble_vec(hex!("02"), 2)); + Some(Ok((prefix, hash, node))) => { + if !can_expand { + assert!(hash.is_none()); + } + assert_eq!(prefix, nibble_vec(hex!("0120"), 3)); match node.node() { - Node::Leaf(partial, _) => assert_eq!(partial, NibbleSlice::new(&hex!("")[..])), + Node::Leaf(partial, _) => + assert_eq!(partial, NibbleSlice::new_offset(&hex!("03")[..], 1)), _ => panic!("unexpected node"), } }, @@ -128,7 +131,7 @@ fn node_double_ended_iterator() { assert_eq!(prefix, nibble_vec(hex!("01"), 2)); match node.node() { Node::NibbledBranch(partial, _, _) => - assert_eq!(partial, NibbleSlice::new(&hex!("")[..])), + assert_eq!(partial, NibbleSlice::new_offset(&hex!("")[..], 0)), _ => panic!("unexpected node"), } }, @@ -136,14 +139,11 @@ fn node_double_ended_iterator() { } match iter.next_back() { - Some(Ok((prefix, hash, node))) => { - if !can_expand { - assert!(hash.is_none()); - } - assert_eq!(prefix, nibble_vec(hex!("0120"), 3)); + Some(Ok((prefix, Some(_), node))) => { + assert_eq!(prefix, nibble_vec(hex!(""), 0)); match node.node() { - Node::Leaf(partial, _) => - assert_eq!(partial, NibbleSlice::new_offset(&hex!("03")[..], 1)), + Node::NibbledBranch(partial, _, _) => + assert_eq!(partial, NibbleSlice::new_offset(&hex!("00")[..], 1)), _ => panic!("unexpected node"), } }, @@ -172,8 +172,19 @@ fn seek_back_over_empty_works_internal() { _ => panic!("unexpected item"), } - >::seek(&mut iter, &hex!("00")[..]).unwrap(); assert!(iter.next_back().is_none()); + + >::seek(&mut iter, &hex!("00")[..]).unwrap(); + match iter.next_back() { + Some(Ok((prefix, _, node))) => { + assert_eq!(prefix, nibble_vec(hex!(""), 0)); + match node.node() { + Node::Empty => {}, + _ => panic!("unexpected node"), + } + }, + _ => panic!("unexpected item"), + } } test_layouts!(seek_back_works, seek_back_works_internal); @@ -208,6 +219,27 @@ fn seek_back_works_internal() { } >::seek(&mut iter, &hex!("01")[..]).unwrap(); + match iter.next_back() { + Some(Ok((prefix, _, _))) => { + assert_eq!(prefix, nibble_vec(hex!("0123"), 4)); + }, + _ => panic!("unexpected item"), + } + + match iter.next_back() { + Some(Ok((prefix, _, _))) => { + assert_eq!(prefix, nibble_vec(hex!("0122"), 4)); + }, + _ => panic!("unexpected item"), + } + + match iter.next_back() { + Some(Ok((prefix, _, _))) => { + assert_eq!(prefix, nibble_vec(hex!("0120"), 3)); + }, + _ => panic!("unexpected item"), + } + match iter.next_back() { Some(Ok((prefix, _, _))) => { assert_eq!(prefix, nibble_vec(hex!("01"), 2)); @@ -231,7 +263,19 @@ fn seek_back_works_internal() { } >::seek(&mut iter, &hex!("0120")[..]).unwrap(); - assert!(iter.next_back().is_none()); + match iter.next_back() { + Some(Ok((prefix, _, _))) => { + assert_eq!(prefix, nibble_vec(hex!("0120"), 3)); + }, + _ => panic!("unexpected item"), + } + + match iter.next_back() { + Some(Ok((prefix, _, _))) => { + assert_eq!(prefix, nibble_vec(hex!("01"), 2)); + }, + _ => panic!("unexpected item"), + } } test_layouts!(prefix_back_works, prefix_back_works_internal); @@ -253,9 +297,11 @@ fn prefix_back_works_internal() { if T::USE_EXTENSION { match iter.next_back() { Some(Ok((prefix, None, node))) => { - assert_eq!(prefix, nibble_vec(hex!("01"), 2)); + assert_eq!(prefix, nibble_vec(hex!("0123"), 4)); match node.node() { - Node::Branch(_, _) => {}, + Node::Leaf(partial, _) => { + assert_eq!(partial, NibbleSlice::new_offset(&hex!("")[..], 0)) + }, _ => panic!("unexpected node"), } }, @@ -267,10 +313,11 @@ fn prefix_back_works_internal() { if !can_expand { debug_assert!(hash.is_none()); } - assert_eq!(prefix, nibble_vec(hex!("01"), 2)); + assert_eq!(prefix, nibble_vec(hex!("0123"), 4)); match node.node() { - Node::NibbledBranch(partial, _, _) => - assert_eq!(partial, NibbleSlice::new_offset(&hex!("")[..], 0)), + Node::Leaf(partial, _) => { + assert_eq!(partial, NibbleSlice::new_offset(&hex!("")[..], 0)) + }, _ => panic!("unexpected node"), } }, @@ -283,11 +330,11 @@ fn prefix_back_works_internal() { if !can_expand { debug_assert!(hash.is_none()); } - assert_eq!(prefix, nibble_vec(hex!("0120"), 3)); + assert_eq!(prefix, nibble_vec(hex!("0122"), 4)); match node.node() { - Node::NibbledBranch(partial, _, _) => - assert_eq!(partial, NibbleSlice::new(&hex!("")[..])), - Node::Branch(_, _) => {}, + Node::Leaf(partial, _) => { + assert_eq!(partial, NibbleSlice::new_offset(&hex!("")[..], 0)) + }, _ => panic!("unexpected node"), } }, @@ -299,11 +346,11 @@ fn prefix_back_works_internal() { if !can_expand { debug_assert!(hash.is_none()); } - assert_eq!(prefix, nibble_vec(hex!("0123"), 4)); + assert_eq!(prefix, nibble_vec(hex!("0120"), 3)); match node.node() { - Node::Leaf(partial, _) => { - assert_eq!(partial, NibbleSlice::new_offset(&hex!("")[..], 0)) - }, + Node::NibbledBranch(partial, _, _) => + assert_eq!(partial, NibbleSlice::new_offset(&hex!("")[..], 0)), + Node::Branch(_, _) => {}, _ => panic!("unexpected node"), } }, @@ -315,11 +362,11 @@ fn prefix_back_works_internal() { if !can_expand { debug_assert!(hash.is_none()); } - assert_eq!(prefix, nibble_vec(hex!("0122"), 4)); + assert_eq!(prefix, nibble_vec(hex!("01"), 2)); match node.node() { - Node::Leaf(partial, _) => { - assert_eq!(partial, NibbleSlice::new_offset(&hex!("")[..], 0)) - }, + Node::NibbledBranch(partial, _, _) => + assert_eq!(partial, NibbleSlice::new_offset(&hex!("")[..], 0)), + Node::Branch(_, _) => {}, _ => panic!("unexpected node"), } },