fluidB
/
fluidb
1
0
Fork 0
Code Pull Requests Activity

cleanup of type conversion

Browse Source
main
Ziyang Hu 2 years ago
parent 2d5921a4e8
commit c3c674950f
16 changed files with 282 additions and 256 deletions
Show Stats Download Patch File Download Diff File

8
cozo-core/src/data/aggr.rs
Unescape Escape View File

@ -87,7 +87,7 @@ impl NormalAggrObj for AggrAnd {
} }
fn get(&self) -> Result<DataValue> { fn get(&self) -> Result<DataValue> {
Ok(DataValue::Bool(self.accum)) Ok(DataValue::from(self.accum))
} }
} }
@ -95,7 +95,7 @@ pub(crate) struct MeetAggrAnd;
impl MeetAggrObj for MeetAggrAnd { impl MeetAggrObj for MeetAggrAnd {
fn init_val(&self) -> DataValue { fn init_val(&self) -> DataValue {
DataValue::Bool(true) DataValue::from(true)
} }
fn update(&self, left: &mut DataValue, right: &DataValue) -> Result<bool> { fn update(&self, left: &mut DataValue, right: &DataValue) -> Result<bool> {
@ -127,7 +127,7 @@ impl NormalAggrObj for AggrOr {
} }
fn get(&self) -> Result<DataValue> { fn get(&self) -> Result<DataValue> {
Ok(DataValue::Bool(self.accum)) Ok(DataValue::from(self.accum))
} }
} }
@ -135,7 +135,7 @@ pub(crate) struct MeetAggrOr;
impl MeetAggrObj for MeetAggrOr { impl MeetAggrObj for MeetAggrOr {
fn init_val(&self) -> DataValue { fn init_val(&self) -> DataValue {
DataValue::Bool(false) DataValue::from(false)
} }
fn update(&self, left: &mut DataValue, right: &DataValue) -> Result<bool> { fn update(&self, left: &mut DataValue, right: &DataValue) -> Result<bool> {

2
cozo-core/src/data/expr.rs
Unescape Escape View File

@ -456,7 +456,7 @@ impl Expr {
StrRangeScanError(val.clone(), symb.span) StrRangeScanError(val.clone(), symb.span)
})?; })?;
let lower = DataValue::Str(SmartString::from(s)); let lower = DataValue::from(s);
// let lower = DataValue::Str(s.to_string()); // let lower = DataValue::Str(s.to_string());
let mut upper = SmartString::from(s); let mut upper = SmartString::from(s);
// let mut upper = s.to_string(); // let mut upper = s.to_string();

84
cozo-core/src/data/functions.rs
Unescape Escape View File

@ -78,7 +78,7 @@ pub(crate) fn op_coalesce(args: &[DataValue]) -> Result<DataValue> {
define_op!(OP_EQ, 2, false); define_op!(OP_EQ, 2, false);
pub(crate) fn op_eq(args: &[DataValue]) -> Result<DataValue> { pub(crate) fn op_eq(args: &[DataValue]) -> Result<DataValue> {
Ok(DataValue::Bool(match (&args[0], &args[1]) { Ok(DataValue::from(match (&args[0], &args[1]) {
(DataValue::Num(Num::Float(f)), DataValue::Num(Num::Int(i))) (DataValue::Num(Num::Float(f)), DataValue::Num(Num::Int(i)))
| (DataValue::Num(Num::Int(i)), DataValue::Num(Num::Float(f))) => *i as f64 == *f, | (DataValue::Num(Num::Int(i)), DataValue::Num(Num::Float(f))) => *i as f64 == *f,
(a, b) => a == b, (a, b) => a == b,
@ -87,7 +87,7 @@ pub(crate) fn op_eq(args: &[DataValue]) -> Result<DataValue> {
define_op!(OP_IS_UUID, 1, false); define_op!(OP_IS_UUID, 1, false);
pub(crate) fn op_is_uuid(args: &[DataValue]) -> Result<DataValue> { pub(crate) fn op_is_uuid(args: &[DataValue]) -> Result<DataValue> {
Ok(DataValue::Bool(matches!(args[0], DataValue::Uuid(_)))) Ok(DataValue::from(matches!(args[0], DataValue::Uuid(_))))
} }
define_op!(OP_IS_IN, 2, false); define_op!(OP_IS_IN, 2, false);
@ -96,12 +96,12 @@ pub(crate) fn op_is_in(args: &[DataValue]) -> Result<DataValue> {
let right = args[1] let right = args[1]
.get_slice() .get_slice()
.ok_or_else(|| miette!("right hand side of 'is_in' must be a list"))?; .ok_or_else(|| miette!("right hand side of 'is_in' must be a list"))?;
Ok(DataValue::Bool(right.contains(left))) Ok(DataValue::from(right.contains(left)))
} }
define_op!(OP_NEQ, 2, false); define_op!(OP_NEQ, 2, false);
pub(crate) fn op_neq(args: &[DataValue]) -> Result<DataValue> { pub(crate) fn op_neq(args: &[DataValue]) -> Result<DataValue> {
Ok(DataValue::Bool(match (&args[0], &args[1]) { Ok(DataValue::from(match (&args[0], &args[1]) {
(DataValue::Num(Num::Float(f)), DataValue::Num(Num::Int(i))) (DataValue::Num(Num::Float(f)), DataValue::Num(Num::Int(i)))
| (DataValue::Num(Num::Int(i)), DataValue::Num(Num::Float(f))) => *i as f64 != *f, | (DataValue::Num(Num::Int(i)), DataValue::Num(Num::Float(f))) => *i as f64 != *f,
(a, b) => a != b, (a, b) => a != b,
@ -111,7 +111,7 @@ pub(crate) fn op_neq(args: &[DataValue]) -> Result<DataValue> {
define_op!(OP_GT, 2, false); define_op!(OP_GT, 2, false);
pub(crate) fn op_gt(args: &[DataValue]) -> Result<DataValue> { pub(crate) fn op_gt(args: &[DataValue]) -> Result<DataValue> {
ensure_same_value_type(&args[0], &args[1])?; ensure_same_value_type(&args[0], &args[1])?;
Ok(DataValue::Bool(match (&args[0], &args[1]) { Ok(DataValue::from(match (&args[0], &args[1]) {
(DataValue::Num(Num::Float(l)), DataValue::Num(Num::Int(r))) => *l > *r as f64, (DataValue::Num(Num::Float(l)), DataValue::Num(Num::Int(r))) => *l > *r as f64,
(DataValue::Num(Num::Int(l)), DataValue::Num(Num::Float(r))) => *l as f64 > *r, (DataValue::Num(Num::Int(l)), DataValue::Num(Num::Float(r))) => *l as f64 > *r,
(a, b) => a > b, (a, b) => a > b,
@ -121,7 +121,7 @@ pub(crate) fn op_gt(args: &[DataValue]) -> Result<DataValue> {
define_op!(OP_GE, 2, false); define_op!(OP_GE, 2, false);
pub(crate) fn op_ge(args: &[DataValue]) -> Result<DataValue> { pub(crate) fn op_ge(args: &[DataValue]) -> Result<DataValue> {
ensure_same_value_type(&args[0], &args[1])?; ensure_same_value_type(&args[0], &args[1])?;
Ok(DataValue::Bool(match (&args[0], &args[1]) { Ok(DataValue::from(match (&args[0], &args[1]) {
(DataValue::Num(Num::Float(l)), DataValue::Num(Num::Int(r))) => *l >= *r as f64, (DataValue::Num(Num::Float(l)), DataValue::Num(Num::Int(r))) => *l >= *r as f64,
(DataValue::Num(Num::Int(l)), DataValue::Num(Num::Float(r))) => *l as f64 >= *r, (DataValue::Num(Num::Int(l)), DataValue::Num(Num::Float(r))) => *l as f64 >= *r,
(a, b) => a >= b, (a, b) => a >= b,
@ -131,7 +131,7 @@ pub(crate) fn op_ge(args: &[DataValue]) -> Result<DataValue> {
define_op!(OP_LT, 2, false); define_op!(OP_LT, 2, false);
pub(crate) fn op_lt(args: &[DataValue]) -> Result<DataValue> { pub(crate) fn op_lt(args: &[DataValue]) -> Result<DataValue> {
ensure_same_value_type(&args[0], &args[1])?; ensure_same_value_type(&args[0], &args[1])?;
Ok(DataValue::Bool(match (&args[0], &args[1]) { Ok(DataValue::from(match (&args[0], &args[1]) {
(DataValue::Num(Num::Float(l)), DataValue::Num(Num::Int(r))) => *l < (*r as f64), (DataValue::Num(Num::Float(l)), DataValue::Num(Num::Int(r))) => *l < (*r as f64),
(DataValue::Num(Num::Int(l)), DataValue::Num(Num::Float(r))) => (*l as f64) < *r, (DataValue::Num(Num::Int(l)), DataValue::Num(Num::Float(r))) => (*l as f64) < *r,
(a, b) => a < b, (a, b) => a < b,
@ -141,7 +141,7 @@ pub(crate) fn op_lt(args: &[DataValue]) -> Result<DataValue> {
define_op!(OP_LE, 2, false); define_op!(OP_LE, 2, false);
pub(crate) fn op_le(args: &[DataValue]) -> Result<DataValue> { pub(crate) fn op_le(args: &[DataValue]) -> Result<DataValue> {
ensure_same_value_type(&args[0], &args[1])?; ensure_same_value_type(&args[0], &args[1])?;
Ok(DataValue::Bool(match (&args[0], &args[1]) { Ok(DataValue::from(match (&args[0], &args[1]) {
(DataValue::Num(Num::Float(l)), DataValue::Num(Num::Int(r))) => *l <= (*r as f64), (DataValue::Num(Num::Float(l)), DataValue::Num(Num::Int(r))) => *l <= (*r as f64),
(DataValue::Num(Num::Int(l)), DataValue::Num(Num::Float(r))) => (*l as f64) <= *r, (DataValue::Num(Num::Int(l)), DataValue::Num(Num::Float(r))) => (*l as f64) <= *r,
(a, b) => a <= b, (a, b) => a <= b,
@ -543,10 +543,10 @@ pub(crate) fn op_and(args: &[DataValue]) -> Result<DataValue> {
.get_bool() .get_bool()
.ok_or_else(|| miette!("'and' requires booleans"))? .ok_or_else(|| miette!("'and' requires booleans"))?
{ {
return Ok(DataValue::Bool(false)); return Ok(DataValue::from(false));
} }
} }
Ok(DataValue::Bool(true)) Ok(DataValue::from(true))
} }
define_op!(OP_OR, 0, true); define_op!(OP_OR, 0, true);
@ -556,16 +556,16 @@ pub(crate) fn op_or(args: &[DataValue]) -> Result<DataValue> {
.get_bool() .get_bool()
.ok_or_else(|| miette!("'or' requires booleans"))? .ok_or_else(|| miette!("'or' requires booleans"))?
{ {
return Ok(DataValue::Bool(true)); return Ok(DataValue::from(true));
} }
} }
Ok(DataValue::Bool(false)) Ok(DataValue::from(false))
} }
define_op!(OP_NEGATE, 1, false); define_op!(OP_NEGATE, 1, false);
pub(crate) fn op_negate(args: &[DataValue]) -> Result<DataValue> { pub(crate) fn op_negate(args: &[DataValue]) -> Result<DataValue> {
if let DataValue::Bool(b) = &args[0] { if let DataValue::Bool(b) = &args[0] {
Ok(DataValue::Bool(!*b)) Ok(DataValue::from(!*b))
} else { } else {
bail!("'negate' requires booleans"); bail!("'negate' requires booleans");
} }
@ -710,7 +710,7 @@ pub(crate) fn op_concat(args: &[DataValue]) -> Result<DataValue> {
bail!("'concat' requires strings, or lists"); bail!("'concat' requires strings, or lists");
} }
} }
Ok(DataValue::Str(SmartString::from(ret))) Ok(DataValue::from(ret))
} }
DataValue::List(_) | DataValue::Set(_) => { DataValue::List(_) | DataValue::Set(_) => {
let mut ret = vec![]; let mut ret = vec![];
@ -732,7 +732,7 @@ pub(crate) fn op_concat(args: &[DataValue]) -> Result<DataValue> {
define_op!(OP_STR_INCLUDES, 2, false); define_op!(OP_STR_INCLUDES, 2, false);
pub(crate) fn op_str_includes(args: &[DataValue]) -> Result<DataValue> { pub(crate) fn op_str_includes(args: &[DataValue]) -> Result<DataValue> {
match (&args[0], &args[1]) { match (&args[0], &args[1]) {
(DataValue::Str(l), DataValue::Str(r)) => Ok(DataValue::Bool(l.find(r as &str).is_some())), (DataValue::Str(l), DataValue::Str(r)) => Ok(DataValue::from(l.find(r as &str).is_some())),
_ => bail!("'str_includes' requires strings"), _ => bail!("'str_includes' requires strings"),
} }
} }
@ -740,7 +740,7 @@ pub(crate) fn op_str_includes(args: &[DataValue]) -> Result<DataValue> {
define_op!(OP_LOWERCASE, 1, false); define_op!(OP_LOWERCASE, 1, false);
pub(crate) fn op_lowercase(args: &[DataValue]) -> Result<DataValue> { pub(crate) fn op_lowercase(args: &[DataValue]) -> Result<DataValue> {
match &args[0] { match &args[0] {
DataValue::Str(s) => Ok(DataValue::Str(SmartString::from(s.to_lowercase()))), DataValue::Str(s) => Ok(DataValue::from(s.to_lowercase())),
_ => bail!("'lowercase' requires strings"), _ => bail!("'lowercase' requires strings"),
} }
} }
@ -748,7 +748,7 @@ pub(crate) fn op_lowercase(args: &[DataValue]) -> Result<DataValue> {
define_op!(OP_UPPERCASE, 1, false); define_op!(OP_UPPERCASE, 1, false);
pub(crate) fn op_uppercase(args: &[DataValue]) -> Result<DataValue> { pub(crate) fn op_uppercase(args: &[DataValue]) -> Result<DataValue> {
match &args[0] { match &args[0] {
DataValue::Str(s) => Ok(DataValue::Str(SmartString::from(s.to_uppercase()))), DataValue::Str(s) => Ok(DataValue::from(s.to_uppercase())),
_ => bail!("'uppercase' requires strings"), _ => bail!("'uppercase' requires strings"),
} }
} }
@ -756,7 +756,7 @@ pub(crate) fn op_uppercase(args: &[DataValue]) -> Result<DataValue> {
define_op!(OP_TRIM, 1, false); define_op!(OP_TRIM, 1, false);
pub(crate) fn op_trim(args: &[DataValue]) -> Result<DataValue> { pub(crate) fn op_trim(args: &[DataValue]) -> Result<DataValue> {
match &args[0] { match &args[0] {
DataValue::Str(s) => Ok(DataValue::Str(SmartString::from(s.trim()))), DataValue::Str(s) => Ok(DataValue::from(s.trim())),
_ => bail!("'trim' requires strings"), _ => bail!("'trim' requires strings"),
} }
} }
@ -764,7 +764,7 @@ pub(crate) fn op_trim(args: &[DataValue]) -> Result<DataValue> {
define_op!(OP_TRIM_START, 1, false); define_op!(OP_TRIM_START, 1, false);
pub(crate) fn op_trim_start(args: &[DataValue]) -> Result<DataValue> { pub(crate) fn op_trim_start(args: &[DataValue]) -> Result<DataValue> {
match &args[0] { match &args[0] {
DataValue::Str(s) => Ok(DataValue::Str(SmartString::from(s.trim_start()))), DataValue::Str(s) => Ok(DataValue::from(s.trim_start())),
_ => bail!("'trim_start' requires strings"), _ => bail!("'trim_start' requires strings"),
} }
} }
@ -772,7 +772,7 @@ pub(crate) fn op_trim_start(args: &[DataValue]) -> Result<DataValue> {
define_op!(OP_TRIM_END, 1, false); define_op!(OP_TRIM_END, 1, false);
pub(crate) fn op_trim_end(args: &[DataValue]) -> Result<DataValue> { pub(crate) fn op_trim_end(args: &[DataValue]) -> Result<DataValue> {
match &args[0] { match &args[0] {
DataValue::Str(s) => Ok(DataValue::Str(SmartString::from(s.trim_end()))), DataValue::Str(s) => Ok(DataValue::from(s.trim_end())),
_ => bail!("'trim_end' requires strings"), _ => bail!("'trim_end' requires strings"),
} }
} }
@ -787,7 +787,7 @@ pub(crate) fn op_starts_with(args: &[DataValue]) -> Result<DataValue> {
DataValue::Str(s) => s, DataValue::Str(s) => s,
_ => bail!("'starts_with' requires strings"), _ => bail!("'starts_with' requires strings"),
}; };
Ok(DataValue::Bool(a.starts_with(b as &str))) Ok(DataValue::from(a.starts_with(b as &str)))
} }
define_op!(OP_ENDS_WITH, 2, false); define_op!(OP_ENDS_WITH, 2, false);
@ -800,7 +800,7 @@ pub(crate) fn op_ends_with(args: &[DataValue]) -> Result<DataValue> {
DataValue::Str(s) => s, DataValue::Str(s) => s,
_ => bail!("'ends_with' requires strings"), _ => bail!("'ends_with' requires strings"),
}; };
Ok(DataValue::Bool(a.ends_with(b as &str))) Ok(DataValue::from(a.ends_with(b as &str)))
} }
define_op!(OP_REGEX, 1, false); define_op!(OP_REGEX, 1, false);
@ -819,7 +819,7 @@ pub(crate) fn op_regex(args: &[DataValue]) -> Result<DataValue> {
define_op!(OP_REGEX_MATCHES, 2, false); define_op!(OP_REGEX_MATCHES, 2, false);
pub(crate) fn op_regex_matches(args: &[DataValue]) -> Result<DataValue> { pub(crate) fn op_regex_matches(args: &[DataValue]) -> Result<DataValue> {
match (&args[0], &args[1]) { match (&args[0], &args[1]) {
(DataValue::Str(s), DataValue::Regex(r)) => Ok(DataValue::Bool(r.0.is_match(s))), (DataValue::Str(s), DataValue::Regex(r)) => Ok(DataValue::from(r.0.is_match(s))),
_ => bail!("'regex_matches' requires strings"), _ => bail!("'regex_matches' requires strings"),
} }
} }
@ -850,7 +850,7 @@ pub(crate) fn op_regex_extract(args: &[DataValue]) -> Result<DataValue> {
(DataValue::Str(s), DataValue::Regex(r)) => { (DataValue::Str(s), DataValue::Regex(r)) => {
let found = let found =
r.0.find_iter(s) r.0.find_iter(s)
.map(|v| DataValue::Str(SmartString::from(v.as_str()))) .map(|v| DataValue::from(v.as_str()))
.collect_vec(); .collect_vec();
Ok(DataValue::List(found)) Ok(DataValue::List(found))
} }
@ -862,9 +862,7 @@ define_op!(OP_REGEX_EXTRACT_FIRST, 2, false);
pub(crate) fn op_regex_extract_first(args: &[DataValue]) -> Result<DataValue> { pub(crate) fn op_regex_extract_first(args: &[DataValue]) -> Result<DataValue> {
match (&args[0], &args[1]) { match (&args[0], &args[1]) {
(DataValue::Str(s), DataValue::Regex(r)) => { (DataValue::Str(s), DataValue::Regex(r)) => {
let found = let found = r.0.find(s).map(|v| DataValue::from(v.as_str()));
r.0.find(s)
.map(|v| DataValue::Str(SmartString::from(v.as_str())));
Ok(found.unwrap_or(DataValue::Null)) Ok(found.unwrap_or(DataValue::Null))
} }
_ => bail!("'regex_extract_first' requires strings"), _ => bail!("'regex_extract_first' requires strings"),
@ -873,12 +871,12 @@ pub(crate) fn op_regex_extract_first(args: &[DataValue]) -> Result<DataValue> {
define_op!(OP_IS_NULL, 1, false); define_op!(OP_IS_NULL, 1, false);
pub(crate) fn op_is_null(args: &[DataValue]) -> Result<DataValue> { pub(crate) fn op_is_null(args: &[DataValue]) -> Result<DataValue> {
Ok(DataValue::Bool(matches!(args[0], DataValue::Null))) Ok(DataValue::from(matches!(args[0], DataValue::Null)))
} }
define_op!(OP_IS_INT, 1, false); define_op!(OP_IS_INT, 1, false);
pub(crate) fn op_is_int(args: &[DataValue]) -> Result<DataValue> { pub(crate) fn op_is_int(args: &[DataValue]) -> Result<DataValue> {
Ok(DataValue::Bool(matches!( Ok(DataValue::from(matches!(
args[0], args[0],
DataValue::Num(Num::Int(_)) DataValue::Num(Num::Int(_))
))) )))
@ -886,7 +884,7 @@ pub(crate) fn op_is_int(args: &[DataValue]) -> Result<DataValue> {
define_op!(OP_IS_FLOAT, 1, false); define_op!(OP_IS_FLOAT, 1, false);
pub(crate) fn op_is_float(args: &[DataValue]) -> Result<DataValue> { pub(crate) fn op_is_float(args: &[DataValue]) -> Result<DataValue> {
Ok(DataValue::Bool(matches!( Ok(DataValue::from(matches!(
args[0], args[0],
DataValue::Num(Num::Float(_)) DataValue::Num(Num::Float(_))
))) )))
@ -894,7 +892,7 @@ pub(crate) fn op_is_float(args: &[DataValue]) -> Result<DataValue> {
define_op!(OP_IS_NUM, 1, false); define_op!(OP_IS_NUM, 1, false);
pub(crate) fn op_is_num(args: &[DataValue]) -> Result<DataValue> { pub(crate) fn op_is_num(args: &[DataValue]) -> Result<DataValue> {
Ok(DataValue::Bool(matches!( Ok(DataValue::from(matches!(
args[0], args[0],
DataValue::Num(Num::Int(_)) | DataValue::Num(Num::Float(_)) DataValue::Num(Num::Int(_)) | DataValue::Num(Num::Float(_))
))) )))
@ -902,7 +900,7 @@ pub(crate) fn op_is_num(args: &[DataValue]) -> Result<DataValue> {
define_op!(OP_IS_FINITE, 1, false); define_op!(OP_IS_FINITE, 1, false);
pub(crate) fn op_is_finite(args: &[DataValue]) -> Result<DataValue> { pub(crate) fn op_is_finite(args: &[DataValue]) -> Result<DataValue> {
Ok(DataValue::Bool(match &args[0] { Ok(DataValue::from(match &args[0] {
DataValue::Num(Num::Int(_)) => true, DataValue::Num(Num::Int(_)) => true,
DataValue::Num(Num::Float(f)) => f.is_finite(), DataValue::Num(Num::Float(f)) => f.is_finite(),
_ => false, _ => false,
@ -911,7 +909,7 @@ pub(crate) fn op_is_finite(args: &[DataValue]) -> Result<DataValue> {
define_op!(OP_IS_INFINITE, 1, false); define_op!(OP_IS_INFINITE, 1, false);
pub(crate) fn op_is_infinite(args: &[DataValue]) -> Result<DataValue> { pub(crate) fn op_is_infinite(args: &[DataValue]) -> Result<DataValue> {
Ok(DataValue::Bool(match &args[0] { Ok(DataValue::from(match &args[0] {
DataValue::Num(Num::Float(f)) => f.is_infinite(), DataValue::Num(Num::Float(f)) => f.is_infinite(),
_ => false, _ => false,
})) }))
@ -919,7 +917,7 @@ pub(crate) fn op_is_infinite(args: &[DataValue]) -> Result<DataValue> {
define_op!(OP_IS_NAN, 1, false); define_op!(OP_IS_NAN, 1, false);
pub(crate) fn op_is_nan(args: &[DataValue]) -> Result<DataValue> { pub(crate) fn op_is_nan(args: &[DataValue]) -> Result<DataValue> {
Ok(DataValue::Bool(match &args[0] { Ok(DataValue::from(match &args[0] {
DataValue::Num(Num::Float(f)) => f.is_nan(), DataValue::Num(Num::Float(f)) => f.is_nan(),
_ => false, _ => false,
})) }))
@ -927,12 +925,12 @@ pub(crate) fn op_is_nan(args: &[DataValue]) -> Result<DataValue> {
define_op!(OP_IS_STRING, 1, false); define_op!(OP_IS_STRING, 1, false);
pub(crate) fn op_is_string(args: &[DataValue]) -> Result<DataValue> { pub(crate) fn op_is_string(args: &[DataValue]) -> Result<DataValue> {
Ok(DataValue::Bool(matches!(args[0], DataValue::Str(_)))) Ok(DataValue::from(matches!(args[0], DataValue::Str(_))))
} }
define_op!(OP_IS_LIST, 1, false); define_op!(OP_IS_LIST, 1, false);
pub(crate) fn op_is_list(args: &[DataValue]) -> Result<DataValue> { pub(crate) fn op_is_list(args: &[DataValue]) -> Result<DataValue> {
Ok(DataValue::Bool(matches!( Ok(DataValue::from(matches!(
args[0], args[0],
DataValue::List(_) | DataValue::Set(_) DataValue::List(_) | DataValue::Set(_)
))) )))
@ -974,7 +972,7 @@ pub(crate) fn op_prepend(args: &[DataValue]) -> Result<DataValue> {
define_op!(OP_IS_BYTES, 1, false); define_op!(OP_IS_BYTES, 1, false);
pub(crate) fn op_is_bytes(args: &[DataValue]) -> Result<DataValue> { pub(crate) fn op_is_bytes(args: &[DataValue]) -> Result<DataValue> {
Ok(DataValue::Bool(matches!(args[0], DataValue::Bytes(_)))) Ok(DataValue::from(matches!(args[0], DataValue::Bytes(_))))
} }
define_op!(OP_LENGTH, 1, false); define_op!(OP_LENGTH, 1, false);
@ -1235,7 +1233,7 @@ pub(crate) fn op_from_substrings(args: &[DataValue]) -> Result<DataValue> {
} }
_ => bail!("'from_substring' requires a list of strings"), _ => bail!("'from_substring' requires a list of strings"),
} }
Ok(DataValue::Str(SmartString::from(ret))) Ok(DataValue::from(ret))
} }
define_op!(OP_ENCODE_BASE64, 1, false); define_op!(OP_ENCODE_BASE64, 1, false);
@ -1243,7 +1241,7 @@ pub(crate) fn op_encode_base64(args: &[DataValue]) -> Result<DataValue> {
match &args[0] { match &args[0] {
DataValue::Bytes(b) => { DataValue::Bytes(b) => {
let s = base64::encode(b); let s = base64::encode(b);
Ok(DataValue::Str(SmartString::from(s))) Ok(DataValue::from(s))
} }
_ => bail!("'encode_base64' requires bytes"), _ => bail!("'encode_base64' requires bytes"),
} }
@ -1262,7 +1260,7 @@ pub(crate) fn op_decode_base64(args: &[DataValue]) -> Result<DataValue> {
define_op!(OP_TO_BOOL, 1, false); define_op!(OP_TO_BOOL, 1, false);
pub(crate) fn op_to_bool(args: &[DataValue]) -> Result<DataValue> { pub(crate) fn op_to_bool(args: &[DataValue]) -> Result<DataValue> {
Ok(DataValue::Bool(match &args[0] { Ok(DataValue::from(match &args[0] {
DataValue::Null => false, DataValue::Null => false,
DataValue::Bool(b) => *b, DataValue::Bool(b) => *b,
DataValue::Num(n) => n.get_int() != Some(0), DataValue::Num(n) => n.get_int() != Some(0),
@ -1344,7 +1342,7 @@ pub(crate) fn op_to_string(args: &[DataValue]) -> Result<DataValue> {
v => { v => {
let jv = JsonValue::from(v.clone()); let jv = JsonValue::from(v.clone());
let s = jv.to_string(); let s = jv.to_string();
DataValue::Str(SmartString::from(s)) DataValue::from(s)
} }
}) })
} }
@ -1367,7 +1365,7 @@ pub(crate) fn op_rand_bernoulli(args: &[DataValue]) -> Result<DataValue> {
} }
_ => bail!("'rand_bernoulli' requires number between 0. and 1."), _ => bail!("'rand_bernoulli' requires number between 0. and 1."),
}; };
Ok(DataValue::Bool(thread_rng().gen_bool(prob))) Ok(DataValue::from(thread_rng().gen_bool(prob)))
} }
define_op!(OP_RAND_INT, 2, false); define_op!(OP_RAND_INT, 2, false);
@ -1402,7 +1400,7 @@ pub(crate) fn op_rand_choose(args: &[DataValue]) -> Result<DataValue> {
define_op!(OP_ASSERT, 1, true); define_op!(OP_ASSERT, 1, true);
pub(crate) fn op_assert(args: &[DataValue]) -> Result<DataValue> { pub(crate) fn op_assert(args: &[DataValue]) -> Result<DataValue> {
match &args[0] { match &args[0] {
DataValue::Bool(true) => Ok(DataValue::Bool(true)), DataValue::Bool(true) => Ok(DataValue::from(true)),
_ => bail!("assertion failed: {:?}", args), _ => bail!("assertion failed: {:?}", args),
} }
} }

9
cozo-core/src/data/json.rs
Unescape Escape View File

@ -8,7 +8,6 @@
use serde_json::json; use serde_json::json;
pub(crate) use serde_json::Value as JsonValue; pub(crate) use serde_json::Value as JsonValue;
use smartstring::SmartString;
use crate::data::value::{DataValue, Num}; use crate::data::value::{DataValue, Num};
@ -21,16 +20,16 @@ impl From<JsonValue> for DataValue {
Some(i) => DataValue::from(i), Some(i) => DataValue::from(i),
None => match n.as_f64() { None => match n.as_f64() {
Some(f) => DataValue::from(f), Some(f) => DataValue::from(f),
None => DataValue::Str(SmartString::from(n.to_string())), None => DataValue::from(n.to_string()),
}, },
}, },
JsonValue::String(s) => DataValue::Str(SmartString::from(s)), JsonValue::String(s) => DataValue::from(s),
JsonValue::Array(arr) => DataValue::List(arr.iter().map(DataValue::from).collect()), JsonValue::Array(arr) => DataValue::List(arr.iter().map(DataValue::from).collect()),
JsonValue::Object(d) => DataValue::List( JsonValue::Object(d) => DataValue::List(
d.into_iter() d.into_iter()
.map(|(k, v)| { .map(|(k, v)| {
DataValue::List( DataValue::List(
[DataValue::Str(SmartString::from(k)), DataValue::from(v)].into(), [DataValue::from(k), DataValue::from(v)].into(),
) )
}) })
.collect(), .collect(),
@ -48,7 +47,7 @@ impl<'a> From<&'a JsonValue> for DataValue {
Some(i) => DataValue::from(i), Some(i) => DataValue::from(i),
None => match n.as_f64() { None => match n.as_f64() {
Some(f) => DataValue::from(f), Some(f) => DataValue::from(f),
None => DataValue::Str(SmartString::from(n.to_string())), None => DataValue::from(n.to_string()),
}, },
}, },
JsonValue::String(s) => DataValue::Str(s.into()), JsonValue::String(s) => DataValue::Str(s.into()),

4
cozo-core/src/data/memcmp.rs
Unescape Escape View File

@ -226,8 +226,8 @@ impl DataValue {
let (tag, remaining) = bs.split_first().unwrap(); let (tag, remaining) = bs.split_first().unwrap();
match *tag { match *tag {
NULL_TAG => (DataValue::Null, remaining), NULL_TAG => (DataValue::Null, remaining),
FALSE_TAG => (DataValue::Bool(false), remaining), FALSE_TAG => (DataValue::from(false), remaining),
TRUE_TAG => (DataValue::Bool(true), remaining), TRUE_TAG => (DataValue::from(true), remaining),
NUM_TAG => { NUM_TAG => {
let (n, remaining) = Num::decode_from_key(remaining); let (n, remaining) = Num::decode_from_key(remaining);
(DataValue::Num(n), remaining) (DataValue::Num(n), remaining)

15
cozo-core/src/data/relation.rs
Unescape Escape View File

@ -170,8 +170,19 @@ impl NullableColType {
let make_err = || DataCoercionFailed(self.clone(), data.clone()); let make_err = || DataCoercionFailed(self.clone(), data.clone());
Ok(match &self.coltype { Ok(match &self.coltype {
ColType::Any => data, ColType::Any => match data {
ColType::Bool => DataValue::Bool(data.get_bool().ok_or_else(make_err)?), DataValue::Set(s) => DataValue::List(s.into_iter().collect_vec()),
DataValue::Bot => {
#[derive(Debug, Error, Diagnostic)]
#[error("data coercion failed: internal type Bot not allowed")]
#[diagnostic(code(eval::coercion_from_bot))]
struct DataCoercionFromBot;
bail!(DataCoercionFromBot)
}
d => d,
},
ColType::Bool => DataValue::from(data.get_bool().ok_or_else(make_err)?),
ColType::Int => DataValue::from(data.get_int().ok_or_else(make_err)?), ColType::Int => DataValue::from(data.get_int().ok_or_else(make_err)?),
ColType::Float => DataValue::from(data.get_float().ok_or_else(make_err)?), ColType::Float => DataValue::from(data.get_float().ok_or_else(make_err)?),
ColType::String => { ColType::String => {

76
cozo-core/src/data/tests/aggrs.rs
Unescape Escape View File

@ -18,27 +18,27 @@ fn test_and() {
aggr.normal_init(&[]).unwrap(); aggr.normal_init(&[]).unwrap();
aggr.meet_init(&[]).unwrap(); aggr.meet_init(&[]).unwrap();
let mut and_aggr = aggr.normal_op.unwrap(); let mut and_aggr = aggr.normal_op.unwrap();
assert_eq!(and_aggr.get().unwrap(), DataValue::Bool(true)); assert_eq!(and_aggr.get().unwrap(), DataValue::from(true));
and_aggr.set(&DataValue::Bool(true)).unwrap(); and_aggr.set(&DataValue::from(true)).unwrap();
and_aggr.set(&DataValue::Bool(true)).unwrap(); and_aggr.set(&DataValue::from(true)).unwrap();
assert_eq!(and_aggr.get().unwrap(), DataValue::Bool(true)); assert_eq!(and_aggr.get().unwrap(), DataValue::from(true));
and_aggr.set(&DataValue::Bool(false)).unwrap(); and_aggr.set(&DataValue::from(false)).unwrap();
assert_eq!(and_aggr.get().unwrap(), DataValue::Bool(false)); assert_eq!(and_aggr.get().unwrap(), DataValue::from(false));
let m_and_aggr = aggr.meet_op.unwrap(); let m_and_aggr = aggr.meet_op.unwrap();
let mut v = DataValue::Bool(true); let mut v = DataValue::from(true);
m_and_aggr.update(&mut v, &DataValue::Bool(true)).unwrap(); m_and_aggr.update(&mut v, &DataValue::from(true)).unwrap();
assert_eq!(v, DataValue::Bool(true)); assert_eq!(v, DataValue::from(true));
m_and_aggr.update(&mut v, &DataValue::Bool(false)).unwrap(); m_and_aggr.update(&mut v, &DataValue::from(false)).unwrap();
assert_eq!(v, DataValue::Bool(false)); assert_eq!(v, DataValue::from(false));
m_and_aggr.update(&mut v, &DataValue::Bool(true)).unwrap(); m_and_aggr.update(&mut v, &DataValue::from(true)).unwrap();
assert_eq!(v, DataValue::Bool(false)); assert_eq!(v, DataValue::from(false));
} }
#[test] #[test]
@ -48,27 +48,27 @@ fn test_or() {
aggr.meet_init(&[]).unwrap(); aggr.meet_init(&[]).unwrap();
let mut or_aggr = aggr.normal_op.unwrap(); let mut or_aggr = aggr.normal_op.unwrap();
assert_eq!(or_aggr.get().unwrap(), DataValue::Bool(false)); assert_eq!(or_aggr.get().unwrap(), DataValue::from(false));
or_aggr.set(&DataValue::Bool(false)).unwrap(); or_aggr.set(&DataValue::from(false)).unwrap();
or_aggr.set(&DataValue::Bool(false)).unwrap(); or_aggr.set(&DataValue::from(false)).unwrap();
assert_eq!(or_aggr.get().unwrap(), DataValue::Bool(false)); assert_eq!(or_aggr.get().unwrap(), DataValue::from(false));
or_aggr.set(&DataValue::Bool(true)).unwrap(); or_aggr.set(&DataValue::from(true)).unwrap();
assert_eq!(or_aggr.get().unwrap(), DataValue::Bool(true)); assert_eq!(or_aggr.get().unwrap(), DataValue::from(true));
let m_or_aggr = aggr.meet_op.unwrap(); let m_or_aggr = aggr.meet_op.unwrap();
let mut v = DataValue::Bool(false); let mut v = DataValue::from(false);
m_or_aggr.update(&mut v, &DataValue::Bool(false)).unwrap(); m_or_aggr.update(&mut v, &DataValue::from(false)).unwrap();
assert_eq!(v, DataValue::Bool(false)); assert_eq!(v, DataValue::from(false));
m_or_aggr.update(&mut v, &DataValue::Bool(true)).unwrap(); m_or_aggr.update(&mut v, &DataValue::from(true)).unwrap();
assert_eq!(v, DataValue::Bool(true)); assert_eq!(v, DataValue::from(true));
m_or_aggr.update(&mut v, &DataValue::Bool(false)).unwrap(); m_or_aggr.update(&mut v, &DataValue::from(false)).unwrap();
assert_eq!(v, DataValue::Bool(true)); assert_eq!(v, DataValue::from(true));
} }
#[test] #[test]
@ -77,14 +77,14 @@ fn test_unique() {
aggr.normal_init(&[]).unwrap(); aggr.normal_init(&[]).unwrap();
let mut unique_aggr = aggr.normal_op.unwrap(); let mut unique_aggr = aggr.normal_op.unwrap();
unique_aggr.set(&DataValue::Bool(true)).unwrap(); unique_aggr.set(&DataValue::from(true)).unwrap();
unique_aggr.set(&DataValue::from(1)).unwrap(); unique_aggr.set(&DataValue::from(1)).unwrap();
unique_aggr.set(&DataValue::from(2)).unwrap(); unique_aggr.set(&DataValue::from(2)).unwrap();
unique_aggr.set(&DataValue::from(1)).unwrap(); unique_aggr.set(&DataValue::from(1)).unwrap();
assert_eq!( assert_eq!(
unique_aggr.get().unwrap(), unique_aggr.get().unwrap(),
DataValue::List(vec![ DataValue::List(vec![
DataValue::Bool(true), DataValue::from(true),
DataValue::from(1), DataValue::from(1),
DataValue::from(2), DataValue::from(2),
]) ])
@ -243,8 +243,8 @@ fn test_count() {
count_aggr.set(&DataValue::Null).unwrap(); count_aggr.set(&DataValue::Null).unwrap();
count_aggr.set(&DataValue::Null).unwrap(); count_aggr.set(&DataValue::Null).unwrap();
count_aggr.set(&DataValue::Null).unwrap(); count_aggr.set(&DataValue::Null).unwrap();
count_aggr.set(&DataValue::Bool(true)).unwrap(); count_aggr.set(&DataValue::from(true)).unwrap();
count_aggr.set(&DataValue::Bool(true)).unwrap(); count_aggr.set(&DataValue::from(true)).unwrap();
assert_eq!(count_aggr.get().unwrap(), DataValue::from(6)); assert_eq!(count_aggr.get().unwrap(), DataValue::from(6));
} }
@ -386,19 +386,19 @@ fn test_min_cost() {
.unwrap(); .unwrap();
min_cost_aggr min_cost_aggr
.set(&DataValue::List(vec![ .set(&DataValue::List(vec![
DataValue::Bool(true), DataValue::from(true),
DataValue::from(1), DataValue::from(1),
])) ]))
.unwrap(); .unwrap();
min_cost_aggr min_cost_aggr
.set(&DataValue::List(vec![ .set(&DataValue::List(vec![
DataValue::Bool(false), DataValue::from(false),
DataValue::from(2), DataValue::from(2),
])) ]))
.unwrap(); .unwrap();
assert_eq!( assert_eq!(
min_cost_aggr.get().unwrap(), min_cost_aggr.get().unwrap(),
DataValue::List(vec![DataValue::Bool(true), DataValue::from(1.)]) DataValue::List(vec![DataValue::from(true), DataValue::from(1.)])
); );
let m_min_cost_aggr = aggr.meet_op.unwrap(); let m_min_cost_aggr = aggr.meet_op.unwrap();
@ -406,18 +406,18 @@ fn test_min_cost() {
m_min_cost_aggr m_min_cost_aggr
.update( .update(
&mut v, &mut v,
&DataValue::List(vec![DataValue::Bool(true), DataValue::from(1)]), &DataValue::List(vec![DataValue::from(true), DataValue::from(1)]),
) )
.unwrap(); .unwrap();
m_min_cost_aggr m_min_cost_aggr
.update( .update(
&mut v, &mut v,
&DataValue::List(vec![DataValue::Bool(false), DataValue::from(2)]), &DataValue::List(vec![DataValue::from(false), DataValue::from(2)]),
) )
.unwrap(); .unwrap();
assert_eq!( assert_eq!(
v, v,
DataValue::List(vec![DataValue::Bool(true), DataValue::from(1)]) DataValue::List(vec![DataValue::from(true), DataValue::from(1)])
); );
} }
@ -432,13 +432,13 @@ fn test_latest_by() {
.unwrap(); .unwrap();
latest_by_aggr latest_by_aggr
.set(&DataValue::List(vec![ .set(&DataValue::List(vec![
DataValue::Bool(true), DataValue::from(true),
DataValue::from(1), DataValue::from(1),
])) ]))
.unwrap(); .unwrap();
latest_by_aggr latest_by_aggr
.set(&DataValue::List(vec![ .set(&DataValue::List(vec![
DataValue::Bool(false), DataValue::from(false),
DataValue::from(2), DataValue::from(2),
])) ]))
.unwrap(); .unwrap();

241
cozo-core/src/data/tests/functions.rs
Unescape Escape View File

@ -9,7 +9,6 @@
use approx::AbsDiffEq; use approx::AbsDiffEq;
use num_traits::FloatConst; use num_traits::FloatConst;
use regex::Regex; use regex::Regex;
use smartstring::SmartString;
use crate::data::functions::*; use crate::data::functions::*;
use crate::data::value::{DataValue, RegexWrapper}; use crate::data::value::{DataValue, RegexWrapper};
@ -86,23 +85,23 @@ fn test_div() {
fn test_eq_neq() { fn test_eq_neq() {
assert_eq!( assert_eq!(
op_eq(&[DataValue::from(1), DataValue::from(1.0)]).unwrap(), op_eq(&[DataValue::from(1), DataValue::from(1.0)]).unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
assert_eq!( assert_eq!(
op_eq(&[DataValue::from(123), DataValue::from(123)]).unwrap(), op_eq(&[DataValue::from(123), DataValue::from(123)]).unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
assert_eq!( assert_eq!(
op_neq(&[DataValue::from(1), DataValue::from(1.0)]).unwrap(), op_neq(&[DataValue::from(1), DataValue::from(1.0)]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!( assert_eq!(
op_neq(&[DataValue::from(123), DataValue::from(123.0)]).unwrap(), op_neq(&[DataValue::from(123), DataValue::from(123.0)]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!( assert_eq!(
op_eq(&[DataValue::from(123), DataValue::from(123.1)]).unwrap(), op_eq(&[DataValue::from(123), DataValue::from(123.1)]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
} }
@ -127,7 +126,7 @@ fn test_is_in() {
DataValue::List(vec![DataValue::from(1), DataValue::from(2)]) DataValue::List(vec![DataValue::from(1), DataValue::from(2)])
]) ])
.unwrap(), .unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
assert_eq!( assert_eq!(
op_is_in(&[ op_is_in(&[
@ -135,11 +134,11 @@ fn test_is_in() {
DataValue::List(vec![DataValue::from(1), DataValue::from(2)]) DataValue::List(vec![DataValue::from(1), DataValue::from(2)])
]) ])
.unwrap(), .unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!( assert_eq!(
op_is_in(&[DataValue::from(3), DataValue::List(vec![])]).unwrap(), op_is_in(&[DataValue::from(3), DataValue::List(vec![])]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
} }
@ -147,105 +146,105 @@ fn test_is_in() {
fn test_comparators() { fn test_comparators() {
assert_eq!( assert_eq!(
op_ge(&[DataValue::from(2), DataValue::from(1)]).unwrap(), op_ge(&[DataValue::from(2), DataValue::from(1)]).unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
assert_eq!( assert_eq!(
op_ge(&[DataValue::from(2.), DataValue::from(1)]).unwrap(), op_ge(&[DataValue::from(2.), DataValue::from(1)]).unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
assert_eq!( assert_eq!(
op_ge(&[DataValue::from(2), DataValue::from(1.)]).unwrap(), op_ge(&[DataValue::from(2), DataValue::from(1.)]).unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
assert_eq!( assert_eq!(
op_ge(&[DataValue::from(1), DataValue::from(1)]).unwrap(), op_ge(&[DataValue::from(1), DataValue::from(1)]).unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
assert_eq!( assert_eq!(
op_ge(&[DataValue::from(1), DataValue::from(1.0)]).unwrap(), op_ge(&[DataValue::from(1), DataValue::from(1.0)]).unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
assert_eq!( assert_eq!(
op_ge(&[DataValue::from(1), DataValue::from(2)]).unwrap(), op_ge(&[DataValue::from(1), DataValue::from(2)]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert!(op_ge(&[DataValue::Null, DataValue::Bool(true)]).is_err()); assert!(op_ge(&[DataValue::Null, DataValue::from(true)]).is_err());
assert_eq!( assert_eq!(
op_gt(&[DataValue::from(2), DataValue::from(1)]).unwrap(), op_gt(&[DataValue::from(2), DataValue::from(1)]).unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
assert_eq!( assert_eq!(
op_gt(&[DataValue::from(2.), DataValue::from(1)]).unwrap(), op_gt(&[DataValue::from(2.), DataValue::from(1)]).unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
assert_eq!( assert_eq!(
op_gt(&[DataValue::from(2), DataValue::from(1.)]).unwrap(), op_gt(&[DataValue::from(2), DataValue::from(1.)]).unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
assert_eq!( assert_eq!(
op_gt(&[DataValue::from(1), DataValue::from(1)]).unwrap(), op_gt(&[DataValue::from(1), DataValue::from(1)]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!( assert_eq!(
op_gt(&[DataValue::from(1), DataValue::from(1.0)]).unwrap(), op_gt(&[DataValue::from(1), DataValue::from(1.0)]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!( assert_eq!(
op_gt(&[DataValue::from(1), DataValue::from(2)]).unwrap(), op_gt(&[DataValue::from(1), DataValue::from(2)]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert!(op_gt(&[DataValue::Null, DataValue::Bool(true)]).is_err()); assert!(op_gt(&[DataValue::Null, DataValue::from(true)]).is_err());
assert_eq!( assert_eq!(
op_le(&[DataValue::from(2), DataValue::from(1)]).unwrap(), op_le(&[DataValue::from(2), DataValue::from(1)]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!( assert_eq!(
op_le(&[DataValue::from(2.), DataValue::from(1)]).unwrap(), op_le(&[DataValue::from(2.), DataValue::from(1)]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!( assert_eq!(
op_le(&[DataValue::from(2), DataValue::from(1.)]).unwrap(), op_le(&[DataValue::from(2), DataValue::from(1.)]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!( assert_eq!(
op_le(&[DataValue::from(1), DataValue::from(1)]).unwrap(), op_le(&[DataValue::from(1), DataValue::from(1)]).unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
assert_eq!( assert_eq!(
op_le(&[DataValue::from(1), DataValue::from(1.0)]).unwrap(), op_le(&[DataValue::from(1), DataValue::from(1.0)]).unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
assert_eq!( assert_eq!(
op_le(&[DataValue::from(1), DataValue::from(2)]).unwrap(), op_le(&[DataValue::from(1), DataValue::from(2)]).unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
assert!(op_le(&[DataValue::Null, DataValue::Bool(true)]).is_err()); assert!(op_le(&[DataValue::Null, DataValue::from(true)]).is_err());
assert_eq!( assert_eq!(
op_lt(&[DataValue::from(2), DataValue::from(1)]).unwrap(), op_lt(&[DataValue::from(2), DataValue::from(1)]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!( assert_eq!(
op_lt(&[DataValue::from(2.), DataValue::from(1)]).unwrap(), op_lt(&[DataValue::from(2.), DataValue::from(1)]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!( assert_eq!(
op_lt(&[DataValue::from(2), DataValue::from(1.)]).unwrap(), op_lt(&[DataValue::from(2), DataValue::from(1.)]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!( assert_eq!(
op_lt(&[DataValue::from(1), DataValue::from(1)]).unwrap(), op_lt(&[DataValue::from(1), DataValue::from(1)]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!( assert_eq!(
op_lt(&[DataValue::from(1), DataValue::from(1.0)]).unwrap(), op_lt(&[DataValue::from(1), DataValue::from(1.0)]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!( assert_eq!(
op_lt(&[DataValue::from(1), DataValue::from(2)]).unwrap(), op_lt(&[DataValue::from(1), DataValue::from(2)]).unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
assert!(op_lt(&[DataValue::Null, DataValue::Bool(true)]).is_err()); assert!(op_lt(&[DataValue::Null, DataValue::from(true)]).is_err());
} }
#[test] #[test]
@ -281,7 +280,7 @@ fn test_max_min() {
.unwrap(), .unwrap(),
DataValue::from(4.0) DataValue::from(4.0)
); );
assert!(op_max(&[DataValue::Bool(true)]).is_err()); assert!(op_max(&[DataValue::from(true)]).is_err());
assert_eq!(op_min(&[DataValue::from(1),]).unwrap(), DataValue::from(1)); assert_eq!(op_min(&[DataValue::from(1),]).unwrap(), DataValue::from(1));
assert_eq!( assert_eq!(
@ -314,7 +313,7 @@ fn test_max_min() {
.unwrap(), .unwrap(),
DataValue::from(1) DataValue::from(1)
); );
assert!(op_max(&[DataValue::Bool(true)]).is_err()); assert!(op_max(&[DataValue::from(true)]).is_err());
} }
#[test] #[test]
@ -542,19 +541,19 @@ fn test_mod() {
#[test] #[test]
fn test_boolean() { fn test_boolean() {
assert_eq!(op_and(&[]).unwrap(), DataValue::Bool(true)); assert_eq!(op_and(&[]).unwrap(), DataValue::from(true));
assert_eq!( assert_eq!(
op_and(&[DataValue::Bool(true), DataValue::Bool(false)]).unwrap(), op_and(&[DataValue::from(true), DataValue::from(false)]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!(op_or(&[]).unwrap(), DataValue::Bool(false)); assert_eq!(op_or(&[]).unwrap(), DataValue::from(false));
assert_eq!( assert_eq!(
op_or(&[DataValue::Bool(true), DataValue::Bool(false)]).unwrap(), op_or(&[DataValue::from(true), DataValue::from(false)]).unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
assert_eq!( assert_eq!(
op_negate(&[DataValue::Bool(false)]).unwrap(), op_negate(&[DataValue::from(false)]).unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
} }
@ -593,7 +592,7 @@ fn test_bits() {
#[test] #[test]
fn test_pack_bits() { fn test_pack_bits() {
assert_eq!( assert_eq!(
op_pack_bits(&[DataValue::List(vec![DataValue::Bool(true)])]).unwrap(), op_pack_bits(&[DataValue::List(vec![DataValue::from(true)])]).unwrap(),
DataValue::Bytes([0b10000000].into()) DataValue::Bytes([0b10000000].into())
) )
} }
@ -620,14 +619,14 @@ fn test_concat() {
assert_eq!( assert_eq!(
op_concat(&[ op_concat(&[
DataValue::List(vec![DataValue::Bool(true), DataValue::Bool(false)]), DataValue::List(vec![DataValue::from(true), DataValue::from(false)]),
DataValue::List(vec![DataValue::Bool(true)]) DataValue::List(vec![DataValue::from(true)])
]) ])
.unwrap(), .unwrap(),
DataValue::List(vec![ DataValue::List(vec![
DataValue::Bool(true), DataValue::from(true),
DataValue::Bool(false), DataValue::from(false),
DataValue::Bool(true), DataValue::from(true),
]) ])
); );
} }
@ -640,11 +639,11 @@ fn test_str_includes() {
DataValue::Str("bcd".into()) DataValue::Str("bcd".into())
]) ])
.unwrap(), .unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
assert_eq!( assert_eq!(
op_str_includes(&[DataValue::Str("abcdef".into()), DataValue::Str("bd".into())]).unwrap(), op_str_includes(&[DataValue::Str("abcdef".into()), DataValue::Str("bd".into())]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
} }
@ -684,11 +683,11 @@ fn test_starts_ends_with() {
DataValue::Str("abc".into()) DataValue::Str("abc".into())
]) ])
.unwrap(), .unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
assert_eq!( assert_eq!(
op_starts_with(&[DataValue::Str("abcdef".into()), DataValue::Str("bc".into())]).unwrap(), op_starts_with(&[DataValue::Str("abcdef".into()), DataValue::Str("bc".into())]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!( assert_eq!(
op_ends_with(&[ op_ends_with(&[
@ -696,11 +695,11 @@ fn test_starts_ends_with() {
DataValue::Str("def".into()) DataValue::Str("def".into())
]) ])
.unwrap(), .unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
assert_eq!( assert_eq!(
op_ends_with(&[DataValue::Str("abcdef".into()), DataValue::Str("bc".into())]).unwrap(), op_ends_with(&[DataValue::Str("abcdef".into()), DataValue::Str("bc".into())]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
} }
@ -712,7 +711,7 @@ fn test_regex() {
DataValue::Regex(RegexWrapper(Regex::new("c.e").unwrap())) DataValue::Regex(RegexWrapper(Regex::new("c.e").unwrap()))
]) ])
.unwrap(), .unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
assert_eq!( assert_eq!(
@ -721,7 +720,7 @@ fn test_regex() {
DataValue::Regex(RegexWrapper(Regex::new("c.ef$").unwrap())) DataValue::Regex(RegexWrapper(Regex::new("c.ef$").unwrap()))
]) ])
.unwrap(), .unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
assert_eq!( assert_eq!(
@ -730,7 +729,7 @@ fn test_regex() {
DataValue::Regex(RegexWrapper(Regex::new("c.e$").unwrap())) DataValue::Regex(RegexWrapper(Regex::new("c.e$").unwrap()))
]) ])
.unwrap(), .unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!( assert_eq!(
@ -796,107 +795,107 @@ fn test_regex() {
fn test_predicates() { fn test_predicates() {
assert_eq!( assert_eq!(
op_is_null(&[DataValue::Null]).unwrap(), op_is_null(&[DataValue::Null]).unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
assert_eq!( assert_eq!(
op_is_null(&[DataValue::Bot]).unwrap(), op_is_null(&[DataValue::Bot]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!( assert_eq!(
op_is_int(&[DataValue::from(1)]).unwrap(), op_is_int(&[DataValue::from(1)]).unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
assert_eq!( assert_eq!(
op_is_int(&[DataValue::from(1.0)]).unwrap(), op_is_int(&[DataValue::from(1.0)]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!( assert_eq!(
op_is_float(&[DataValue::from(1)]).unwrap(), op_is_float(&[DataValue::from(1)]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!( assert_eq!(
op_is_float(&[DataValue::from(1.0)]).unwrap(), op_is_float(&[DataValue::from(1.0)]).unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
assert_eq!( assert_eq!(
op_is_num(&[DataValue::from(1)]).unwrap(), op_is_num(&[DataValue::from(1)]).unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
assert_eq!( assert_eq!(
op_is_num(&[DataValue::from(1.0)]).unwrap(), op_is_num(&[DataValue::from(1.0)]).unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
assert_eq!( assert_eq!(
op_is_num(&[DataValue::Null]).unwrap(), op_is_num(&[DataValue::Null]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!( assert_eq!(
op_is_bytes(&[DataValue::Bytes([0b1].into())]).unwrap(), op_is_bytes(&[DataValue::Bytes([0b1].into())]).unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
assert_eq!( assert_eq!(
op_is_bytes(&[DataValue::Null]).unwrap(), op_is_bytes(&[DataValue::Null]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!( assert_eq!(
op_is_list(&[DataValue::List(vec![])]).unwrap(), op_is_list(&[DataValue::List(vec![])]).unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
assert_eq!( assert_eq!(
op_is_list(&[DataValue::Null]).unwrap(), op_is_list(&[DataValue::Null]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!( assert_eq!(
op_is_string(&[DataValue::Str("".into())]).unwrap(), op_is_string(&[DataValue::Str("".into())]).unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
assert_eq!( assert_eq!(
op_is_string(&[DataValue::Null]).unwrap(), op_is_string(&[DataValue::Null]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!( assert_eq!(
op_is_finite(&[DataValue::from(1.0)]).unwrap(), op_is_finite(&[DataValue::from(1.0)]).unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
assert_eq!( assert_eq!(
op_is_finite(&[DataValue::from(f64::INFINITY)]).unwrap(), op_is_finite(&[DataValue::from(f64::INFINITY)]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!( assert_eq!(
op_is_finite(&[DataValue::from(f64::NAN)]).unwrap(), op_is_finite(&[DataValue::from(f64::NAN)]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!( assert_eq!(
op_is_infinite(&[DataValue::from(1.0)]).unwrap(), op_is_infinite(&[DataValue::from(1.0)]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!( assert_eq!(
op_is_infinite(&[DataValue::from(f64::INFINITY)]).unwrap(), op_is_infinite(&[DataValue::from(f64::INFINITY)]).unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
assert_eq!( assert_eq!(
op_is_infinite(&[DataValue::from(f64::NEG_INFINITY)]).unwrap(), op_is_infinite(&[DataValue::from(f64::NEG_INFINITY)]).unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
assert_eq!( assert_eq!(
op_is_infinite(&[DataValue::from(f64::NAN)]).unwrap(), op_is_infinite(&[DataValue::from(f64::NAN)]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!( assert_eq!(
op_is_nan(&[DataValue::from(1.0)]).unwrap(), op_is_nan(&[DataValue::from(1.0)]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!( assert_eq!(
op_is_nan(&[DataValue::from(f64::INFINITY)]).unwrap(), op_is_nan(&[DataValue::from(f64::INFINITY)]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!( assert_eq!(
op_is_nan(&[DataValue::from(f64::NEG_INFINITY)]).unwrap(), op_is_nan(&[DataValue::from(f64::NEG_INFINITY)]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!( assert_eq!(
op_is_nan(&[DataValue::from(f64::NAN)]).unwrap(), op_is_nan(&[DataValue::from(f64::NAN)]).unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
} }
@ -1213,7 +1212,7 @@ fn test_encode_decode() {
#[test] #[test]
fn test_to_string() { fn test_to_string() {
assert_eq!( assert_eq!(
op_to_string(&[DataValue::Bool(false)]).unwrap(), op_to_string(&[DataValue::from(false)]).unwrap(),
DataValue::Str("false".into()) DataValue::Str("false".into())
); );
} }
@ -1222,11 +1221,11 @@ fn test_to_string() {
fn test_to_unity() { fn test_to_unity() {
assert_eq!(op_to_unity(&[DataValue::Null]).unwrap(), DataValue::from(0)); assert_eq!(op_to_unity(&[DataValue::Null]).unwrap(), DataValue::from(0));
assert_eq!( assert_eq!(
op_to_unity(&[DataValue::Bool(false)]).unwrap(), op_to_unity(&[DataValue::from(false)]).unwrap(),
DataValue::from(0) DataValue::from(0)
); );
assert_eq!( assert_eq!(
op_to_unity(&[DataValue::Bool(true)]).unwrap(), op_to_unity(&[DataValue::from(true)]).unwrap(),
DataValue::from(1) DataValue::from(1)
); );
assert_eq!( assert_eq!(
@ -1266,11 +1265,11 @@ fn test_to_float() {
DataValue::from(0.0) DataValue::from(0.0)
); );
assert_eq!( assert_eq!(
op_to_float(&[DataValue::Bool(false)]).unwrap(), op_to_float(&[DataValue::from(false)]).unwrap(),
DataValue::from(0.0) DataValue::from(0.0)
); );
assert_eq!( assert_eq!(
op_to_float(&[DataValue::Bool(true)]).unwrap(), op_to_float(&[DataValue::from(true)]).unwrap(),
DataValue::from(1.0) DataValue::from(1.0)
); );
assert_eq!( assert_eq!(
@ -1312,11 +1311,11 @@ fn test_rand() {
assert!(n <= 1.); assert!(n <= 1.);
assert_eq!( assert_eq!(
op_rand_bernoulli(&[DataValue::from(0)]).unwrap(), op_rand_bernoulli(&[DataValue::from(0)]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!( assert_eq!(
op_rand_bernoulli(&[DataValue::from(1)]).unwrap(), op_rand_bernoulli(&[DataValue::from(1)]).unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
assert!(op_rand_bernoulli(&[DataValue::from(2)]).is_err()); assert!(op_rand_bernoulli(&[DataValue::from(2)]).is_err());
let n = op_rand_int(&[DataValue::from(100), DataValue::from(200)]) let n = op_rand_int(&[DataValue::from(100), DataValue::from(200)])
@ -1382,11 +1381,8 @@ fn test_uuid() {
let v4 = op_rand_uuid_v4(&[]).unwrap(); let v4 = op_rand_uuid_v4(&[]).unwrap();
assert!(op_is_uuid(&[v4]).unwrap().get_bool().unwrap()); assert!(op_is_uuid(&[v4]).unwrap().get_bool().unwrap());
assert!(op_uuid_timestamp(&[v1]).unwrap().get_float().is_some()); assert!(op_uuid_timestamp(&[v1]).unwrap().get_float().is_some());
assert!(op_to_uuid(&[DataValue::Str(SmartString::from(""))]).is_err()); assert!(op_to_uuid(&[DataValue::from("")]).is_err());
assert!(op_to_uuid(&[DataValue::Str(SmartString::from( assert!(op_to_uuid(&[DataValue::from("f3b4958c-52a1-11e7-802a-010203040506")]).is_ok());
"f3b4958c-52a1-11e7-802a-010203040506"
))])
.is_ok());
} }
#[test] #[test]
@ -1401,53 +1397,62 @@ fn test_now() {
fn test_to_bool() { fn test_to_bool() {
assert_eq!( assert_eq!(
op_to_bool(&[DataValue::Null]).unwrap(), op_to_bool(&[DataValue::Null]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!( assert_eq!(
op_to_bool(&[DataValue::Bool(true)]).unwrap(), op_to_bool(&[DataValue::from(true)]).unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
assert_eq!( assert_eq!(
op_to_bool(&[DataValue::Bool(false)]).unwrap(), op_to_bool(&[DataValue::from(false)]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!( assert_eq!(
op_to_bool(&[DataValue::from(0)]).unwrap(), op_to_bool(&[DataValue::from(0)]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!( assert_eq!(
op_to_bool(&[DataValue::from(0.0)]).unwrap(), op_to_bool(&[DataValue::from(0.0)]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!( assert_eq!(
op_to_bool(&[DataValue::from(1)]).unwrap(), op_to_bool(&[DataValue::from(1)]).unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
assert_eq!( assert_eq!(
op_to_bool(&[DataValue::Str(SmartString::from(""))]).unwrap(), op_to_bool(&[DataValue::from("")]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!( assert_eq!(
op_to_bool(&[DataValue::Str(SmartString::from("a"))]).unwrap(), op_to_bool(&[DataValue::from("a")]).unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
assert_eq!( assert_eq!(
op_to_bool(&[DataValue::List(vec![])]).unwrap(), op_to_bool(&[DataValue::List(vec![])]).unwrap(),
DataValue::Bool(false) DataValue::from(false)
); );
assert_eq!( assert_eq!(
op_to_bool(&[DataValue::List(vec![DataValue::from(0)])]).unwrap(), op_to_bool(&[DataValue::List(vec![DataValue::from(0)])]).unwrap(),
DataValue::Bool(true) DataValue::from(true)
); );
} }
#[test] #[test]
fn test_coalesce() { fn test_coalesce() {
let db = new_cozo_mem().unwrap(); let db = new_cozo_mem().unwrap();
let res = db.run_script("?[a] := a = null ~ 1 ~ 2", Default::default()).unwrap().rows; let res = db
.run_script("?[a] := a = null ~ 1 ~ 2", Default::default())
.unwrap()
.rows;
assert_eq!(res[0][0], DataValue::from(1)); assert_eq!(res[0][0], DataValue::from(1));
let res = db.run_script("?[a] := a = null ~ null ~ null", Default::default()).unwrap().rows; let res = db
.run_script("?[a] := a = null ~ null ~ null", Default::default())
.unwrap()
.rows;
assert_eq!(res[0][0], DataValue::Null); assert_eq!(res[0][0], DataValue::Null);
let res = db.run_script("?[a] := a = 2 ~ null ~ 1", Default::default()).unwrap().rows; let res = db
.run_script("?[a] := a = 2 ~ null ~ 1", Default::default())
.unwrap()
.rows;
assert_eq!(res[0][0], DataValue::from(2)); assert_eq!(res[0][0], DataValue::from(2));
} }

9
cozo-core/src/data/tests/memcmp.rs
Unescape Escape View File

@ -7,7 +7,6 @@
* *
*/ */
use smartstring::SmartString;
use uuid::Uuid; use uuid::Uuid;
use crate::data::memcmp::{decode_bytes, MemCmpEncoder}; use crate::data::memcmp::{decode_bytes, MemCmpEncoder};
@ -99,22 +98,22 @@ fn specific_encode() {
let mut encoder = vec![]; let mut encoder = vec![];
encoder.encode_datavalue(&DataValue::from(2095)); encoder.encode_datavalue(&DataValue::from(2095));
// println!("e1 {:?}", encoder); // println!("e1 {:?}", encoder);
encoder.encode_datavalue(&DataValue::Str(SmartString::from("MSS"))); encoder.encode_datavalue(&DataValue::from("MSS"));
// println!("e2 {:?}", encoder); // println!("e2 {:?}", encoder);
let (a, remaining) = DataValue::decode_from_key(&encoder); let (a, remaining) = DataValue::decode_from_key(&encoder);
// println!("r {:?}", remaining); // println!("r {:?}", remaining);
let (b, remaining) = DataValue::decode_from_key(remaining); let (b, remaining) = DataValue::decode_from_key(remaining);
assert!(remaining.is_empty()); assert!(remaining.is_empty());
assert_eq!(a, DataValue::from(2095)); assert_eq!(a, DataValue::from(2095));
assert_eq!(b, DataValue::Str(SmartString::from("MSS"))); assert_eq!(b, DataValue::from("MSS"));
} }
#[test] #[test]
fn encode_decode_datavalues() { fn encode_decode_datavalues() {
let mut dv = vec![ let mut dv = vec![
DataValue::Null, DataValue::Null,
DataValue::Bool(false), DataValue::from(false),
DataValue::Bool(true), DataValue::from(true),
DataValue::from(1), DataValue::from(1),
DataValue::from(1.0), DataValue::from(1.0),
DataValue::from(i64::MAX), DataValue::from(i64::MAX),

8
cozo-core/src/data/tests/values.rs
Unescape Escape View File

@ -10,8 +10,6 @@
use std::collections::{BTreeMap, HashMap}; use std::collections::{BTreeMap, HashMap};
use std::mem::size_of; use std::mem::size_of;
use smartstring::SmartString;
use crate::data::symb::Symbol; use crate::data::symb::Symbol;
use crate::data::value::DataValue; use crate::data::value::DataValue;
@ -43,7 +41,7 @@ fn utf8() {
#[test] #[test]
fn display_datavalues() { fn display_datavalues() {
println!("{}", DataValue::Null); println!("{}", DataValue::Null);
println!("{}", DataValue::Bool(true)); println!("{}", DataValue::from(true));
println!("{}", DataValue::from(-1)); println!("{}", DataValue::from(-1));
println!("{}", DataValue::from(-1121212121.331212121)); println!("{}", DataValue::from(-1121212121.331212121));
println!("{}", DataValue::from(f64::NAN)); println!("{}", DataValue::from(f64::NAN));
@ -51,8 +49,8 @@ fn display_datavalues() {
println!( println!(
"{}", "{}",
DataValue::List(vec![ DataValue::List(vec![
DataValue::Bool(false), DataValue::from(false),
DataValue::Str(SmartString::from(r###"abc"你"好'啊👌"###)), DataValue::from(r###"abc"你"好'啊👌"###),
DataValue::from(f64::NEG_INFINITY), DataValue::from(f64::NEG_INFINITY),
]) ])
); );

18
cozo-core/src/data/value.rs
Unescape Escape View File

@ -144,6 +144,24 @@ impl From<f64> for DataValue {
} }
} }
impl From<&str> for DataValue {
fn from(v: &str) -> Self {
DataValue::Str(SmartString::from(v))
}
}
impl From<String> for DataValue {
fn from(v: String) -> Self {
DataValue::Str(SmartString::from(v))
}
}
impl From<bool> for DataValue {
fn from(value: bool) -> Self {
DataValue::Bool(value)
}
}
#[derive(Copy, Clone, serde_derive::Deserialize, serde_derive::Serialize)] #[derive(Copy, Clone, serde_derive::Deserialize, serde_derive::Serialize)]
pub enum Num { pub enum Num {
Int(i64), Int(i64),

2
cozo-core/src/fixed_rule/utilities/csv.rs
Unescape Escape View File

@ -102,7 +102,7 @@ impl FixedRule for CsvReader {
} }
} }
Some(s) => { Some(s) => {
let dv = DataValue::Str(SmartString::from(s)); let dv = DataValue::from(s);
match &typ.coltype { match &typ.coltype {
ColType::Any | ColType::String => out_tuple.push(dv), ColType::Any | ColType::String => out_tuple.push(dv),
ColType::Uuid => out_tuple.push(match op_to_uuid(&[dv]) { ColType::Uuid => out_tuple.push(match op_to_uuid(&[dv]) {

6
cozo-core/src/parse/expr.rs
Unescape Escape View File

@ -194,7 +194,7 @@ fn build_term(pair: Pair<'_>, param_pool: &BTreeMap<String, DataValue>) -> Resul
span, span,
}, },
Rule::boolean => Expr::Const { Rule::boolean => Expr::Const {
val: DataValue::Bool(pair.as_str() == "true"), val: DataValue::from(pair.as_str() == "true"),
span, span,
}, },
Rule::quoted_string | Rule::s_quoted_string | Rule::raw_string => { Rule::quoted_string | Rule::s_quoted_string | Rule::raw_string => {
@ -240,7 +240,7 @@ fn build_term(pair: Pair<'_>, param_pool: &BTreeMap<String, DataValue>) -> Resul
args.insert( args.insert(
args.len() - 1, args.len() - 1,
Expr::Const { Expr::Const {
val: DataValue::Bool(true), val: DataValue::from(true),
span: args.last().unwrap().span(), span: args.last().unwrap().span(),
}, },
) )
@ -267,7 +267,7 @@ fn build_term(pair: Pair<'_>, param_pool: &BTreeMap<String, DataValue>) -> Resul
if let Some(else_clause) = args.next() { if let Some(else_clause) = args.next() {
clauses.push(( clauses.push((
Expr::Const { Expr::Const {
val: DataValue::Bool(true), val: DataValue::from(true),
span, span,
}, },
else_clause, else_clause,

28
cozo-core/src/runtime/db.rs
Unescape Escape View File

@ -764,7 +764,7 @@ impl<'s, S: Storage<'s>> Db<S> {
self.compact_relation()?; self.compact_relation()?;
Ok(NamedRows { Ok(NamedRows {
headers: vec![STATUS_STR.to_string()], headers: vec![STATUS_STR.to_string()],
rows: vec![vec![DataValue::Str(SmartString::from(OK_STR))]], rows: vec![vec![DataValue::from(OK_STR)]],
}) })
} }
SysOp::ListRelations => self.list_relations(), SysOp::ListRelations => self.list_relations(),
@ -783,7 +783,7 @@ impl<'s, S: Storage<'s>> Db<S> {
} }
Ok(NamedRows { Ok(NamedRows {
headers: vec![STATUS_STR.to_string()], headers: vec![STATUS_STR.to_string()],
rows: vec![vec![DataValue::Str(SmartString::from(OK_STR))]], rows: vec![vec![DataValue::from(OK_STR)]],
}) })
} }
SysOp::ListRelation(rs) => self.list_relation(&rs), SysOp::ListRelation(rs) => self.list_relation(&rs),
@ -795,7 +795,7 @@ impl<'s, S: Storage<'s>> Db<S> {
tx.commit_tx()?; tx.commit_tx()?;
Ok(NamedRows { Ok(NamedRows {
headers: vec![STATUS_STR.to_string()], headers: vec![STATUS_STR.to_string()],
rows: vec![vec![DataValue::Str(SmartString::from(OK_STR))]], rows: vec![vec![DataValue::from(OK_STR)]],
}) })
} }
SysOp::ListRunning => self.list_running(), SysOp::ListRunning => self.list_running(),
@ -804,13 +804,13 @@ impl<'s, S: Storage<'s>> Db<S> {
Ok(match queries.get(&id) { Ok(match queries.get(&id) {
None => NamedRows { None => NamedRows {
headers: vec![STATUS_STR.to_string()], headers: vec![STATUS_STR.to_string()],
rows: vec![vec![DataValue::Str(SmartString::from("NOT_FOUND"))]], rows: vec![vec![DataValue::from("NOT_FOUND")]],
}, },
Some(handle) => { Some(handle) => {
handle.poison.0.store(true, Ordering::Relaxed); handle.poison.0.store(true, Ordering::Relaxed);
NamedRows { NamedRows {
headers: vec![STATUS_STR.to_string()], headers: vec![STATUS_STR.to_string()],
rows: vec![vec![DataValue::Str(SmartString::from("KILLING"))]], rows: vec![vec![DataValue::from("KILLING")]],
} }
} }
}) })
@ -848,7 +848,7 @@ impl<'s, S: Storage<'s>> Db<S> {
tx.commit_tx()?; tx.commit_tx()?;
Ok(NamedRows { Ok(NamedRows {
headers: vec![STATUS_STR.to_string()], headers: vec![STATUS_STR.to_string()],
rows: vec![vec![DataValue::Str(SmartString::from(OK_STR))]], rows: vec![vec![DataValue::from(OK_STR)]],
}) })
} }
SysOp::SetAccessLevel(names, level) => { SysOp::SetAccessLevel(names, level) => {
@ -859,7 +859,7 @@ impl<'s, S: Storage<'s>> Db<S> {
tx.commit_tx()?; tx.commit_tx()?;
Ok(NamedRows { Ok(NamedRows {
headers: vec![STATUS_STR.to_string()], headers: vec![STATUS_STR.to_string()],
rows: vec![vec![DataValue::Str(SmartString::from(OK_STR))]], rows: vec![vec![DataValue::from(OK_STR)]],
}) })
} }
} }
@ -1018,7 +1018,7 @@ impl<'s, S: Storage<'s>> Db<S> {
Ok(( Ok((
NamedRows { NamedRows {
headers: vec![STATUS_STR.to_string()], headers: vec![STATUS_STR.to_string()],
rows: vec![vec![DataValue::Str(SmartString::from(OK_STR))]], rows: vec![vec![DataValue::from(OK_STR)]],
}, },
clean_ups, clean_ups,
)) ))
@ -1070,7 +1070,7 @@ impl<'s, S: Storage<'s>> Db<S> {
Ok(( Ok((
NamedRows { NamedRows {
headers: vec![STATUS_STR.to_string()], headers: vec![STATUS_STR.to_string()],
rows: vec![vec![DataValue::Str(SmartString::from(OK_STR))]], rows: vec![vec![DataValue::from(OK_STR)]],
}, },
clean_ups, clean_ups,
)) ))
@ -1099,7 +1099,7 @@ impl<'s, S: Storage<'s>> Db<S> {
.map(|(k, v)| { .map(|(k, v)| {
vec![ vec![
DataValue::from(*k as i64), DataValue::from(*k as i64),
DataValue::Str(SmartString::from(format!("{:?}", v.started_at))), DataValue::from(format!("{:?}", v.started_at)),
] ]
}) })
.collect_vec(); .collect_vec();
@ -1154,11 +1154,9 @@ impl<'s, S: Storage<'s>> Db<S> {
}) })
} }
fn list_relations(&'s self) -> Result<NamedRows> { fn list_relations(&'s self) -> Result<NamedRows> {
let lower = vec![DataValue::Str(SmartString::from(""))].encode_as_key(RelationId::SYSTEM); let lower = vec![DataValue::from("")].encode_as_key(RelationId::SYSTEM);
let upper = vec![DataValue::Str(SmartString::from(String::from( let upper =
LARGEST_UTF_CHAR, vec![DataValue::from(String::from(LARGEST_UTF_CHAR))].encode_as_key(RelationId::SYSTEM);
)))]
.encode_as_key(RelationId::SYSTEM);
let tx = self.db.transact(false)?; let tx = self.db.transact(false)?;
let mut rows: Vec<Vec<JsonValue>> = vec![]; let mut rows: Vec<Vec<JsonValue>> = vec![];
for kv_res in tx.range_scan(&lower, &upper) { for kv_res in tx.range_scan(&lower, &upper) {

25
cozo-core/src/runtime/relation.rs
Unescape Escape View File

@ -163,7 +163,11 @@ impl RelationHandle {
tuple.serialize(&mut Serializer::new(&mut ret)).unwrap(); tuple.serialize(&mut Serializer::new(&mut ret)).unwrap();
Ok(ret) Ok(ret)
} }
pub(crate) fn ensure_compatible(&self, inp: &InputRelationHandle, is_remove: bool) -> Result<()> { pub(crate) fn ensure_compatible(
&self,
inp: &InputRelationHandle,
is_remove: bool,
) -> Result<()> {
let InputRelationHandle { metadata, .. } = inp; let InputRelationHandle { metadata, .. } = inp;
// check that every given key is found and compatible // check that every given key is found and compatible
for col in &metadata.keys { for col in &metadata.keys {
@ -203,8 +207,10 @@ impl Debug for RelationHandle {
#[derive(thiserror::Error, miette::Diagnostic, Debug)] #[derive(thiserror::Error, miette::Diagnostic, Debug)]
#[error("Cannot deserialize relation")] #[error("Cannot deserialize relation")]
#[diagnostic(code(deser::relation))] #[diagnostic(code(deser::relation))]
#[diagnostic(help("This could indicate a bug, or you are using an incompatible DB version. \ #[diagnostic(help(
Consider file a bug report."))] "This could indicate a bug, or you are using an incompatible DB version. \
Consider file a bug report."
))]
pub(crate) struct RelationDeserError; pub(crate) struct RelationDeserError;
impl RelationHandle { impl RelationHandle {
@ -239,11 +245,7 @@ impl RelationHandle {
tx.store_tx.range_skip_scan_tuple(&lower, &upper, valid_at) tx.store_tx.range_skip_scan_tuple(&lower, &upper, valid_at)
} }
pub(crate) fn get( pub(crate) fn get(&self, tx: &SessionTx<'_>, key: &[DataValue]) -> Result<Option<Tuple>> {
&self,
tx: &SessionTx<'_>,
key: &[DataValue],
) -> Result<Option<Tuple>> {
let key_data = key.encode_as_key(self.id); let key_data = key.encode_as_key(self.id);
Ok(tx Ok(tx
.store_tx .store_tx
@ -346,7 +348,7 @@ struct RelNameConflictError(String);
impl<'a> SessionTx<'a> { impl<'a> SessionTx<'a> {
pub(crate) fn relation_exists(&self, name: &str) -> Result<bool> { pub(crate) fn relation_exists(&self, name: &str) -> Result<bool> {
let key = DataValue::Str(SmartString::from(name)); let key = DataValue::from(name);
let encoded = vec![key].encode_as_key(RelationId::SYSTEM); let encoded = vec![key].encode_as_key(RelationId::SYSTEM);
self.store_tx.exists(&encoded, false) self.store_tx.exists(&encoded, false)
} }
@ -422,7 +424,7 @@ impl<'a> SessionTx<'a> {
#[diagnostic(code(query::relation_not_found))] #[diagnostic(code(query::relation_not_found))]
struct StoredRelationNotFoundError(String); struct StoredRelationNotFoundError(String);
let key = DataValue::Str(SmartString::from(name as &str)); let key = DataValue::from(name);
let encoded = vec![key].encode_as_key(RelationId::SYSTEM); let encoded = vec![key].encode_as_key(RelationId::SYSTEM);
let found = self let found = self
@ -441,7 +443,7 @@ impl<'a> SessionTx<'a> {
store.access_level store.access_level
)) ))
} }
let key = DataValue::Str(SmartString::from(name as &str)); let key = DataValue::from(name);
let encoded = vec![key].encode_as_key(RelationId::SYSTEM); let encoded = vec![key].encode_as_key(RelationId::SYSTEM);
self.store_tx.del(&encoded)?; self.store_tx.del(&encoded)?;
let lower_bound = Tuple::default().encode_as_key(store.id); let lower_bound = Tuple::default().encode_as_key(store.id);
@ -498,4 +500,3 @@ pub(crate) struct InsufficientAccessLevel(
pub(crate) String, pub(crate) String,
pub(crate) AccessLevel, pub(crate) AccessLevel,
); );

3
cozo-core/src/runtime/tests.rs
Unescape Escape View File

@ -10,7 +10,6 @@
use crate::data::value::DataValue; use crate::data::value::DataValue;
use log::debug; use log::debug;
use serde_json::json; use serde_json::json;
use smartstring::SmartString;
use crate::new_cozo_mem; use crate::new_cozo_mem;
@ -139,7 +138,7 @@ grandparent[gcld, gp] := parent[gcld, p], parent[p, gp]
.unwrap() .unwrap()
.rows; .rows;
println!("{:?}", res); println!("{:?}", res);
assert_eq!(res[0][0], DataValue::Str(SmartString::from("jakob"))) assert_eq!(res[0][0], DataValue::from("jakob"))
} }
#[test] #[test]

Write Preview
Loading…
Cancel
Save