fluidB
/
fluidb
1
0
Fork 0
Code Pull Requests Activity

tuple_eval deals with megatuple instead

Browse Source
main
Ziyang Hu 2 years ago
parent 42fa98b223
commit 8d6bf05b6f
2 changed files with 41 additions and 39 deletions
Show Stats Download Patch File Download Diff File

62
src/db/eval.rs
Unescape Escape View File

@ -9,12 +9,14 @@ use crate::db::table::TableId;
use crate::relation::value::{Value};
use crate::error::{CozoError, Result};
use crate::error::CozoError::{InvalidArgument, LogicError};
use crate::relation::data::DataKind;
use crate::relation::table::MegaTuple;
use crate::relation::tuple::{SliceTuple, Tuple};
use crate::relation::value;
impl<'s> Session<'s> {
pub fn tuple_eval<'a>(&self, value: &'a Value<'a>, tuples: &'a [(SliceTuple, SliceTuple)]) -> Result<Value<'a>> {
pub fn tuple_eval<'a>(&self, value: &'a Value<'a>, tuples: &'a MegaTuple) -> Result<Value<'a>> {
let res: Value = match value {
v @ (Value::Null |
Value::Bool(_) |
@ -37,16 +39,16 @@ impl<'s> Session<'s> {
return Err(LogicError(format!("Cannot resolve variable {}", v)));
}
Value::TupleRef(tid, cid) => {
let pair = tuples.get(tid.id as usize).ok_or_else(|| {
let targets = if cid.is_key { &tuples.keys } else { &tuples.vals };
let target = targets.get(tid.id as usize).ok_or_else(|| {
LogicError("Tuple ref out of bound".to_string())
})?;
let tuple = if cid.is_key {
&pair.0
if matches!(target.data_kind(), Ok(DataKind::Empty)) {
Value::Null
} else {
&pair.1
};
tuple.get(cid.id as usize)
.ok_or_else(|| LogicError("Tuple ref out of bound".to_string()))?
target.get(cid.id as usize)
.ok_or_else(|| LogicError("Tuple ref out of bound".to_string()))?
}
}
Value::Apply(op, args) => {
match op.as_ref() {
@ -274,7 +276,7 @@ impl<'s> Session<'s> {
}
impl<'s> Session<'s> {
fn coalesce_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a [(SliceTuple, SliceTuple)]) -> Result<Value<'a>> {
fn coalesce_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a MegaTuple) -> Result<Value<'a>> {
for v in args {
match self.tuple_eval(v, tuples)? {
Value::Null => {}
@ -318,7 +320,7 @@ impl<'s> Session<'s> {
}
}
fn str_cat_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a [(SliceTuple, SliceTuple)]) -> Result<Value<'a>> {
fn str_cat_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a MegaTuple) -> Result<Value<'a>> {
let mut ret = String::new();
for v in args {
let v = self.tuple_eval(v, tuples)?;
@ -348,7 +350,7 @@ impl<'s> Session<'s> {
})
}
fn add_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a [(SliceTuple, SliceTuple)]) -> Result<Value<'a>> {
fn add_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a MegaTuple) -> Result<Value<'a>> {
let mut args = args.into_iter();
let left = self.tuple_eval(args.next().unwrap(), tuples)?;
if left == Value::Null {
@ -387,7 +389,7 @@ impl<'s> Session<'s> {
})
}
fn sub_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a [(SliceTuple, SliceTuple)]) -> Result<Value<'a>> {
fn sub_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a MegaTuple) -> Result<Value<'a>> {
let mut args = args.into_iter();
let left = self.tuple_eval(args.next().unwrap(), tuples)?;
if left == Value::Null {
@ -426,7 +428,7 @@ impl<'s> Session<'s> {
})
}
fn minus_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a [(SliceTuple, SliceTuple)]) -> Result<Value<'a>> {
fn minus_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a MegaTuple) -> Result<Value<'a>> {
let left = self.tuple_eval(args.get(0).unwrap(), tuples)?;
Ok(match left {
Value::Int(l) => (-l).into(),
@ -452,7 +454,7 @@ impl<'s> Session<'s> {
})
}
fn negate_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a [(SliceTuple, SliceTuple)]) -> Result<Value<'a>> {
fn negate_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a MegaTuple) -> Result<Value<'a>> {
let left = self.tuple_eval(args.get(0).unwrap(), tuples)?;
Ok(match left {
Value::Bool(l) => (!l).into(),
@ -476,7 +478,7 @@ impl<'s> Session<'s> {
})
}
fn is_null_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a [(SliceTuple, SliceTuple)]) -> Result<Value<'a>> {
fn is_null_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a MegaTuple) -> Result<Value<'a>> {
let left = self.tuple_eval(args.get(0).unwrap(), tuples)?;
Ok((left == Value::Null).into())
}
@ -494,7 +496,7 @@ impl<'s> Session<'s> {
Ok((true, false.into()))
}
fn not_null_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a [(SliceTuple, SliceTuple)]) -> Result<Value<'a>> {
fn not_null_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a MegaTuple) -> Result<Value<'a>> {
let left = self.tuple_eval(args.get(0).unwrap(), tuples)?;
Ok((left != Value::Null).into())
}
@ -512,7 +514,7 @@ impl<'s> Session<'s> {
Ok((true, true.into()))
}
fn pow_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a [(SliceTuple, SliceTuple)]) -> Result<Value<'a>> {
fn pow_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a MegaTuple) -> Result<Value<'a>> {
let mut args = args.into_iter();
let left = self.tuple_eval(args.next().unwrap(), tuples)?;
if left == Value::Null {
@ -551,7 +553,7 @@ impl<'s> Session<'s> {
})
}
fn gt_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a [(SliceTuple, SliceTuple)]) -> Result<Value<'a>> {
fn gt_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a MegaTuple) -> Result<Value<'a>> {
let mut args = args.into_iter();
let left = self.tuple_eval(args.next().unwrap(), tuples)?;
if left == Value::Null {
@ -590,7 +592,7 @@ impl<'s> Session<'s> {
})
}
fn lt_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a [(SliceTuple, SliceTuple)]) -> Result<Value<'a>> {
fn lt_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a MegaTuple) -> Result<Value<'a>> {
let mut args = args.into_iter();
let left = self.tuple_eval(args.next().unwrap(), tuples)?;
if left == Value::Null {
@ -629,7 +631,7 @@ impl<'s> Session<'s> {
})
}
fn ge_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a [(SliceTuple, SliceTuple)]) -> Result<Value<'a>> {
fn ge_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a MegaTuple) -> Result<Value<'a>> {
let mut args = args.into_iter();
let left = self.tuple_eval(args.next().unwrap(), tuples)?;
if left == Value::Null {
@ -668,7 +670,7 @@ impl<'s> Session<'s> {
})
}
fn le_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a [(SliceTuple, SliceTuple)]) -> Result<Value<'a>> {
fn le_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a MegaTuple) -> Result<Value<'a>> {
let mut args = args.into_iter();
let left = self.tuple_eval(args.next().unwrap(), tuples)?;
if left == Value::Null {
@ -707,7 +709,7 @@ impl<'s> Session<'s> {
})
}
fn mod_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a [(SliceTuple, SliceTuple)]) -> Result<Value<'a>> {
fn mod_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a MegaTuple) -> Result<Value<'a>> {
let mut args = args.into_iter();
let left = self.tuple_eval(args.next().unwrap(), tuples)?;
if left == Value::Null {
@ -740,7 +742,7 @@ impl<'s> Session<'s> {
})
}
fn mul_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a [(SliceTuple, SliceTuple)]) -> Result<Value<'a>> {
fn mul_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a MegaTuple) -> Result<Value<'a>> {
let mut args = args.into_iter();
let left = self.tuple_eval(args.next().unwrap(), tuples)?;
if left == Value::Null {
@ -779,7 +781,7 @@ impl<'s> Session<'s> {
})
}
fn div_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a [(SliceTuple, SliceTuple)]) -> Result<Value<'a>> {
fn div_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a MegaTuple) -> Result<Value<'a>> {
let mut args = args.into_iter();
let left = self.tuple_eval(args.next().unwrap(), tuples)?;
if left == Value::Null {
@ -818,7 +820,7 @@ impl<'s> Session<'s> {
})
}
fn eq_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a [(SliceTuple, SliceTuple)]) -> Result<Value<'a>> {
fn eq_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a MegaTuple) -> Result<Value<'a>> {
let mut args = args.into_iter();
let left = self.tuple_eval(args.next().unwrap(), tuples)?;
if left == Value::Null {
@ -845,7 +847,7 @@ impl<'s> Session<'s> {
Ok((true, (left == right).into()))
}
fn ne_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a [(SliceTuple, SliceTuple)]) -> Result<Value<'a>> {
fn ne_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a MegaTuple) -> Result<Value<'a>> {
let mut args = args.into_iter();
let left = self.tuple_eval(args.next().unwrap(), tuples)?;
if left == Value::Null {
@ -872,7 +874,7 @@ impl<'s> Session<'s> {
Ok((true, (left != right).into()))
}
fn or_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a [(SliceTuple, SliceTuple)]) -> Result<Value<'a>> {
fn or_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a MegaTuple) -> Result<Value<'a>> {
let mut accum = -1;
for v in args.into_iter() {
let v = self.tuple_eval(v, tuples)?;
@ -957,7 +959,7 @@ impl<'s> Session<'s> {
}
}
fn concat_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a [(SliceTuple, SliceTuple)]) -> Result<Value<'a>> {
fn concat_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a MegaTuple) -> Result<Value<'a>> {
let mut coll = vec![];
for v in args.into_iter() {
let v = self.tuple_eval(v, tuples)?;
@ -1012,7 +1014,7 @@ impl<'s> Session<'s> {
}
}
fn merge_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a [(SliceTuple, SliceTuple)]) -> Result<Value<'a>> {
fn merge_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a MegaTuple) -> Result<Value<'a>> {
let mut coll = BTreeMap::new();
for v in args.into_iter() {
let v = self.tuple_eval(v, tuples)?;
@ -1067,7 +1069,7 @@ impl<'s> Session<'s> {
}
}
fn and_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a [(SliceTuple, SliceTuple)]) -> Result<Value<'a>> {
fn and_values<'a>(&self, args: &'a [Value<'a>], tuples: &'a MegaTuple) -> Result<Value<'a>> {
let mut accum = 1;
for v in args.into_iter() {
let v = self.tuple_eval(v, tuples)?;

18
src/db/plan.rs
Unescape Escape View File

@ -415,16 +415,17 @@ mod tests {
println!("{:?}", rel_tbls);
let tbl = rel_tbls.pop().unwrap();
for (k, v) in &sess.iter_table(tbl) {
let tpair = [(k, v)];
match sess.tuple_eval(&where_vals, &tpair).unwrap() {
let it = sess.iter_table(tbl);
let it = TableRowWithAssociatesIterable::new(it, vec![]);
for tuple in &it {
match sess.tuple_eval(&where_vals, &tuple).unwrap() {
Value::Bool(true) => {
let extracted = sess.tuple_eval(&vals, &tpair).unwrap();
let extracted = sess.tuple_eval(&vals, &tuple).unwrap();
println!("{}", extracted);
}
Value::Null |
Value::Bool(_) => {
println!(" Ignore {:?}", &tpair);
println!(" Ignore {:?}", &tuple);
}
_ => panic!("Bad type")
}
@ -460,16 +461,15 @@ mod tests {
println!("Now cartesian product");
let mut n = 0;
for el in &c_it {
// if i % 4096 == 0 {
// println!("{}: {:?}", i, el)
// }
n += el.keys.len();
let _x = el.keys.into_iter().map(|v| v.iter().map(|v| ()).collect::<Vec<_>>()).collect::<Vec<_>>();
let _y = el.vals.into_iter().map(|v| v.iter().map(|v| ()).collect::<Vec<_>>()).collect::<Vec<_>>();
}
let duration = start.elapsed();
println!("Time elapsed {:?} for {}", duration, n / 3);
println!("Time elapsed {:?}", duration);
let a = sess.iter_table(tbl);
let ac = (&a).into_iter().count();
println!("{}", ac);

Write Preview
Loading…
Cancel
Save