fluidB
/
fluidb
1
0
Fork 0
Code Pull Requests Activity

make cf creation/deletion thread-safe

Browse Source
main
Ziyang Hu 2 years ago
parent fe44c00e3d
commit cc60909a70
8 changed files with 76 additions and 79 deletions
Show Stats Download Patch File Download Diff File

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

@ -131,7 +131,7 @@ mod ffi {
use std::fmt::Formatter;
use std::fmt::Debug;
use std::path::Path;
use cxx::{UniquePtr, SharedPtr, let_cxx_string, CxxString};
use cxx::{UniquePtr, SharedPtr, let_cxx_string};
pub use ffi::BridgeStatus;
pub use ffi::StatusBridgeCode;
pub use ffi::StatusCode;

8
src/ast.rs
Unescape Escape View File

@ -1,4 +1,4 @@
use std::sync::Arc;
use std::rc::Rc;
use pest::iterators::{Pair};
use pest::Parser as PestParser;
use pest::prec_climber::{Assoc, PrecClimber, Operator};
@ -194,7 +194,7 @@ fn build_expr_primary(pair: Pair<Rule>) -> Result<Expr> {
Rule::null => Ok(Const(Value::Null)),
Rule::boolean => Ok(Const(Value::Bool(pair.as_str() == "true"))),
Rule::quoted_string | Rule::s_quoted_string | Rule::raw_string => Ok(
Const(Value::OwnString(Arc::new(parse_string(pair)?)))),
Const(Value::OwnString(Rc::new(parse_string(pair)?)))),
Rule::list => {
let mut vals = vec![];
let mut has_apply = false;
@ -211,7 +211,7 @@ fn build_expr_primary(pair: Pair<Rule>) -> Result<Expr> {
if has_apply {
Ok(Expr::List(vals))
} else {
Ok(Const(Value::List(Arc::new(vals.into_iter().map(|v| {
Ok(Const(Value::List(Rc::new(vals.into_iter().map(|v| {
match v {
Apply(_, _) => { unreachable!() }
Expr::List(_) => { unreachable!() }
@ -249,7 +249,7 @@ fn build_expr_primary(pair: Pair<Rule>) -> Result<Expr> {
if has_apply {
Ok(Expr::Dict(keys, vals))
} else {
Ok(Const(Value::Dict(Arc::new(keys.into_iter().zip(vals.into_iter()).map(|(k, v)| {
Ok(Const(Value::Dict(Rc::new(keys.into_iter().zip(vals.into_iter()).map(|(k, v)| {
match v {
Expr::List(_) => { unreachable!() }
Expr::Dict(_, _) => { unreachable!() }

26
src/definition.rs
Unescape Escape View File

@ -1,5 +1,5 @@
use std::collections::BTreeMap;
use std::sync::Arc;
use std::rc::Rc;
use pest::iterators::{Pair, Pairs};
use crate::ast::parse_string;
use crate::env::{Env, LayeredEnv, StructuredEnvItem};
@ -413,17 +413,17 @@ impl RocksStorage {
key_writer.build_value(&Value::RefString(&node.id.name));
let mut val_writer = ByteArrayBuilder::with_capacity(128);
val_writer.build_value(&Value::UInt(TableKind::Node as u64));
val_writer.build_value(&Value::List(Arc::new(node.keys.iter().map(|k| {
Value::List(Arc::new(vec![
val_writer.build_value(&Value::List(Rc::new(node.keys.iter().map(|k| {
Value::List(Rc::new(vec![
Value::RefString(&k.name),
Value::OwnString(Arc::new(format!("{}", k.typ))),
Value::OwnString(Rc::new(format!("{}", k.typ))),
k.default.clone(),
]))
}).collect())));
val_writer.build_value(&Value::List(Arc::new(node.cols.iter().map(|k| {
Value::List(Arc::new(vec![
val_writer.build_value(&Value::List(Rc::new(node.cols.iter().map(|k| {
Value::List(Rc::new(vec![
Value::RefString(&k.name),
Value::OwnString(Arc::new(format!("{}", k.typ))),
Value::OwnString(Rc::new(format!("{}", k.typ))),
k.default.clone(),
]))
}).collect())));
@ -442,17 +442,17 @@ impl RocksStorage {
val_writer.build_value(&Value::UInt(TableKind::Edge as u64));
val_writer.build_value(&Value::RefString(&edge.src.name));
val_writer.build_value(&Value::RefString(&edge.dst.name));
val_writer.build_value(&Value::List(Arc::new(edge.keys.iter().map(|k| {
Value::List(Arc::new(vec![
val_writer.build_value(&Value::List(Rc::new(edge.keys.iter().map(|k| {
Value::List(Rc::new(vec![
Value::RefString(&k.name),
Value::OwnString(Arc::new(format!("{}", k.typ))),
Value::OwnString(Rc::new(format!("{}", k.typ))),
k.default.clone(),
]))
}).collect())));
val_writer.build_value(&Value::List(Arc::new(edge.cols.iter().map(|k| {
Value::List(Arc::new(vec![
val_writer.build_value(&Value::List(Rc::new(edge.cols.iter().map(|k| {
Value::List(Rc::new(vec![
Value::RefString(&k.name),
Value::OwnString(Arc::new(format!("{}", k.typ))),
Value::OwnString(Rc::new(format!("{}", k.typ))),
k.default.clone(),
]))
}).collect())));

25
src/eval.rs
Unescape Escape View File

@ -1,5 +1,4 @@
use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::rc::Rc;
use crate::ast::Expr;
use crate::ast::Expr::*;
use crate::error::Result;
@ -14,15 +13,16 @@ use crate::typing::Structured;
pub struct Evaluator<S: Storage> {
pub env: StructuredEnv,
pub storage: S,
pub last_local_id: Arc<AtomicUsize>,
pub last_local_id: usize,
}
impl<S: Storage> Evaluator<S> {
pub fn get_next_local_id(&self, is_global: bool) -> usize {
pub fn get_next_local_id(&mut self, is_global: bool) -> usize {
if is_global {
0
} else {
self.last_local_id.fetch_add(1, Ordering::Relaxed)
self.last_local_id += 1;
self.last_local_id
}
}
}
@ -35,7 +35,7 @@ impl EvaluatorWithStorage {
Ok(Self {
env: StructuredEnv::new(),
storage: RocksStorage::new(path)?,
last_local_id: Arc::new(AtomicUsize::new(1)),
last_local_id: 0,
})
}
}
@ -45,7 +45,7 @@ impl Default for BareEvaluator {
Self {
env: StructuredEnv::new(),
storage: DummyStorage,
last_local_id: Arc::new(AtomicUsize::new(0)),
last_local_id: 0,
}
}
}
@ -89,7 +89,6 @@ impl<'a, S: Storage> ExprVisitor<'a, Result<Expr<'a>>> for Evaluator<S> {
}
_ => return Err(ValueRequired)
}
}
}
}
@ -111,10 +110,10 @@ impl<S: Storage> Evaluator<S> {
(Float(va), Int(vb)) => Float(va + vb as f64),
(Int(va), Float(vb)) => Float(va as f64 + vb),
(Float(va), Float(vb)) => Float(va + vb),
(OwnString(va), OwnString(vb)) => OwnString(Arc::new(va.clone().to_string() + &vb)),
(OwnString(va), RefString(vb)) => OwnString(Arc::new(va.clone().to_string() + &*vb)),
(RefString(va), OwnString(vb)) => OwnString(Arc::new(va.to_string() + &*vb)),
(RefString(va), RefString(vb)) => OwnString(Arc::new(va.to_string() + &*vb)),
(OwnString(va), OwnString(vb)) => OwnString(Rc::new(va.clone().to_string() + &vb)),
(OwnString(va), RefString(vb)) => OwnString(Rc::new(va.clone().to_string() + &*vb)),
(RefString(va), OwnString(vb)) => OwnString(Rc::new(va.to_string() + &*vb)),
(RefString(va), RefString(vb)) => OwnString(Rc::new(va.to_string() + &*vb)),
(_, _) => return Err(CozoError::TypeError)
}
}
@ -537,7 +536,7 @@ mod tests {
#[test]
fn operators() {
let mut ev = BareEvaluator::default();
let ev = BareEvaluator::default();
println!("{:#?}", ev.visit_expr(&parse_expr_from_str("1/10+(-2+3)*4^5").unwrap()).unwrap());
println!("{:#?}", ev.visit_expr(&parse_expr_from_str("true && false").unwrap()).unwrap());

67
src/function.rs
Unescape Escape View File

@ -1,8 +1,7 @@
use std::collections::BTreeMap;
use std::fmt::{Debug, Formatter};
use crate::typing::{BaseType, Typing};
use crate::typing::{Typing};
use crate::value::Value;
use lazy_static::lazy_static;
// use lazy_static::lazy_static;
#[derive(PartialEq, Debug)]
pub struct Function {
@ -40,34 +39,34 @@ pub struct Arg {
pub name: Option<String>,
}
lazy_static! {
static ref BUILT_IN_FUNCTIONS : BTreeMap<&'static str, Function> = {
let mut ret = BTreeMap::new();
fn add_int<'a>(_args: &[Value<'a>]) -> Value<'a> {
todo!()
}
fn add_float<'a>(_args: &[Value<'a>]) -> Value<'a> {
todo!()
}
ret.insert("_add_int",
Function {
args: vec![],
var_arg: Some(Typing::Base(BaseType::Int)),
ret_type: Typing::Base(BaseType::Int),
fn_impl: FunctionImpl::Native("_add_int", add_int)
});
ret.insert("_add_float",
Function {
args: vec![],
var_arg: Some(Typing::Base(BaseType::Float)),
ret_type: Typing::Base(BaseType::Float),
fn_impl: FunctionImpl::Native("_add_float", add_float)
});
ret
};
}
// lazy_static! {
// static ref BUILT_IN_FUNCTIONS : BTreeMap<&'static str, Function> = {
// let mut ret = BTreeMap::new();
//
// fn add_int<'a>(_args: &[Value<'a>]) -> Value<'a> {
// todo!()
// }
//
// fn add_float<'a>(_args: &[Value<'a>]) -> Value<'a> {
// todo!()
// }
//
// ret.insert("_add_int",
// Function {
// args: vec![],
// var_arg: Some(Typing::Base(BaseType::Int)),
// ret_type: Typing::Base(BaseType::Int),
// fn_impl: FunctionImpl::Native("_add_int", add_int)
// });
//
// ret.insert("_add_float",
// Function {
// args: vec![],
// var_arg: Some(Typing::Base(BaseType::Float)),
// ret_type: Typing::Base(BaseType::Float),
// fn_impl: FunctionImpl::Native("_add_float", add_float)
// });
//
// ret
// };
// }

1
src/mutation.rs
Unescape Escape View File

@ -63,7 +63,6 @@ mod tests {
use crate::ast::{Expr, ExprVisitor, parse_expr_from_str};
use crate::eval::{BareEvaluator, EvaluatorWithStorage};
use pest::Parser as PestParser;
use cozo_rocks::*;
use crate::env::Env;
use crate::typing::Structured;

2
src/storage.rs
Unescape Escape View File

@ -30,7 +30,7 @@ impl RocksStorage {
// DB::destroy(&make_options(), &self.path)?;
let path = self.path.clone();
drop(self);
fs::remove_dir_all(path);
fs::remove_dir_all(path)?;
Ok(())
}

24
src/value.rs
Unescape Escape View File

@ -6,7 +6,7 @@ use ordered_float::OrderedFloat;
use uuid::Uuid;
use crate::typing::{Typing};
use Ordering::{Greater, Less, Equal};
use std::sync::Arc;
use std::rc::Rc;
// TODO: array types, alignment of values
#[repr(u8)]
@ -67,22 +67,22 @@ pub enum Value<'a> {
Float(f64),
Uuid(Uuid),
RefString(&'a str),
OwnString(Arc<String>),
List(Arc<Vec<Value<'a>>>),
Dict(Arc<BTreeMap<Cow<'a, str>, Value<'a>>>),
OwnString(Rc<String>),
List(Rc<Vec<Value<'a>>>),
Dict(Rc<BTreeMap<Cow<'a, str>, Value<'a>>>),
}
impl<'a> Value<'a> {
pub fn get_list(&self) -> Option<Arc<Vec<Self>>> {
pub fn get_list(&self) -> Option<Rc<Vec<Self>>> {
match self {
Value::List(v) => Some(v.clone()),
_ => None
}
}
pub fn get_string(&self) -> Option<Arc<String>> {
pub fn get_string(&self) -> Option<Rc<String>> {
match self {
Value::OwnString(v) => Some(v.clone()),
Value::RefString(v) => Some(Arc::new(v.to_string())),
Value::RefString(v) => Some(Rc::new(v.to_string())),
_ => None
}
}
@ -283,8 +283,8 @@ impl<'a> ByteArrayParser<'a> {
FloatTag => Some(Float(self.parse_float()?)),
StringTag => Some(RefString(self.parse_string()?)),
UIntTag => Some(UInt(self.parse_varint()?)),
ListTag => Some(List(Arc::new(self.parse_list()?))),
DictTag => Some(Dict(Arc::new(self.parse_dict()?))),
ListTag => Some(List(Rc::new(self.parse_list()?))),
DictTag => Some(Dict(Rc::new(self.parse_dict()?))),
UuidTag => Some(Uuid(self.parse_uuid()?))
}
}
@ -516,7 +516,7 @@ impl<'a> Value<'a> {
UInt(u) => UInt(*u),
Int(i) => Int(*i),
Float(f) => Float(*f),
RefString(s) => OwnString(Arc::new(s.to_string())),
RefString(s) => OwnString(Rc::new(s.to_string())),
OwnString(s) => OwnString(s.clone()),
List(l) => {
let mut inner = Vec::with_capacity(l.len());
@ -524,7 +524,7 @@ impl<'a> Value<'a> {
for el in l.iter() {
inner.push(el.clone().to_owned())
}
List(Arc::new(inner))
List(Rc::new(inner))
}
Dict(d) => {
let mut inner = BTreeMap::new();
@ -532,7 +532,7 @@ impl<'a> Value<'a> {
let new_k = Cow::from(k.clone().into_owned());
inner.insert(new_k, v.clone().to_owned());
}
Dict(Arc::new(inner))
Dict(Rc::new(inner))
}
Uuid(u) => Uuid(*u),
}

Write Preview
Loading…
Cancel
Save