chore: simplify DataValue

KipData · Dec 28, 2024 · f69a726 · f69a726
1 parent a7b3d5f
commit f69a726
Show file tree

Hide file tree

Showing 63 changed files with 2,288 additions and 2,704 deletions.
diff --git a/Cargo.toml b/Cargo.toml
@@ -43,7 +43,7 @@ csv                   = { version = "1" }
 dirs                  = { version = "5" }
 fixedbitset           = { version = "0.4" }
 itertools             = { version = "0.12" }
-ordered-float         = { version = "4" }
+ordered-float         = { version = "4", features = ["serde"] }
 paste                 = { version = "1" }
 parking_lot           = { version = "0.12", features = ["arc_lock"] }
 petgraph              = { version = "0.6" }

diff --git a/docs/features.md b/docs/features.md
@@ -14,13 +14,13 @@ struct MyStruct {
 implement_from_tuple!(
     MyStruct, (
         c1: i32 => |inner: &mut MyStruct, value| {
-            if let DataValue::Int32(Some(val)) = value {
+            if let DataValue::Int32(val) = value {
                 inner.c1 = val;
             }
         },
         c2: String => |inner: &mut MyStruct, value| {
-            if let DataValue::Utf8(Some(val)) = value {
-                inner.c2 = val;
+            if let DataValue::Utf8 { value, .. } = value {
+                inner.c2 = value;
             }
         }
     )

diff --git a/examples/hello_world.rs b/examples/hello_world.rs
@@ -12,13 +12,13 @@ struct MyStruct {
 implement_from_tuple!(
     MyStruct, (
         c1: i32 => |inner: &mut MyStruct, value| {
-            if let DataValue::Int32(Some(val)) = value {
+            if let DataValue::Int32(val) = value {
                 inner.c1 = val;
             }
         },
         c2: String => |inner: &mut MyStruct, value| {
-            if let DataValue::Utf8 { value: Some(val), .. } = value {
-                inner.c2 = val;
+            if let DataValue::Utf8 { value, .. } = value {
+                inner.c2 = value;
             }
         }
     )

diff --git a/src/binder/expr.rs b/src/binder/expr.rs
@@ -82,7 +82,7 @@ impl<'a, T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'a, '_, T
             Expr::TypedString { data_type, value } => {
                 let logical_type = LogicalType::try_from(data_type.clone())?;
                 let value = DataValue::Utf8 {
-                    value: Some(value.to_string()),
+                    value: value.to_string(),
                     ty: Utf8Type::Variable(None),
                     unit: CharLengthUnits::Characters,
                 }
@@ -429,7 +429,7 @@ impl<'a, T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'a, '_, T
         };
 
         Ok(ScalarExpression::Binary {
-            op: (op.clone()).into(),
+            op: (op.clone()).try_into()?,
             left_expr,
             right_expr,
             evaluator: None,
@@ -450,7 +450,7 @@ impl<'a, T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'a, '_, T
         };
 
         Ok(ScalarExpression::Unary {
-            op: (*op).into(),
+            op: (*op).try_into()?,
             expr,
             evaluator: None,
             ty,
@@ -690,7 +690,7 @@ impl<'a, T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'a, '_, T
 
     fn wildcard_expr() -> ScalarExpression {
         ScalarExpression::Constant(DataValue::Utf8 {
-            value: Some("*".to_string()),
+            value: "*".to_string(),
             ty: Utf8Type::Variable(None),
             unit: CharLengthUnits::Characters,
         })

diff --git a/src/binder/select.rs b/src/binder/select.rs
@@ -695,8 +695,8 @@ impl<'a: 'b, 'b, T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'
             let expr = self.bind_expr(expr)?;
             match expr {
                 ScalarExpression::Constant(dv) => match &dv {
-                    DataValue::Int32(Some(v)) if *v >= 0 => limit = Some(*v as usize),
-                    DataValue::Int64(Some(v)) if *v >= 0 => limit = Some(*v as usize),
+                    DataValue::Int32(v) if *v >= 0 => limit = Some(*v as usize),
+                    DataValue::Int64(v) if *v >= 0 => limit = Some(*v as usize),
                     _ => return Err(DatabaseError::InvalidType),
                 },
                 _ => {
@@ -711,8 +711,8 @@ impl<'a: 'b, 'b, T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'
             let expr = self.bind_expr(&expr.value)?;
             match expr {
                 ScalarExpression::Constant(dv) => match &dv {
-                    DataValue::Int32(Some(v)) if *v > 0 => offset = Some(*v as usize),
-                    DataValue::Int64(Some(v)) if *v > 0 => offset = Some(*v as usize),
+                    DataValue::Int32(v) if *v > 0 => offset = Some(*v as usize),
+                    DataValue::Int64(v) if *v > 0 => offset = Some(*v as usize),
                     _ => return Err(DatabaseError::InvalidType),
                 },
                 _ => {

diff --git a/src/db.rs b/src/db.rs
@@ -530,7 +530,7 @@ pub(crate) mod test {
             iter.next().unwrap()?,
             Tuple::new(
                 None,
-                vec![DataValue::Date32(Some(Local::now().num_days_from_ce()))]
+                vec![DataValue::Date32(Local::now().num_days_from_ce())]
             )
         );
         assert!(iter.next().is_none());
@@ -558,11 +558,11 @@ pub(crate) mod test {
         assert_eq!(iter.schema(), &Arc::new(vec![ColumnRef::from(column)]));
         assert_eq!(
             iter.next().unwrap()?,
-            Tuple::new(None, vec![DataValue::Int32(Some(3))])
+            Tuple::new(None, vec![DataValue::Int32(3)])
         );
         assert_eq!(
             iter.next().unwrap()?,
-            Tuple::new(None, vec![DataValue::Int32(Some(4))])
+            Tuple::new(None, vec![DataValue::Int32(4)])
         );
         Ok(())
     }
@@ -583,7 +583,7 @@ pub(crate) mod test {
         {
             let statement = fnck_sql.prepare("explain select * from t1 where b > ?1")?;
 
-            let mut iter = fnck_sql.execute(&statement, &[("?1", DataValue::Int32(Some(0)))])?;
+            let mut iter = fnck_sql.execute(&statement, &[("?1", DataValue::Int32(0))])?;
 
             assert_eq!(
                 iter.next().unwrap()?.values[0].utf8().unwrap(),
@@ -601,10 +601,10 @@ pub(crate) mod test {
             let mut iter = fnck_sql.execute(
                 &statement,
                 &[
-                    ("?1", DataValue::Int32(Some(0))),
-                    ("?2", DataValue::Int32(Some(0))),
-                    ("?3", DataValue::Int32(Some(1))),
-                    ("?4", DataValue::Int32(Some(0))),
+                    ("?1", DataValue::Int32(0)),
+                    ("?2", DataValue::Int32(0)),
+                    ("?3", DataValue::Int32(1)),
+                    ("?4", DataValue::Int32(0)),
                 ],
             )?;
             assert_eq!(
@@ -621,10 +621,10 @@ pub(crate) mod test {
             let mut iter = fnck_sql.execute(
                 &statement,
                 &[
-                    ("?1", DataValue::Int32(Some(9))),
-                    ("?2", DataValue::Int32(Some(0))),
-                    ("?3", DataValue::Int32(Some(1))),
-                    ("?4", DataValue::Int32(Some(0))),
+                    ("?1", DataValue::Int32(9)),
+                    ("?2", DataValue::Int32(0)),
+                    ("?3", DataValue::Int32(1)),
+                    ("?4", DataValue::Int32(0)),
                 ],
             )?;
             assert_eq!(
@@ -666,20 +666,20 @@ pub(crate) mod test {
 
         assert_eq!(
             iter_1.next().unwrap()?.values,
-            vec![DataValue::Int32(Some(0)), DataValue::Int32(Some(0))]
+            vec![DataValue::Int32(0), DataValue::Int32(0)]
         );
         assert_eq!(
             iter_1.next().unwrap()?.values,
-            vec![DataValue::Int32(Some(1)), DataValue::Int32(Some(1))]
+            vec![DataValue::Int32(1), DataValue::Int32(1)]
         );
 
         assert_eq!(
             iter_2.next().unwrap()?.values,
-            vec![DataValue::Int32(Some(0)), DataValue::Int32(Some(0))]
+            vec![DataValue::Int32(0), DataValue::Int32(0)]
         );
         assert_eq!(
             iter_2.next().unwrap()?.values,
-            vec![DataValue::Int32(Some(3)), DataValue::Int32(Some(3))]
+            vec![DataValue::Int32(3), DataValue::Int32(3)]
         );
         drop(iter_1);
         drop(iter_2);

diff --git a/src/execution/dml/analyze.rs b/src/execution/dml/analyze.rs
@@ -92,9 +92,7 @@ impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for Analyze {
                         if values.len() == 1 {
                             throw!(builder.append(&values[0]));
                         } else {
-                            throw!(
-                                builder.append(&Arc::new(DataValue::Tuple(Some((values, false)))))
-                            );
+                            throw!(builder.append(&Arc::new(DataValue::Tuple(values, false))));
                         }
                     }
                 }
@@ -121,7 +119,7 @@ impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for Analyze {
 
                     throw!(meta.to_file(&temp_path));
                     values.push(DataValue::Utf8 {
-                        value: Some(path_str.clone()),
+                        value: path_str.clone(),
                         ty: Utf8Type::Variable(None),
                         unit: CharLengthUnits::Characters,
                     });

diff --git a/src/execution/dml/insert.rs b/src/execution/dml/insert.rs
@@ -118,7 +118,7 @@ impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for Insert {
                                 if value.is_none() {
                                     value = throw!(col.default_value());
                                 }
-                                value.unwrap_or_else(|| DataValue::none(col.datatype()))
+                                value.unwrap_or(DataValue::Null)
                             };
                             if value.is_null() && !col.nullable() {
                                 yield Err(DatabaseError::NotNull);

diff --git a/src/execution/dql/aggregate/avg.rs b/src/execution/dql/aggregate/avg.rs
@@ -38,9 +38,9 @@ impl Accumulator for AvgAccumulator {
             return Ok(DataValue::init(&value_ty));
         }
         let quantity = if value_ty.is_signed_numeric() {
-            DataValue::Int64(Some(self.count as i64))
+            DataValue::Int64(self.count as i64)
         } else {
-            DataValue::UInt32(Some(self.count as u32))
+            DataValue::UInt32(self.count as u32)
         };
         let quantity_ty = quantity.logical_type();
 

diff --git a/src/execution/dql/aggregate/count.rs b/src/execution/dql/aggregate/count.rs
@@ -24,7 +24,7 @@ impl Accumulator for CountAccumulator {
     }
 
     fn evaluate(&self) -> Result<DataValue, DatabaseError> {
-        Ok(DataValue::Int32(Some(self.result)))
+        Ok(DataValue::Int32(self.result))
     }
 }
 
@@ -50,6 +50,6 @@ impl Accumulator for DistinctCountAccumulator {
     }
 
     fn evaluate(&self) -> Result<DataValue, DatabaseError> {
-        Ok(DataValue::Int32(Some(self.distinct_values.len() as i32)))
+        Ok(DataValue::Int32(self.distinct_values.len() as i32))
     }
 }
diff --git a/src/execution/dql/aggregate/hash_agg.rs b/src/execution/dql/aggregate/hash_agg.rs
@@ -159,24 +159,24 @@ mod test {
             operator: Operator::Values(ValuesOperator {
                 rows: vec![
                     vec![
-                        DataValue::Int32(Some(0)),
-                        DataValue::Int32(Some(2)),
-                        DataValue::Int32(Some(4)),
+                        DataValue::Int32(0),
+                        DataValue::Int32(2),
+                        DataValue::Int32(4),
                     ],
                     vec![
-                        DataValue::Int32(Some(1)),
-                        DataValue::Int32(Some(3)),
-                        DataValue::Int32(Some(5)),
+                        DataValue::Int32(1),
+                        DataValue::Int32(3),
+                        DataValue::Int32(5),
                     ],
                     vec![
-                        DataValue::Int32(Some(0)),
-                        DataValue::Int32(Some(1)),
-                        DataValue::Int32(Some(2)),
+                        DataValue::Int32(0),
+                        DataValue::Int32(1),
+                        DataValue::Int32(2),
                     ],
                     vec![
-                        DataValue::Int32(Some(1)),
-                        DataValue::Int32(Some(2)),
-                        DataValue::Int32(Some(3)),
+                        DataValue::Int32(1),
+                        DataValue::Int32(2),
+                        DataValue::Int32(3),
                     ],
                 ],
                 schema_ref: t1_schema.clone(),

diff --git a/src/execution/dql/aggregate/min_max.rs b/src/execution/dql/aggregate/min_max.rs
@@ -3,27 +3,21 @@ use crate::execution::dql::aggregate::Accumulator;
 use crate::expression::BinaryOperator;
 use crate::types::evaluator::EvaluatorFactory;
 use crate::types::value::DataValue;
-use crate::types::LogicalType;
 
 pub struct MinMaxAccumulator {
     inner: Option<DataValue>,
     op: BinaryOperator,
-    ty: LogicalType,
 }
 
 impl MinMaxAccumulator {
-    pub fn new(ty: &LogicalType, is_max: bool) -> Self {
+    pub fn new(is_max: bool) -> Self {
         let op = if is_max {
             BinaryOperator::Lt
         } else {
             BinaryOperator::Gt
         };
 
-        Self {
-            inner: None,
-            op,
-            ty: ty.clone(),
-        }
+        Self { inner: None, op }
     }
 }
 
@@ -32,12 +26,10 @@ impl Accumulator for MinMaxAccumulator {
         if !value.is_null() {
             if let Some(inner_value) = &self.inner {
                 let evaluator = EvaluatorFactory::binary_create(value.logical_type(), self.op)?;
-                if let DataValue::Boolean(Some(result)) =
-                    evaluator.0.binary_eval(inner_value, value)
-                {
+                if let DataValue::Boolean(result) = evaluator.0.binary_eval(inner_value, value) {
                     result
                 } else {
-                    unreachable!()
+                    return Err(DatabaseError::InvalidType);
                 }
             } else {
                 true
@@ -49,9 +41,6 @@ impl Accumulator for MinMaxAccumulator {
     }
 
     fn evaluate(&self) -> Result<DataValue, DatabaseError> {
-        Ok(self
-            .inner
-            .clone()
-            .unwrap_or_else(|| DataValue::none(&self.ty)))
+        Ok(self.inner.clone().unwrap_or(DataValue::Null))
     }
 }
diff --git a/src/execution/dql/aggregate/mod.rs b/src/execution/dql/aggregate/mod.rs
@@ -36,8 +36,8 @@ fn create_accumulator(expr: &ScalarExpression) -> Result<Box<dyn Accumulator>, D
             (AggKind::Count, true) => Box::new(DistinctCountAccumulator::new()),
             (AggKind::Sum, false) => Box::new(SumAccumulator::new(ty)?),
             (AggKind::Sum, true) => Box::new(DistinctSumAccumulator::new(ty)?),
-            (AggKind::Min, _) => Box::new(MinMaxAccumulator::new(ty, false)),
-            (AggKind::Max, _) => Box::new(MinMaxAccumulator::new(ty, true)),
+            (AggKind::Min, _) => Box::new(MinMaxAccumulator::new(false)),
+            (AggKind::Max, _) => Box::new(MinMaxAccumulator::new(true)),
             (AggKind::Avg, _) => Box::new(AvgAccumulator::new(ty)?),
         })
     } else {

diff --git a/src/execution/dql/aggregate/sum.rs b/src/execution/dql/aggregate/sum.rs
@@ -17,7 +17,7 @@ impl SumAccumulator {
         debug_assert!(ty.is_numeric());
 
         Ok(Self {
-            result: DataValue::none(ty),
+            result: DataValue::Null,
             evaluator: EvaluatorFactory::binary_create(ty.clone(), BinaryOperator::Plus)?,
         })
     }
@@ -27,7 +27,7 @@ impl Accumulator for SumAccumulator {
     fn update_value(&mut self, value: &DataValue) -> Result<(), DatabaseError> {
         if !value.is_null() {
             if self.result.is_null() {
-                self.result = DataValue::clone(value);
+                self.result = value.clone();
             } else {
                 self.result = self.evaluator.0.binary_eval(&self.result, value);
             }