fluidB
/
fluidb
1
0
Fork 0
Code Pull Requests Activity

optimize chaining

Browse Source
main
Ziyang Hu 2 years ago
parent 3adae6db13
commit 83b9e0852e
3 changed files with 86 additions and 54 deletions
Show Stats Download Patch File Download Diff File

43
cozo-rocks/src/lib.rs
Unescape Escape View File

@ -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<PinnableSliceBridge>;
pub type Slice = UniquePtr<SliceBridge>;
pub struct PinnableSlice(UniquePtr<PinnableSliceBridge>);
impl AsRef<[u8]> for PinnableSlice {
#[inline]
fn as_ref(&self) -> &[u8] {
self.0.as_bytes()
}
}
pub struct Slice(UniquePtr<SliceBridge>);
impl AsRef<[u8]> for Slice {
#[inline]
fn as_ref(&self) -> &[u8] {
self.0.as_bytes()
}
}
pub type Iterator = UniquePtr<IteratorBridge>;
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<WriteBatchBridge> {
self.bridge.write_batch()
}
#[inline]
pub fn create_column_family(&self, _name: impl AsRef<str>) -> Result<usize, Status> {
unimplemented!()
}
#[inline]
pub fn drop_column_family(&self, _name: impl AsRef<str>) -> Result<(), Status> {
unimplemented!()
}
pub fn destroy_data(self) -> Result<(), Status> {
unimplemented!()
}
}
impl Default for Status {

22
src/storage.rs
Unescape Escape View File

@ -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());
}
}

75
src/value.rs
Unescape Escape View File

@ -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<T: AsRef<[u8]>>(source: &'a T) -> Self {
Self { bytes: source.as_ref(), current: 0 }
}
#[inline]
@ -339,17 +339,24 @@ impl<'a> ByteArrayParser<'a> {
}
}
pub struct ByteArrayBuilder<T: Write> {
pub struct ByteArrayBuilder<T: Write + AsRef<[u8]>> {
byte_writer: T,
}
impl <T: Write + AsRef<[u8]>> AsRef<[u8]> for ByteArrayBuilder<T> {
fn as_ref(&self) -> &[u8] {
self.byte_writer.as_ref()
}
}
impl ByteArrayBuilder<Vec<u8>> {
pub fn default() -> Self { Self { byte_writer: vec![] } }
pub fn with_capacity(size: usize) -> Self {
Self::new(Vec::with_capacity(size))
}
}
impl<T: Write> ByteArrayBuilder<T> {
impl<T: Write + AsRef<[u8]>> ByteArrayBuilder<T> {
pub fn get(self) -> T {
self.byte_writer
}
@ -359,7 +366,7 @@ impl<T: Write> ByteArrayBuilder<T> {
}
#[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<T: Write> ByteArrayBuilder<T> {
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<T: Write> ByteArrayBuilder<T> {
(((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<T: Write> ByteArrayBuilder<T> {
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<Cow<str>, Value>) {
pub fn build_dict(&mut self, d: &BTreeMap<Cow<str>, 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);
}

Write Preview
Loading…
Cancel
Save