Add commit_changes_bytes() method to Db (#248)

* Don't expose RcValue's Vec<u8>

Also, make RcKey a distinct type.

* Add commit_changes_bytes()

Only when "bytes" feature is enabled.

Also make commit_changes_shared() only available when "arc" feature is
enabled.

Author: zdave-parity

Cargo.toml

@@ -9,11 +9,14 @@ repository = "https://github.com/paritytech/parity-db/"
 description = "Key-value database for the blockchain"
 
 [features]
+default = ["arc"]
 instrumentation = []
 bench = []
+arc = []
 
 [dependencies]
 blake2 = "0.10.6"
+bytes = { version = "1.7.1", optional = true }
 crc32fast = "1.4.2"
 fs2 = "0.4.3"
 hex = "0.4.3"

src/btree/iter.rs

@@ -147,38 +147,38 @@ impl<'a> BTreeIterator<'a> {
 			};
 			let result = match (next_commit_overlay, next_backend) {
 				(Some((commit_key, commit_value)), Some((backend_key, backend_value))) => {
-					match (direction, commit_key.value().cmp(&backend_key)) {
+					match (direction, commit_key.as_ref().cmp(&backend_key)) {
 						(IterDirection::Backward, std::cmp::Ordering::Greater) |
 						(IterDirection::Forward, std::cmp::Ordering::Less) => {
 							self.pending_backend = Some(PendingBackend {
 								next_item: Some((backend_key, backend_value)),
 								direction,
 							});
 							if let Some(value) = commit_value {
-								Some((commit_key.value().clone(), value.value().clone()))
+								Some((commit_key.as_ref().to_vec(), value.as_ref().to_vec()))
 							} else {
-								self.last_key = LastKey::At(commit_key.value().clone());
+								self.last_key = LastKey::At(commit_key.as_ref().to_vec());
 								continue
 							}
 						},
 						(IterDirection::Backward, std::cmp::Ordering::Less) |
 						(IterDirection::Forward, std::cmp::Ordering::Greater) => Some((backend_key, backend_value)),
 						(_, std::cmp::Ordering::Equal) =>
 							if let Some(value) = commit_value {
-								Some((backend_key, value.value().clone()))
+								Some((backend_key, value.as_ref().to_vec()))
 							} else {
-								self.last_key = LastKey::At(commit_key.value().clone());
+								self.last_key = LastKey::At(commit_key.as_ref().to_vec());
 								continue
 							},
 					}
 				},
 				(Some((commit_key, Some(commit_value))), None) => {
 					self.pending_backend = Some(PendingBackend { next_item: None, direction });
-					Some((commit_key.value().clone(), commit_value.value().clone()))
+					Some((commit_key.as_ref().to_vec(), commit_value.as_ref().to_vec()))
 				},
 				(Some((k, None)), None) => {
 					self.pending_backend = Some(PendingBackend { next_item: None, direction });
-					self.last_key = LastKey::At(k.value().clone());
+					self.last_key = LastKey::At(k.as_ref().to_vec());
 					continue
 				},
 				(None, Some((backend_key, backend_value))) => Some((backend_key, backend_value)),

src/btree/mod.rs

@@ -414,16 +414,16 @@ pub mod commit_overlay {
 			for change in self.changes.iter() {
 				match change {
 					Operation::Set(key, value) => {
-						*bytes += key.value().len();
-						*bytes += value.value().len();
+						*bytes += key.as_ref().len();
+						*bytes += value.as_ref().len();
 						overlay.insert(key.clone(), (record_id, Some(value.clone())));
 					},
 					Operation::Dereference(key) => {
 						// Don't add removed ref-counted values to overlay.
 						// (current ref_counted implementation does not
 						// make much sense for btree indexed content).
 						if !ref_counted {
-							*bytes += key.value().len();
+							*bytes += key.as_ref().len();
 							overlay.insert(key.clone(), (record_id, None));
 						}
 					},

src/btree/node.rs

@@ -71,7 +71,7 @@ impl Node {
 			}
 			let r = match &changes[0] {
 				Operation::Set(key, value) =>
-					self.insert(depth, key.value(), value.value(), changes, btree, log)?,
+					self.insert(depth, key.as_ref(), value.as_ref(), changes, btree, log)?,
 				_ => self.on_existing(depth, changes, btree, log)?,
 			};
 			if r.0.is_some() || r.1 {
@@ -82,12 +82,12 @@ impl Node {
 			}
 			if let Some((parent, p)) = &parent {
 				let key = &changes[1].key();
-				let (at, i) = self.position(key.value())?; // TODO could start position from current
+				let (at, i) = self.position(key.as_ref())?; // TODO could start position from current
 				if at || i < self.number_separator() {
 					*changes = &changes[1..];
 					continue
 				}
-				let (at, i) = parent.position(key.value())?;
+				let (at, i) = parent.position(key.as_ref())?;
 				if !at && &i == p && i < parent.number_separator() {
 					*changes = &changes[1..];
 					continue
@@ -243,7 +243,7 @@ impl Node {
 		let change = &changes[0];
 		let key = change.key();
 		let has_child = depth != 0;
-		let (at, i) = self.position(key.value())?;
+		let (at, i) = self.position(key.as_ref())?;
 		if at {
 			let existing = self.separator_address(i);
 			if let Some(existing) = existing {

src/column.rs

@@ -426,7 +426,7 @@ pub fn unpack_node_data(data: Vec<u8>) -> Result<(Vec<u8>, Children)> {
 	Ok((data, children))
 }
 
-pub fn unpack_node_children(data: &Vec<u8>) -> Result<Children> {
+pub fn unpack_node_children(data: &[u8]) -> Result<Children> {
 	if data.len() == 0 {
 		return Err(Error::InvalidValueData)
 	}
@@ -1203,7 +1203,7 @@ impl HashColumn {
 
 		let stats = self.collect_stats.then_some(&self.stats);
 		if let Some(stats) = stats {
-			stats.insert_val(val_len, cval.value().len() as u32);
+			stats.insert_val(val_len, cval.as_ref().len() as u32);
 		}
 
 		Ok(PlanOutcome::Written)