From 83b9e0852e9d9180e6695321cc5a425b041940ef Mon Sep 17 00:00:00 2001 From: Ziyang Hu Date: Fri, 15 Apr 2022 13:17:04 +0800 Subject: [PATCH] optimize chaining --- cozo-rocks/src/lib.rs | 43 +++++++++++++++++++++---- src/storage.rs | 22 ++++++------- src/value.rs | 75 +++++++++++++++++++++++-------------------- 3 files changed, 86 insertions(+), 54 deletions(-) diff --git a/cozo-rocks/src/lib.rs b/cozo-rocks/src/lib.rs index c7c41912..4e1b8bc6 100644 --- a/cozo-rocks/src/lib.rs +++ b/cozo-rocks/src/lib.rs @@ -2,9 +2,9 @@ mod ffi { #[derive(Copy, Clone, Debug, Eq, PartialEq)] pub struct Status { - code: StatusCode, - subcode: StatusSubCode, - severity: StatusSeverity, + pub code: StatusCode, + pub subcode: StatusSubCode, + pub severity: StatusSeverity, } #[derive(Copy, Clone, Debug, Eq, PartialEq)] @@ -207,8 +207,25 @@ impl WriteOptionsTrait for WriteOptions { } } -pub type PinnableSlice = UniquePtr; -pub type Slice = UniquePtr; +pub struct PinnableSlice(UniquePtr); + +impl AsRef<[u8]> for PinnableSlice { + #[inline] + fn as_ref(&self) -> &[u8] { + self.0.as_bytes() + } +} + +pub struct Slice(UniquePtr); + +impl AsRef<[u8]> for Slice { + #[inline] + fn as_ref(&self) -> &[u8] { + self.0.as_bytes() + } +} + + pub type Iterator = UniquePtr; pub trait IteratorTrait { @@ -294,7 +311,7 @@ impl DB { options.unwrap_or(&self.default_read_options), cf, key.as_ref(), &mut status); match status.code { - StatusCode::kOk => Ok(Some(slice)), + StatusCode::kOk => Ok(Some(PinnableSlice(slice))), StatusCode::kNotFound => Ok(None), _ => Err(status) } @@ -309,6 +326,20 @@ impl DB { pub fn write_batch(&self) -> UniquePtr { self.bridge.write_batch() } + + #[inline] + pub fn create_column_family(&self, _name: impl AsRef) -> Result { + unimplemented!() + } + + #[inline] + pub fn drop_column_family(&self, _name: impl AsRef) -> Result<(), Status> { + unimplemented!() + } + + pub fn destroy_data(self) -> Result<(), Status> { + unimplemented!() + } } impl Default for Status { diff --git a/src/storage.rs b/src/storage.rs index cd6bc7a5..770e6aa0 100644 --- a/src/storage.rs +++ b/src/storage.rs @@ -72,31 +72,27 @@ mod tests { let db = DB::open(options, "xxyyzz.db").unwrap(); - let mut x = vec![]; - let mut builder = ByteArrayBuilder::new(&mut x); + let mut builder = ByteArrayBuilder::default(); builder.build_value(&Value::RefString("A key")); - let key = builder.get(); + let key = builder; - let mut x = vec![]; - let mut builder = ByteArrayBuilder::new(&mut x); + let mut builder = ByteArrayBuilder::default(); builder.build_value(&Value::RefString("Another key")); - let key2 = builder.get(); + let key2 = builder; let val = db.get(&key, 0, None).unwrap(); - // let val = val.as_bytes(); println!("before anything {}", val.is_none()); db.put(&key, "A motherfucking value!!! 👋👋👋", 0, None).unwrap(); db.put(&key2, "Another motherfucking value!!! 👋👋👋", 0, None).unwrap(); // db.put("Yes man", "A motherfucking value!!! 👋👋👋", None).unwrap(); let val = db.get(&key, 0, None).unwrap().unwrap(); - let val = val.as_bytes(); - println!("{}", from_utf8(val).unwrap()); + println!("1 {}", from_utf8(val.as_ref()).unwrap()); let val = db.get(&key2, 0, None).unwrap().unwrap(); - let val = val.as_bytes(); - println!("{}", from_utf8(val).unwrap()); + // let val = val.as_bytes(); + println!("2 {}", from_utf8(val.as_ref()).unwrap()); let val = db.get(&key, 0, None).unwrap().unwrap(); - let val = val.as_bytes(); - println!("{}", from_utf8(val).unwrap()); + println!("3 {}", from_utf8(val.as_ref()).unwrap()); + println!("4 {}", from_utf8(db.get(&key, 0, None).unwrap().unwrap().as_ref()).unwrap()); } } \ No newline at end of file diff --git a/src/value.rs b/src/value.rs index 65aef352..d566ed1b 100644 --- a/src/value.rs +++ b/src/value.rs @@ -1,4 +1,4 @@ -use std::borrow::Cow; +use std::borrow::{Cow}; use std::cmp::{min, Ordering}; use std::collections::{BTreeMap}; use std::io::{Write}; @@ -116,8 +116,8 @@ pub struct ByteArrayParser<'a> { } impl<'a> ByteArrayParser<'a> { - pub fn new(bytes: &'a [u8]) -> Self { - Self { bytes, current: 0 } + pub fn new>(source: &'a T) -> Self { + Self { bytes: source.as_ref(), current: 0 } } #[inline] @@ -339,17 +339,24 @@ impl<'a> ByteArrayParser<'a> { } } -pub struct ByteArrayBuilder { +pub struct ByteArrayBuilder> { byte_writer: T, } +impl > AsRef<[u8]> for ByteArrayBuilder { + fn as_ref(&self) -> &[u8] { + self.byte_writer.as_ref() + } +} + impl ByteArrayBuilder> { + pub fn default() -> Self { Self { byte_writer: vec![] } } pub fn with_capacity(size: usize) -> Self { Self::new(Vec::with_capacity(size)) } } -impl ByteArrayBuilder { +impl> ByteArrayBuilder { pub fn get(self) -> T { self.byte_writer } @@ -359,7 +366,7 @@ impl ByteArrayBuilder { } #[inline] - pub fn build_varint(&mut self, u: u64) { + pub fn build_varint(&mut self, u: u64) -> &mut Self { let mut u = u; while u > 0b01111111 { self.byte_writer.write_all(&[0b10000000 | (u as u8 & 0b01111111)]).expect( @@ -370,10 +377,11 @@ impl ByteArrayBuilder { self.byte_writer.write_all(&[u as u8]).expect( "Failed to write when building Varint" ); + self } #[inline] - pub fn build_zigzag(&mut self, i: i64) { + pub fn build_zigzag(&mut self, i: i64) -> &mut Self { let u: u64 = if i >= 0 { (i as u64) << 1 } else { @@ -381,34 +389,39 @@ impl ByteArrayBuilder { (((i + 1).abs() as u64) << 1) + 1 }; self.build_varint(u); + self } #[inline] - pub fn build_float(&mut self, f: f64) { + pub fn build_float(&mut self, f: f64) -> &mut Self { self.byte_writer.write_all(&f.to_be_bytes()).expect( "Failed to write when building Float" ); + self } #[inline] - pub fn build_uuid(&mut self, u: Uuid) { + pub fn build_uuid(&mut self, u: Uuid) -> &mut Self { self.byte_writer.write_all(u.as_bytes()).expect( "Failed to write when building Uuid" ); + self } #[inline] - pub fn build_string(&mut self, s: &str) { + pub fn build_string(&mut self, s: &str) -> &mut Self { self.build_varint(s.len() as u64); self.byte_writer.write_all(s.as_bytes()).expect("Failed to write when building String"); + self } #[inline] - pub fn build_tag(&mut self, t: ValueTag) { + pub fn build_tag(&mut self, t: ValueTag) -> &mut Self { self.byte_writer.write_all(&[t as u8]).expect("Failed to write when building Tag"); + self } - pub fn build_value(&mut self, v: &Value) { + pub fn build_value(&mut self, v: &Value) -> &mut Self{ use ValueTag::*; match v { @@ -419,53 +432,46 @@ impl ByteArrayBuilder { EdgeDirKind::BwdEdgeDir => { BwdEdgeTag } }), Value::UInt(u) => { - self.build_tag(UIntTag); - self.build_varint(*u); + self.build_tag(UIntTag).build_varint(*u) } Value::Int(i) => { - self.build_tag(IntTag); - self.build_zigzag(*i); + self.build_tag(IntTag).build_zigzag(*i) } Value::Float(f) => { - self.build_tag(FloatTag); - self.build_float(*f); + self.build_tag(FloatTag).build_float(*f) } Value::OwnString(s) => { - self.build_tag(StringTag); - self.build_string(s); + self.build_tag(StringTag).build_string(s) } Value::RefString(s) => { - self.build_tag(StringTag); - self.build_string(s); + self.build_tag(StringTag).build_string(s) } Value::List(l) => { - self.build_tag(ListTag); - self.build_list(l); + self.build_tag(ListTag).build_list(l) } Value::Dict(d) => { - self.build_tag(DictTag); - self.build_dict(d); + self.build_tag(DictTag).build_dict(d) } Value::Uuid(u) => { - self.build_tag(UuidTag); - self.build_uuid(*u); + self.build_tag(UuidTag).build_uuid(*u) } } } - pub fn build_list(&mut self, l: &[Value]) { + pub fn build_list(&mut self, l: &[Value]) -> &mut Self { self.build_varint(l.len() as u64); for el in l { self.build_value(el); } + self } - pub fn build_dict(&mut self, d: &BTreeMap, Value>) { + pub fn build_dict(&mut self, d: &BTreeMap, Value>) -> &mut Self { self.build_varint(d.len() as u64); for (k, v) in d { - self.build_string(k); - self.build_value(v); + self.build_string(k).build_value(v); } + self } } @@ -579,10 +585,9 @@ mod tests { #[test] fn zigzag() { for i in 126..(2i64).pow(9) { - let mut x = vec![]; - let mut builder = ByteArrayBuilder::new(&mut x); + let mut builder = ByteArrayBuilder::default(); builder.build_zigzag(i); - let mut parser = ByteArrayParser::new(&x); + let mut parser = ByteArrayParser::new(&builder); let i2 = parser.parse_zigzag().unwrap(); assert_eq!(i, i2); }