cleanup of type conversion

cozo-core/src/data/aggr.rs

@@ -87,7 +87,7 @@ impl NormalAggrObj for AggrAnd {
     }
 
     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 {
     fn init_val(&self) -> DataValue {
-        DataValue::Bool(true)
+        DataValue::from(true)
     }
 
     fn update(&self, left: &mut DataValue, right: &DataValue) -> Result<bool> {
@@ -127,7 +127,7 @@ impl NormalAggrObj for AggrOr {
     }
 
     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 {
     fn init_val(&self) -> DataValue {
-        DataValue::Bool(false)
+        DataValue::from(false)
     }
 
     fn update(&self, left: &mut DataValue, right: &DataValue) -> Result<bool> {

cozo-core/src/data/expr.rs

@@ -456,7 +456,7 @@ impl Expr {
 
                                     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 mut upper = SmartString::from(s);
                                 // let mut upper = s.to_string();

cozo-core/src/data/functions.rs

@@ -78,7 +78,7 @@ pub(crate) fn op_coalesce(args: &[DataValue]) -> Result<DataValue> {
 
 define_op!(OP_EQ, 2, false);
 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::Int(i)), DataValue::Num(Num::Float(f))) => *i as f64 == *f,
         (a, b) => a == b,
@@ -87,7 +87,7 @@ pub(crate) fn op_eq(args: &[DataValue]) -> Result<DataValue> {
 
 define_op!(OP_IS_UUID, 1, false);
 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);
@@ -96,12 +96,12 @@ pub(crate) fn op_is_in(args: &[DataValue]) -> Result<DataValue> {
     let right = args[1]
         .get_slice()
         .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);
 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::Int(i)), DataValue::Num(Num::Float(f))) => *i as f64 != *f,
         (a, b) => a != b,
@@ -111,7 +111,7 @@ pub(crate) fn op_neq(args: &[DataValue]) -> Result<DataValue> {
 define_op!(OP_GT, 2, false);
 pub(crate) fn op_gt(args: &[DataValue]) -> Result<DataValue> {
     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::Int(l)), DataValue::Num(Num::Float(r))) => *l as f64 > *r,
         (a, b) => a > b,
@@ -121,7 +121,7 @@ pub(crate) fn op_gt(args: &[DataValue]) -> Result<DataValue> {
 define_op!(OP_GE, 2, false);
 pub(crate) fn op_ge(args: &[DataValue]) -> Result<DataValue> {
     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::Int(l)), DataValue::Num(Num::Float(r))) => *l as f64 >= *r,
         (a, b) => a >= b,
@@ -131,7 +131,7 @@ pub(crate) fn op_ge(args: &[DataValue]) -> Result<DataValue> {
 define_op!(OP_LT, 2, false);
 pub(crate) fn op_lt(args: &[DataValue]) -> Result<DataValue> {
     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::Int(l)), DataValue::Num(Num::Float(r))) => (*l as f64) < *r,
         (a, b) => a < b,
@@ -141,7 +141,7 @@ pub(crate) fn op_lt(args: &[DataValue]) -> Result<DataValue> {
 define_op!(OP_LE, 2, false);
 pub(crate) fn op_le(args: &[DataValue]) -> Result<DataValue> {
     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::Int(l)), DataValue::Num(Num::Float(r))) => (*l as f64) <= *r,
         (a, b) => a <= b,
@@ -543,10 +543,10 @@ pub(crate) fn op_and(args: &[DataValue]) -> Result<DataValue> {
             .get_bool()
             .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);
@@ -556,16 +556,16 @@ pub(crate) fn op_or(args: &[DataValue]) -> Result<DataValue> {
             .get_bool()
             .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);
 pub(crate) fn op_negate(args: &[DataValue]) -> Result<DataValue> {
     if let DataValue::Bool(b) = &args[0] {
-        Ok(DataValue::Bool(!*b))
+        Ok(DataValue::from(!*b))
     } else {
         bail!("'negate' requires booleans");
     }
@@ -710,7 +710,7 @@ pub(crate) fn op_concat(args: &[DataValue]) -> Result<DataValue> {
                     bail!("'concat' requires strings, or lists");
                 }
             }
-            Ok(DataValue::Str(SmartString::from(ret)))
+            Ok(DataValue::from(ret))
         }
         DataValue::List(_) | DataValue::Set(_) => {
             let mut ret = vec![];
@@ -732,7 +732,7 @@ pub(crate) fn op_concat(args: &[DataValue]) -> Result<DataValue> {
 define_op!(OP_STR_INCLUDES, 2, false);
 pub(crate) fn op_str_includes(args: &[DataValue]) -> Result<DataValue> {
     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"),
     }
 }
@@ -740,7 +740,7 @@ pub(crate) fn op_str_includes(args: &[DataValue]) -> Result<DataValue> {
 define_op!(OP_LOWERCASE, 1, false);
 pub(crate) fn op_lowercase(args: &[DataValue]) -> Result<DataValue> {
     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"),
     }
 }
@@ -748,7 +748,7 @@ pub(crate) fn op_lowercase(args: &[DataValue]) -> Result<DataValue> {
 define_op!(OP_UPPERCASE, 1, false);
 pub(crate) fn op_uppercase(args: &[DataValue]) -> Result<DataValue> {
     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"),
     }
 }
@@ -756,7 +756,7 @@ pub(crate) fn op_uppercase(args: &[DataValue]) -> Result<DataValue> {
 define_op!(OP_TRIM, 1, false);
 pub(crate) fn op_trim(args: &[DataValue]) -> Result<DataValue> {
     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"),
     }
 }
@@ -764,7 +764,7 @@ pub(crate) fn op_trim(args: &[DataValue]) -> Result<DataValue> {
 define_op!(OP_TRIM_START, 1, false);
 pub(crate) fn op_trim_start(args: &[DataValue]) -> Result<DataValue> {
     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"),
     }
 }
@@ -772,7 +772,7 @@ pub(crate) fn op_trim_start(args: &[DataValue]) -> Result<DataValue> {
 define_op!(OP_TRIM_END, 1, false);
 pub(crate) fn op_trim_end(args: &[DataValue]) -> Result<DataValue> {
     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"),
     }
 }
@@ -787,7 +787,7 @@ pub(crate) fn op_starts_with(args: &[DataValue]) -> Result<DataValue> {
         DataValue::Str(s) => s,
         _ => 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);
@@ -800,7 +800,7 @@ pub(crate) fn op_ends_with(args: &[DataValue]) -> Result<DataValue> {
         DataValue::Str(s) => s,
         _ => 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);
@@ -819,7 +819,7 @@ pub(crate) fn op_regex(args: &[DataValue]) -> Result<DataValue> {
 define_op!(OP_REGEX_MATCHES, 2, false);
 pub(crate) fn op_regex_matches(args: &[DataValue]) -> Result<DataValue> {
     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"),
     }
 }
@@ -850,7 +850,7 @@ pub(crate) fn op_regex_extract(args: &[DataValue]) -> Result<DataValue> {
         (DataValue::Str(s), DataValue::Regex(r)) => {
             let found =
                 r.0.find_iter(s)
-                    .map(|v| DataValue::Str(SmartString::from(v.as_str())))
+                    .map(|v| DataValue::from(v.as_str()))
                     .collect_vec();
             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> {
     match (&args[0], &args[1]) {
         (DataValue::Str(s), DataValue::Regex(r)) => {
-            let found =
-                r.0.find(s)
-                    .map(|v| DataValue::Str(SmartString::from(v.as_str())));
+            let found = r.0.find(s).map(|v| DataValue::from(v.as_str()));
             Ok(found.unwrap_or(DataValue::Null))
         }
         _ => 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);
 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);
 pub(crate) fn op_is_int(args: &[DataValue]) -> Result<DataValue> {
-    Ok(DataValue::Bool(matches!(
+    Ok(DataValue::from(matches!(
         args[0],
         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);
 pub(crate) fn op_is_float(args: &[DataValue]) -> Result<DataValue> {
-    Ok(DataValue::Bool(matches!(
+    Ok(DataValue::from(matches!(
         args[0],
         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);
 pub(crate) fn op_is_num(args: &[DataValue]) -> Result<DataValue> {
-    Ok(DataValue::Bool(matches!(
+    Ok(DataValue::from(matches!(
         args[0],
         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);
 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::Float(f)) => f.is_finite(),
         _ => false,
@@ -911,7 +909,7 @@ pub(crate) fn op_is_finite(args: &[DataValue]) -> Result<DataValue> {
 
 define_op!(OP_IS_INFINITE, 1, false);
 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(),
         _ => false,
     }))
@@ -919,7 +917,7 @@ pub(crate) fn op_is_infinite(args: &[DataValue]) -> Result<DataValue> {
 
 define_op!(OP_IS_NAN, 1, false);
 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(),
         _ => false,
     }))
@@ -927,12 +925,12 @@ pub(crate) fn op_is_nan(args: &[DataValue]) -> Result<DataValue> {
 
 define_op!(OP_IS_STRING, 1, false);
 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);
 pub(crate) fn op_is_list(args: &[DataValue]) -> Result<DataValue> {
-    Ok(DataValue::Bool(matches!(
+    Ok(DataValue::from(matches!(
         args[0],
         DataValue::List(_) | DataValue::Set(_)
     )))
@@ -974,7 +972,7 @@ pub(crate) fn op_prepend(args: &[DataValue]) -> Result<DataValue> {
 
 define_op!(OP_IS_BYTES, 1, false);
 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);
@@ -1235,7 +1233,7 @@ pub(crate) fn op_from_substrings(args: &[DataValue]) -> Result<DataValue> {
         }
         _ => 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);
@@ -1243,7 +1241,7 @@ pub(crate) fn op_encode_base64(args: &[DataValue]) -> Result<DataValue> {
     match &args[0] {
         DataValue::Bytes(b) => {
             let s = base64::encode(b);
-            Ok(DataValue::Str(SmartString::from(s)))
+            Ok(DataValue::from(s))
         }
         _ => 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);
 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::Bool(b) => *b,
         DataValue::Num(n) => n.get_int() != Some(0),
@@ -1344,7 +1342,7 @@ pub(crate) fn op_to_string(args: &[DataValue]) -> Result<DataValue> {
         v => {
             let jv = JsonValue::from(v.clone());
             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."),
     };
-    Ok(DataValue::Bool(thread_rng().gen_bool(prob)))
+    Ok(DataValue::from(thread_rng().gen_bool(prob)))
 }
 
 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);
 pub(crate) fn op_assert(args: &[DataValue]) -> Result<DataValue> {
     match &args[0] {
-        DataValue::Bool(true) => Ok(DataValue::Bool(true)),
+        DataValue::Bool(true) => Ok(DataValue::from(true)),
         _ => bail!("assertion failed: {:?}", args),
     }
 }

cozo-core/src/data/json.rs

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

cozo-core/src/data/memcmp.rs

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

cozo-core/src/data/relation.rs

@@ -170,8 +170,19 @@ impl NullableColType {
         let make_err = || DataCoercionFailed(self.clone(), data.clone());
 
         Ok(match &self.coltype {
-            ColType::Any => data,
-            ColType::Bool => DataValue::Bool(data.get_bool().ok_or_else(make_err)?),
+            ColType::Any => match data {
+                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::Float => DataValue::from(data.get_float().ok_or_else(make_err)?),
             ColType::String => {

cozo-core/src/data/tests/aggrs.rs

@@ -18,27 +18,27 @@ fn test_and() {
     aggr.normal_init(&[]).unwrap();
     aggr.meet_init(&[]).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::Bool(true)).unwrap();
+    and_aggr.set(&DataValue::from(true)).unwrap();
+    and_aggr.set(&DataValue::from(true)).unwrap();
 
-    assert_eq!(and_aggr.get().unwrap(), DataValue::Bool(true));
-    and_aggr.set(&DataValue::Bool(false)).unwrap();
+    assert_eq!(and_aggr.get().unwrap(), DataValue::from(true));
+    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 mut v = DataValue::Bool(true);
+    let mut v = DataValue::from(true);
 
-    m_and_aggr.update(&mut v, &DataValue::Bool(true)).unwrap();
-    assert_eq!(v, DataValue::Bool(true));
+    m_and_aggr.update(&mut v, &DataValue::from(true)).unwrap();
+    assert_eq!(v, DataValue::from(true));
 
-    m_and_aggr.update(&mut v, &DataValue::Bool(false)).unwrap();
-    assert_eq!(v, DataValue::Bool(false));
+    m_and_aggr.update(&mut v, &DataValue::from(false)).unwrap();
+    assert_eq!(v, DataValue::from(false));
 
-    m_and_aggr.update(&mut v, &DataValue::Bool(true)).unwrap();
-    assert_eq!(v, DataValue::Bool(false));
+    m_and_aggr.update(&mut v, &DataValue::from(true)).unwrap();
+    assert_eq!(v, DataValue::from(false));
 }
 
 #[test]
@@ -48,27 +48,27 @@ fn test_or() {
     aggr.meet_init(&[]).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::Bool(false)).unwrap();
+    or_aggr.set(&DataValue::from(false)).unwrap();
+    or_aggr.set(&DataValue::from(false)).unwrap();
 
-    assert_eq!(or_aggr.get().unwrap(), DataValue::Bool(false));
-    or_aggr.set(&DataValue::Bool(true)).unwrap();
+    assert_eq!(or_aggr.get().unwrap(), DataValue::from(false));
+    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 mut v = DataValue::Bool(false);
+    let mut v = DataValue::from(false);
 
-    m_or_aggr.update(&mut v, &DataValue::Bool(false)).unwrap();
-    assert_eq!(v, DataValue::Bool(false));
+    m_or_aggr.update(&mut v, &DataValue::from(false)).unwrap();
+    assert_eq!(v, DataValue::from(false));
 
-    m_or_aggr.update(&mut v, &DataValue::Bool(true)).unwrap();
-    assert_eq!(v, DataValue::Bool(true));
+    m_or_aggr.update(&mut v, &DataValue::from(true)).unwrap();
+    assert_eq!(v, DataValue::from(true));
 
-    m_or_aggr.update(&mut v, &DataValue::Bool(false)).unwrap();
-    assert_eq!(v, DataValue::Bool(true));
+    m_or_aggr.update(&mut v, &DataValue::from(false)).unwrap();
+    assert_eq!(v, DataValue::from(true));
 }
 
 #[test]
@@ -77,14 +77,14 @@ fn test_unique() {
     aggr.normal_init(&[]).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(2)).unwrap();
     unique_aggr.set(&DataValue::from(1)).unwrap();
     assert_eq!(
         unique_aggr.get().unwrap(),
         DataValue::List(vec![
-            DataValue::Bool(true),
+            DataValue::from(true),
             DataValue::from(1),
             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::Bool(true)).unwrap();
-    count_aggr.set(&DataValue::Bool(true)).unwrap();
+    count_aggr.set(&DataValue::from(true)).unwrap();
+    count_aggr.set(&DataValue::from(true)).unwrap();
     assert_eq!(count_aggr.get().unwrap(), DataValue::from(6));
 }
 
@@ -386,19 +386,19 @@ fn test_min_cost() {
         .unwrap();
     min_cost_aggr
         .set(&DataValue::List(vec![
-            DataValue::Bool(true),
+            DataValue::from(true),
             DataValue::from(1),
         ]))
         .unwrap();
     min_cost_aggr
         .set(&DataValue::List(vec![
-            DataValue::Bool(false),
+            DataValue::from(false),
             DataValue::from(2),
         ]))
         .unwrap();
     assert_eq!(
         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();
@@ -406,18 +406,18 @@ fn test_min_cost() {
     m_min_cost_aggr
         .update(
             &mut v,
-            &DataValue::List(vec![DataValue::Bool(true), DataValue::from(1)]),
+            &DataValue::List(vec![DataValue::from(true), DataValue::from(1)]),
         )
         .unwrap();
     m_min_cost_aggr
         .update(
             &mut v,
-            &DataValue::List(vec![DataValue::Bool(false), DataValue::from(2)]),
+            &DataValue::List(vec![DataValue::from(false), DataValue::from(2)]),
         )
         .unwrap();
     assert_eq!(
         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();
     latest_by_aggr
         .set(&DataValue::List(vec![
-            DataValue::Bool(true),
+            DataValue::from(true),
             DataValue::from(1),
         ]))
         .unwrap();
     latest_by_aggr
         .set(&DataValue::List(vec![
-            DataValue::Bool(false),
+            DataValue::from(false),
             DataValue::from(2),
         ]))
         .unwrap();

cozo-core/src/data/tests/functions.rs

@@ -9,7 +9,6 @@
 use approx::AbsDiffEq;
 use num_traits::FloatConst;
 use regex::Regex;
-use smartstring::SmartString;
 
 use crate::data::functions::*;
 use crate::data::value::{DataValue, RegexWrapper};
@@ -86,23 +85,23 @@ fn test_div() {
 fn test_eq_neq() {
     assert_eq!(
         op_eq(&[DataValue::from(1), DataValue::from(1.0)]).unwrap(),
-        DataValue::Bool(true)
+        DataValue::from(true)
     );
     assert_eq!(
         op_eq(&[DataValue::from(123), DataValue::from(123)]).unwrap(),
-        DataValue::Bool(true)
+        DataValue::from(true)
     );
     assert_eq!(
         op_neq(&[DataValue::from(1), DataValue::from(1.0)]).unwrap(),
-        DataValue::Bool(false)
+        DataValue::from(false)
     );
     assert_eq!(
         op_neq(&[DataValue::from(123), DataValue::from(123.0)]).unwrap(),
-        DataValue::Bool(false)
+        DataValue::from(false)
     );
     assert_eq!(
         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)])
         ])
         .unwrap(),
-        DataValue::Bool(true)
+        DataValue::from(true)
     );
     assert_eq!(
         op_is_in(&[
@@ -135,11 +134,11 @@ fn test_is_in() {
             DataValue::List(vec![DataValue::from(1), DataValue::from(2)])
         ])
         .unwrap(),
-        DataValue::Bool(false)
+        DataValue::from(false)
     );
     assert_eq!(
         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() {
     assert_eq!(
         op_ge(&[DataValue::from(2), DataValue::from(1)]).unwrap(),
-        DataValue::Bool(true)
+        DataValue::from(true)
     );
     assert_eq!(
         op_ge(&[DataValue::from(2.), DataValue::from(1)]).unwrap(),
-        DataValue::Bool(true)
+        DataValue::from(true)
     );
     assert_eq!(
         op_ge(&[DataValue::from(2), DataValue::from(1.)]).unwrap(),
-        DataValue::Bool(true)
+        DataValue::from(true)
     );
 
     assert_eq!(
         op_ge(&[DataValue::from(1), DataValue::from(1)]).unwrap(),
-        DataValue::Bool(true)
+        DataValue::from(true)
     );
     assert_eq!(
         op_ge(&[DataValue::from(1), DataValue::from(1.0)]).unwrap(),
-        DataValue::Bool(true)
+        DataValue::from(true)
     );
     assert_eq!(
         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!(
         op_gt(&[DataValue::from(2), DataValue::from(1)]).unwrap(),
-        DataValue::Bool(true)
+        DataValue::from(true)
     );
     assert_eq!(
         op_gt(&[DataValue::from(2.), DataValue::from(1)]).unwrap(),
-        DataValue::Bool(true)
+        DataValue::from(true)
     );
     assert_eq!(
         op_gt(&[DataValue::from(2), DataValue::from(1.)]).unwrap(),
-        DataValue::Bool(true)
+        DataValue::from(true)
     );
     assert_eq!(
         op_gt(&[DataValue::from(1), DataValue::from(1)]).unwrap(),
-        DataValue::Bool(false)
+        DataValue::from(false)
     );
     assert_eq!(
         op_gt(&[DataValue::from(1), DataValue::from(1.0)]).unwrap(),
-        DataValue::Bool(false)
+        DataValue::from(false)
     );
     assert_eq!(
         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!(
         op_le(&[DataValue::from(2), DataValue::from(1)]).unwrap(),
-        DataValue::Bool(false)
+        DataValue::from(false)
     );
     assert_eq!(
         op_le(&[DataValue::from(2.), DataValue::from(1)]).unwrap(),
-        DataValue::Bool(false)
+        DataValue::from(false)
     );
     assert_eq!(
         op_le(&[DataValue::from(2), DataValue::from(1.)]).unwrap(),
-        DataValue::Bool(false)
+        DataValue::from(false)
     );
     assert_eq!(
         op_le(&[DataValue::from(1), DataValue::from(1)]).unwrap(),
-        DataValue::Bool(true)
+        DataValue::from(true)
     );
     assert_eq!(
         op_le(&[DataValue::from(1), DataValue::from(1.0)]).unwrap(),
-        DataValue::Bool(true)
+        DataValue::from(true)
     );
     assert_eq!(
         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!(
         op_lt(&[DataValue::from(2), DataValue::from(1)]).unwrap(),
-        DataValue::Bool(false)
+        DataValue::from(false)
     );
     assert_eq!(
         op_lt(&[DataValue::from(2.), DataValue::from(1)]).unwrap(),
-        DataValue::Bool(false)
+        DataValue::from(false)
     );
     assert_eq!(
         op_lt(&[DataValue::from(2), DataValue::from(1.)]).unwrap(),
-        DataValue::Bool(false)
+        DataValue::from(false)
     );
     assert_eq!(
         op_lt(&[DataValue::from(1), DataValue::from(1)]).unwrap(),
-        DataValue::Bool(false)
+        DataValue::from(false)
     );
     assert_eq!(
         op_lt(&[DataValue::from(1), DataValue::from(1.0)]).unwrap(),
-        DataValue::Bool(false)
+        DataValue::from(false)
     );
     assert_eq!(
         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]
@@ -281,7 +280,7 @@ fn test_max_min() {
         .unwrap(),
         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!(
@@ -314,7 +313,7 @@ fn test_max_min() {
         .unwrap(),
         DataValue::from(1)
     );
-    assert!(op_max(&[DataValue::Bool(true)]).is_err());
+    assert!(op_max(&[DataValue::from(true)]).is_err());
 }
 
 #[test]
@@ -542,19 +541,19 @@ fn test_mod() {
 
 #[test]
 fn test_boolean() {
-    assert_eq!(op_and(&[]).unwrap(), DataValue::Bool(true));
+    assert_eq!(op_and(&[]).unwrap(), DataValue::from(true));
     assert_eq!(
-        op_and(&[DataValue::Bool(true), DataValue::Bool(false)]).unwrap(),
-        DataValue::Bool(false)
+        op_and(&[DataValue::from(true), DataValue::from(false)]).unwrap(),
+        DataValue::from(false)
     );
-    assert_eq!(op_or(&[]).unwrap(), DataValue::Bool(false));
+    assert_eq!(op_or(&[]).unwrap(), DataValue::from(false));
     assert_eq!(
-        op_or(&[DataValue::Bool(true), DataValue::Bool(false)]).unwrap(),
-        DataValue::Bool(true)
+        op_or(&[DataValue::from(true), DataValue::from(false)]).unwrap(),
+        DataValue::from(true)
     );
     assert_eq!(
-        op_negate(&[DataValue::Bool(false)]).unwrap(),
-        DataValue::Bool(true)
+        op_negate(&[DataValue::from(false)]).unwrap(),
+        DataValue::from(true)
     );
 }
 
@@ -593,7 +592,7 @@ fn test_bits() {
 #[test]
 fn test_pack_bits() {
     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())
     )
 }
@@ -620,14 +619,14 @@ fn test_concat() {
 
     assert_eq!(
         op_concat(&[
-            DataValue::List(vec![DataValue::Bool(true), DataValue::Bool(false)]),
-            DataValue::List(vec![DataValue::Bool(true)])
+            DataValue::List(vec![DataValue::from(true), DataValue::from(false)]),
+            DataValue::List(vec![DataValue::from(true)])
         ])
         .unwrap(),
         DataValue::List(vec![
-            DataValue::Bool(true),
-            DataValue::Bool(false),
-            DataValue::Bool(true),
+            DataValue::from(true),
+            DataValue::from(false),
+            DataValue::from(true),
         ])
     );
 }
@@ -640,11 +639,11 @@ fn test_str_includes() {
             DataValue::Str("bcd".into())
         ])
         .unwrap(),
-        DataValue::Bool(true)
+        DataValue::from(true)
     );
     assert_eq!(
         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())
         ])
         .unwrap(),
-        DataValue::Bool(true)
+        DataValue::from(true)
     );
     assert_eq!(
         op_starts_with(&[DataValue::Str("abcdef".into()), DataValue::Str("bc".into())]).unwrap(),
-        DataValue::Bool(false)
+        DataValue::from(false)
     );
     assert_eq!(
         op_ends_with(&[
@@ -696,11 +695,11 @@ fn test_starts_ends_with() {
             DataValue::Str("def".into())
         ])
         .unwrap(),
-        DataValue::Bool(true)
+        DataValue::from(true)
     );
     assert_eq!(
         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()))
         ])
         .unwrap(),
-        DataValue::Bool(true)
+        DataValue::from(true)
     );
 
     assert_eq!(
@@ -721,7 +720,7 @@ fn test_regex() {
             DataValue::Regex(RegexWrapper(Regex::new("c.ef$").unwrap()))
         ])
         .unwrap(),
-        DataValue::Bool(true)
+        DataValue::from(true)
     );
 
     assert_eq!(
@@ -730,7 +729,7 @@ fn test_regex() {
             DataValue::Regex(RegexWrapper(Regex::new("c.e$").unwrap()))
         ])
         .unwrap(),
-        DataValue::Bool(false)
+        DataValue::from(false)
     );
 
     assert_eq!(
@@ -796,107 +795,107 @@ fn test_regex() {
 fn test_predicates() {
     assert_eq!(
         op_is_null(&[DataValue::Null]).unwrap(),
-        DataValue::Bool(true)
+        DataValue::from(true)
     );
     assert_eq!(
         op_is_null(&[DataValue::Bot]).unwrap(),
-        DataValue::Bool(false)
+        DataValue::from(false)
     );
     assert_eq!(
         op_is_int(&[DataValue::from(1)]).unwrap(),
-        DataValue::Bool(true)
+        DataValue::from(true)
     );
     assert_eq!(
         op_is_int(&[DataValue::from(1.0)]).unwrap(),
-        DataValue::Bool(false)
+        DataValue::from(false)
     );
     assert_eq!(
         op_is_float(&[DataValue::from(1)]).unwrap(),
-        DataValue::Bool(false)
+        DataValue::from(false)
     );
     assert_eq!(
         op_is_float(&[DataValue::from(1.0)]).unwrap(),
-        DataValue::Bool(true)
+        DataValue::from(true)
     );
     assert_eq!(
         op_is_num(&[DataValue::from(1)]).unwrap(),
-        DataValue::Bool(true)
+        DataValue::from(true)
     );
     assert_eq!(
         op_is_num(&[DataValue::from(1.0)]).unwrap(),
-        DataValue::Bool(true)
+        DataValue::from(true)
     );
     assert_eq!(
         op_is_num(&[DataValue::Null]).unwrap(),
-        DataValue::Bool(false)
+        DataValue::from(false)
     );
     assert_eq!(
         op_is_bytes(&[DataValue::Bytes([0b1].into())]).unwrap(),
-        DataValue::Bool(true)
+        DataValue::from(true)
     );
     assert_eq!(
         op_is_bytes(&[DataValue::Null]).unwrap(),
-        DataValue::Bool(false)
+        DataValue::from(false)
     );
     assert_eq!(
         op_is_list(&[DataValue::List(vec![])]).unwrap(),
-        DataValue::Bool(true)
+        DataValue::from(true)
     );
     assert_eq!(
         op_is_list(&[DataValue::Null]).unwrap(),
-        DataValue::Bool(false)
+        DataValue::from(false)
     );
     assert_eq!(
         op_is_string(&[DataValue::Str("".into())]).unwrap(),
-        DataValue::Bool(true)
+        DataValue::from(true)
     );
     assert_eq!(
         op_is_string(&[DataValue::Null]).unwrap(),
-        DataValue::Bool(false)
+        DataValue::from(false)
     );
     assert_eq!(
         op_is_finite(&[DataValue::from(1.0)]).unwrap(),
-        DataValue::Bool(true)
+        DataValue::from(true)
     );
     assert_eq!(
         op_is_finite(&[DataValue::from(f64::INFINITY)]).unwrap(),
-        DataValue::Bool(false)
+        DataValue::from(false)
     );
     assert_eq!(
         op_is_finite(&[DataValue::from(f64::NAN)]).unwrap(),
-        DataValue::Bool(false)
+        DataValue::from(false)
     );
     assert_eq!(
         op_is_infinite(&[DataValue::from(1.0)]).unwrap(),
-        DataValue::Bool(false)
+        DataValue::from(false)
     );
     assert_eq!(
         op_is_infinite(&[DataValue::from(f64::INFINITY)]).unwrap(),
-        DataValue::Bool(true)
+        DataValue::from(true)
     );
     assert_eq!(
         op_is_infinite(&[DataValue::from(f64::NEG_INFINITY)]).unwrap(),
-        DataValue::Bool(true)
+        DataValue::from(true)
     );
     assert_eq!(
         op_is_infinite(&[DataValue::from(f64::NAN)]).unwrap(),
-        DataValue::Bool(false)
+        DataValue::from(false)
     );
     assert_eq!(
         op_is_nan(&[DataValue::from(1.0)]).unwrap(),
-        DataValue::Bool(false)
+        DataValue::from(false)
     );
     assert_eq!(
         op_is_nan(&[DataValue::from(f64::INFINITY)]).unwrap(),
-        DataValue::Bool(false)
+        DataValue::from(false)
     );
     assert_eq!(
         op_is_nan(&[DataValue::from(f64::NEG_INFINITY)]).unwrap(),
-        DataValue::Bool(false)
+        DataValue::from(false)
     );
     assert_eq!(
         op_is_nan(&[DataValue::from(f64::NAN)]).unwrap(),
-        DataValue::Bool(true)
+        DataValue::from(true)
     );
 }
 
@@ -1213,7 +1212,7 @@ fn test_encode_decode() {
 #[test]
 fn test_to_string() {
     assert_eq!(
-        op_to_string(&[DataValue::Bool(false)]).unwrap(),
+        op_to_string(&[DataValue::from(false)]).unwrap(),
         DataValue::Str("false".into())
     );
 }
@@ -1222,11 +1221,11 @@ fn test_to_string() {
 fn test_to_unity() {
     assert_eq!(op_to_unity(&[DataValue::Null]).unwrap(), DataValue::from(0));
     assert_eq!(
-        op_to_unity(&[DataValue::Bool(false)]).unwrap(),
+        op_to_unity(&[DataValue::from(false)]).unwrap(),
         DataValue::from(0)
     );
     assert_eq!(
-        op_to_unity(&[DataValue::Bool(true)]).unwrap(),
+        op_to_unity(&[DataValue::from(true)]).unwrap(),
         DataValue::from(1)
     );
     assert_eq!(
@@ -1266,11 +1265,11 @@ fn test_to_float() {
         DataValue::from(0.0)
     );
     assert_eq!(
-        op_to_float(&[DataValue::Bool(false)]).unwrap(),
+        op_to_float(&[DataValue::from(false)]).unwrap(),
         DataValue::from(0.0)
     );
     assert_eq!(
-        op_to_float(&[DataValue::Bool(true)]).unwrap(),
+        op_to_float(&[DataValue::from(true)]).unwrap(),
         DataValue::from(1.0)
     );
     assert_eq!(
@@ -1312,11 +1311,11 @@ fn test_rand() {
     assert!(n <= 1.);
     assert_eq!(
         op_rand_bernoulli(&[DataValue::from(0)]).unwrap(),
-        DataValue::Bool(false)
+        DataValue::from(false)
     );
     assert_eq!(
         op_rand_bernoulli(&[DataValue::from(1)]).unwrap(),
-        DataValue::Bool(true)
+        DataValue::from(true)
     );
     assert!(op_rand_bernoulli(&[DataValue::from(2)]).is_err());
     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();
     assert!(op_is_uuid(&[v4]).unwrap().get_bool().unwrap());
     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::Str(SmartString::from(
-        "f3b4958c-52a1-11e7-802a-010203040506"
-    ))])
-    .is_ok());
+    assert!(op_to_uuid(&[DataValue::from("")]).is_err());
+    assert!(op_to_uuid(&[DataValue::from("f3b4958c-52a1-11e7-802a-010203040506")]).is_ok());
 }
 
 #[test]
@@ -1401,53 +1397,62 @@ fn test_now() {
 fn test_to_bool() {
     assert_eq!(
         op_to_bool(&[DataValue::Null]).unwrap(),
-        DataValue::Bool(false)
+        DataValue::from(false)
     );
     assert_eq!(
-        op_to_bool(&[DataValue::Bool(true)]).unwrap(),
-        DataValue::Bool(true)
+        op_to_bool(&[DataValue::from(true)]).unwrap(),
+        DataValue::from(true)
     );
     assert_eq!(
-        op_to_bool(&[DataValue::Bool(false)]).unwrap(),
-        DataValue::Bool(false)
+        op_to_bool(&[DataValue::from(false)]).unwrap(),
+        DataValue::from(false)
     );
     assert_eq!(
         op_to_bool(&[DataValue::from(0)]).unwrap(),
-        DataValue::Bool(false)
+        DataValue::from(false)
     );
     assert_eq!(
         op_to_bool(&[DataValue::from(0.0)]).unwrap(),
-        DataValue::Bool(false)
+        DataValue::from(false)
     );
     assert_eq!(
         op_to_bool(&[DataValue::from(1)]).unwrap(),
-        DataValue::Bool(true)
+        DataValue::from(true)
     );
     assert_eq!(
-        op_to_bool(&[DataValue::Str(SmartString::from(""))]).unwrap(),
-        DataValue::Bool(false)
+        op_to_bool(&[DataValue::from("")]).unwrap(),
+        DataValue::from(false)
     );
     assert_eq!(
-        op_to_bool(&[DataValue::Str(SmartString::from("a"))]).unwrap(),
-        DataValue::Bool(true)
+        op_to_bool(&[DataValue::from("a")]).unwrap(),
+        DataValue::from(true)
     );
     assert_eq!(
         op_to_bool(&[DataValue::List(vec![])]).unwrap(),
-        DataValue::Bool(false)
+        DataValue::from(false)
     );
     assert_eq!(
         op_to_bool(&[DataValue::List(vec![DataValue::from(0)])]).unwrap(),
-        DataValue::Bool(true)
+        DataValue::from(true)
     );
 }
 
 #[test]
 fn test_coalesce() {
     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));
-    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);
-    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));
-}
+}

cozo-core/src/data/tests/memcmp.rs

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

cozo-core/src/data/tests/values.rs

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

cozo-core/src/data/value.rs

@@ -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)]
 pub enum Num {
     Int(i64),

cozo-core/src/fixed_rule/utilities/csv.rs

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

cozo-core/src/parse/expr.rs

@@ -194,7 +194,7 @@ fn build_term(pair: Pair<'_>, param_pool: &BTreeMap<String, DataValue>) -> Resul
             span,
         },
         Rule::boolean => Expr::Const {
-            val: DataValue::Bool(pair.as_str() == "true"),
+            val: DataValue::from(pair.as_str() == "true"),
             span,
         },
         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.len() - 1,
                             Expr::Const {
-                                val: DataValue::Bool(true),
+                                val: DataValue::from(true),
                                 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() {
                         clauses.push((
                             Expr::Const {
-                                val: DataValue::Bool(true),
+                                val: DataValue::from(true),
                                 span,
                             },
                             else_clause,

cozo-core/src/runtime/db.rs

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

cozo-core/src/runtime/relation.rs

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

cozo-core/src/runtime/tests.rs

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