|
|
|
@ -56,7 +56,7 @@ impl DatabaseEngine for PersyEngine { |
|
|
|
// Create if it doesn't exist
|
|
|
|
// Create if it doesn't exist
|
|
|
|
if !self.persy.exists_index(name)? { |
|
|
|
if !self.persy.exists_index(name)? { |
|
|
|
let mut tx = self.persy.begin()?; |
|
|
|
let mut tx = self.persy.begin()?; |
|
|
|
tx.create_index::<ByteVec, ByteVec>(name, ValueMode::REPLACE)?; |
|
|
|
tx.create_index::<ByteVec, ByteVec>(name, ValueMode::Replace)?; |
|
|
|
tx.prepare()?.commit()?; |
|
|
|
tx.prepare()?.commit()?; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
@ -187,15 +187,15 @@ impl WriteCache { |
|
|
|
for (key, value) in changes { |
|
|
|
for (key, value) in changes { |
|
|
|
tx.put::<ByteVec, ByteVec>( |
|
|
|
tx.put::<ByteVec, ByteVec>( |
|
|
|
&index, |
|
|
|
&index, |
|
|
|
ByteVec(key.to_owned()), |
|
|
|
ByteVec::new(key.to_owned()), |
|
|
|
ByteVec(value.to_owned()), |
|
|
|
ByteVec::new(value.to_owned()), |
|
|
|
)?; |
|
|
|
)?; |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
self.add_cache.clear(); |
|
|
|
self.add_cache.clear(); |
|
|
|
for (index, changes) in &self.remove_cache { |
|
|
|
for (index, changes) in &self.remove_cache { |
|
|
|
for key in changes { |
|
|
|
for key in changes { |
|
|
|
tx.remove::<ByteVec, ByteVec>(&index, ByteVec(key.to_owned()), None)?; |
|
|
|
tx.remove::<ByteVec, ByteVec>(&index, ByteVec::new(key.to_owned()), None)?; |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
self.remove_cache.clear(); |
|
|
|
self.remove_cache.clear(); |
|
|
|
@ -356,9 +356,9 @@ impl Tree for PersyTree { |
|
|
|
fn get(&self, key: &[u8]) -> Result<Option<Vec<u8>>> { |
|
|
|
fn get(&self, key: &[u8]) -> Result<Option<Vec<u8>>> { |
|
|
|
let result = self |
|
|
|
let result = self |
|
|
|
.persy |
|
|
|
.persy |
|
|
|
.get::<ByteVec, ByteVec>(&self.name, &ByteVec(key.to_vec()))? |
|
|
|
.get::<ByteVec, ByteVec>(&self.name, &ByteVec::new(key.to_vec()))? |
|
|
|
.map(|v| v.into_iter().map(|bv| bv.0).next()) |
|
|
|
.next() |
|
|
|
.flatten(); |
|
|
|
.map(|v| (*v).to_owned()); |
|
|
|
let result = self |
|
|
|
let result = self |
|
|
|
.write_cache |
|
|
|
.write_cache |
|
|
|
.read() |
|
|
|
.read() |
|
|
|
@ -396,7 +396,6 @@ impl Tree for PersyTree { |
|
|
|
Ok(()) |
|
|
|
Ok(()) |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
#[tracing::instrument(skip(self, iter))] |
|
|
|
|
|
|
|
fn insert_batch<'a>(&self, iter: &mut dyn Iterator<Item = (Vec<u8>, Vec<u8>)>) -> Result<()> { |
|
|
|
fn insert_batch<'a>(&self, iter: &mut dyn Iterator<Item = (Vec<u8>, Vec<u8>)>) -> Result<()> { |
|
|
|
//TODO: evaluate if use instead a single big transaction
|
|
|
|
//TODO: evaluate if use instead a single big transaction
|
|
|
|
for (key, value) in iter { |
|
|
|
for (key, value) in iter { |
|
|
|
@ -406,6 +405,13 @@ impl Tree for PersyTree { |
|
|
|
Ok(()) |
|
|
|
Ok(()) |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fn increment_batch<'a>(&self, iter: &mut dyn Iterator<Item = Vec<u8>>) -> Result<()> { |
|
|
|
|
|
|
|
for key in iter { |
|
|
|
|
|
|
|
self.increment(&key)?; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
Ok(()) |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
fn remove(&self, key: &[u8]) -> Result<()> { |
|
|
|
fn remove(&self, key: &[u8]) -> Result<()> { |
|
|
|
self.write_cache |
|
|
|
self.write_cache |
|
|
|
.write() |
|
|
|
.write() |
|
|
|
@ -420,7 +426,7 @@ impl Tree for PersyTree { |
|
|
|
Ok(iter) => { |
|
|
|
Ok(iter) => { |
|
|
|
let result = Box::new(iter.filter_map(|(k, v)| { |
|
|
|
let result = Box::new(iter.filter_map(|(k, v)| { |
|
|
|
v.into_iter() |
|
|
|
v.into_iter() |
|
|
|
.map(|val| (k.0.to_owned().into(), val.0.to_owned().into())) |
|
|
|
.map(|val| ((*k).to_owned().into(), (*val).to_owned().into())) |
|
|
|
.next() |
|
|
|
.next() |
|
|
|
})); |
|
|
|
})); |
|
|
|
|
|
|
|
|
|
|
|
@ -440,16 +446,16 @@ impl Tree for PersyTree { |
|
|
|
) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + 'a> { |
|
|
|
) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + 'a> { |
|
|
|
let range = if backwards { |
|
|
|
let range = if backwards { |
|
|
|
self.persy |
|
|
|
self.persy |
|
|
|
.range::<ByteVec, ByteVec, _>(&self.name, ..ByteVec(from.to_owned())) |
|
|
|
.range::<ByteVec, ByteVec, _>(&self.name, ..ByteVec::new(from.to_owned())) |
|
|
|
} else { |
|
|
|
} else { |
|
|
|
self.persy |
|
|
|
self.persy |
|
|
|
.range::<ByteVec, ByteVec, _>(&self.name, ByteVec(from.to_owned())..) |
|
|
|
.range::<ByteVec, ByteVec, _>(&self.name, ByteVec::new(from.to_owned())..) |
|
|
|
}; |
|
|
|
}; |
|
|
|
match range { |
|
|
|
match range { |
|
|
|
Ok(iter) => { |
|
|
|
Ok(iter) => { |
|
|
|
let map = iter.filter_map(|(k, v)| { |
|
|
|
let map = iter.filter_map(|(k, v)| { |
|
|
|
v.into_iter() |
|
|
|
v.into_iter() |
|
|
|
.map(|val| (k.0.to_owned().into(), val.0.to_owned().into())) |
|
|
|
.map(|val| ((*k).to_owned().into(), (*val).to_owned().into())) |
|
|
|
.next() |
|
|
|
.next() |
|
|
|
}); |
|
|
|
}); |
|
|
|
let result: Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + Send + 'a> = if backwards |
|
|
|
let result: Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + Send + 'a> = if backwards |
|
|
|
@ -482,7 +488,7 @@ impl Tree for PersyTree { |
|
|
|
&'a self, |
|
|
|
&'a self, |
|
|
|
prefix: Vec<u8>, |
|
|
|
prefix: Vec<u8>, |
|
|
|
) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + 'a> { |
|
|
|
) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + 'a> { |
|
|
|
let range_prefix = ByteVec(prefix.to_owned()); |
|
|
|
let range_prefix = ByteVec::new(prefix.to_owned()); |
|
|
|
let range = self |
|
|
|
let range = self |
|
|
|
.persy |
|
|
|
.persy |
|
|
|
.range::<ByteVec, ByteVec, _>(&self.name, range_prefix..); |
|
|
|
.range::<ByteVec, ByteVec, _>(&self.name, range_prefix..); |
|
|
|
@ -491,10 +497,10 @@ impl Tree for PersyTree { |
|
|
|
Ok(iter) => { |
|
|
|
Ok(iter) => { |
|
|
|
let owned_prefix = prefix.clone(); |
|
|
|
let owned_prefix = prefix.clone(); |
|
|
|
let result = Box::new( |
|
|
|
let result = Box::new( |
|
|
|
iter.take_while(move |(k, _)| k.0.starts_with(&owned_prefix)) |
|
|
|
iter.take_while(move |(k, _)| (*k).starts_with(&owned_prefix)) |
|
|
|
.filter_map(|(k, v)| { |
|
|
|
.filter_map(|(k, v)| { |
|
|
|
v.into_iter() |
|
|
|
v.into_iter() |
|
|
|
.map(|val| (k.0.to_owned().into(), val.0.to_owned().into())) |
|
|
|
.map(|val| ((*k).to_owned().into(), (*val).to_owned().into())) |
|
|
|
.next() |
|
|
|
.next() |
|
|
|
}), |
|
|
|
}), |
|
|
|
); |
|
|
|
); |
|
|
|
|