invalid: handle the panic in the DataValue::cast method and convert it to TypeError::CastFail

KKould · KKould · commit 93ca5d7ebeac · 2023-09-14T02:52:25.000+08:00
diff --git a/src/binder/insert.rs b/src/binder/insert.rs
@@ -48,7 +48,7 @@ impl<S: Storage> Binder<S> {
                     match self.bind_expr(expr).await? {
                         ScalarExpression::Constant(value) => {
                             let cast_value = DataValue::clone(&value)
-                                .cast(columns[i].datatype());
+                                .cast(columns[i].datatype())?;
 
                             row.push(Arc::new(cast_value))
                         },
diff --git a/src/execution/executor/dml/insert.rs b/src/execution/executor/dml/insert.rs
@@ -51,7 +51,7 @@ impl Insert {
                 });
 
                 let tuple_id = if let DataValue::Int64(Some(primary_id)) =
-                    DataValue::clone(&values[*primary_idx]).cast(&LogicalType::Bigint)
+                    DataValue::clone(&values[*primary_idx]).cast(&LogicalType::Bigint)?
                 {
                     primary_id
                 } else {
diff --git a/src/execution/executor/dql/aggregate/avg.rs b/src/execution/executor/dql/aggregate/avg.rs
@@ -46,7 +46,7 @@ impl Accumulator for AvgAccumulator {
                 &value,
                 &quantity,
                 &BinaryOperator::Divide
-            )
+            )?
         ))
     }
 }
diff --git a/src/execution/executor/dql/aggregate/hash_agg.rs b/src/execution/executor/dql/aggregate/hash_agg.rs
@@ -53,7 +53,7 @@ impl HashAggExecutor {
             });
 
             // 2.1 evaluate agg exprs and collect the result values for later accumulators.
-            let values = self.agg_calls
+            let values: Vec<ValueRef> = self.agg_calls
                 .iter()
                 .map(|expr| {
                     if let ScalarExpression::AggCall { args, .. } = expr {
@@ -62,12 +62,12 @@ impl HashAggExecutor {
                         unreachable!()
                     }
                 })
-                .collect_vec();
+                .try_collect()?;
 
-            let group_keys = self.groupby_exprs
+            let group_keys: Vec<ValueRef> = self.groupby_exprs
                 .iter()
                 .map(|expr| expr.eval_column(&tuple))
-                .collect_vec();
+                .try_collect()?;
 
             for (acc, value) in group_hash_accs
                 .entry(group_keys)
diff --git a/src/execution/executor/dql/aggregate/min_max.rs b/src/execution/executor/dql/aggregate/min_max.rs
@@ -32,7 +32,7 @@ impl Accumulator for MinMaxAccumulator {
     fn update_value(&mut self, value: &ValueRef) -> Result<(), ExecutorError> {
         if !value.is_null() {
             if let Some(inner_value) = &self.inner {
-                if let DataValue::Boolean(Some(result)) = binary_op(&inner_value, value, &self.op) {
+                if let DataValue::Boolean(Some(result)) = binary_op(&inner_value, value, &self.op)? {
                     result
                 } else {
                     unreachable!()
diff --git a/src/execution/executor/dql/aggregate/simple_agg.rs b/src/execution/executor/dql/aggregate/simple_agg.rs
@@ -46,15 +46,15 @@ impl SimpleAggExecutor {
                     .collect_vec()
             });
 
-            let values = self.agg_calls
+            let values: Vec<ValueRef> = self.agg_calls
                 .iter()
                 .map(|expr| match expr {
                     ScalarExpression::AggCall { args, .. } => {
                         args[0].eval_column(&tuple)
                     }
                     _ => unreachable!()
                 })
-                .collect_vec();
+                .try_collect()?;
 
             for (acc, value) in accs.iter_mut().zip_eq(values.iter()) {
                 acc.update_value(value)?;
diff --git a/src/execution/executor/dql/aggregate/sum.rs b/src/execution/executor/dql/aggregate/sum.rs
@@ -27,7 +27,7 @@ impl Accumulator for SumAccumulator {
                 &self.result,
                 value,
                 &BinaryOperator::Plus
-            );
+            )?;
         }
 
         Ok(())
diff --git a/src/execution/executor/dql/filter.rs b/src/execution/executor/dql/filter.rs
@@ -35,7 +35,7 @@ impl Filter {
         #[for_await]
         for tuple in input {
             let tuple = tuple?;
-            if let DataValue::Boolean(option) = predicate.eval_column(&tuple).as_ref() {
+            if let DataValue::Boolean(option) = predicate.eval_column(&tuple)?.as_ref() {
                 if let Some(true) = option{
                     yield tuple;
                 } else {
diff --git a/src/execution/executor/dql/join/hash_join.rs b/src/execution/executor/dql/join/hash_join.rs
@@ -9,6 +9,7 @@ use crate::execution::ExecutorError;
 use crate::expression::ScalarExpression;
 use crate::planner::operator::join::{JoinCondition, JoinOperator, JoinType};
 use crate::storage::Storage;
+use crate::types::errors::TypeError;
 use crate::types::tuple::Tuple;
 use crate::types::value::DataValue;
 
@@ -63,7 +64,7 @@ impl HashJoin {
         #[for_await]
         for tuple in left_input {
             let tuple: Tuple = tuple?;
-            let hash = Self::hash_row(&on_left_keys, &hash_random_state, &tuple);
+            let hash = Self::hash_row(&on_left_keys, &hash_random_state, &tuple)?;
 
             if !left_init_flag {
                 Self::columns_filling(&tuple, &mut join_columns, left_force_nullable);
@@ -82,7 +83,7 @@ impl HashJoin {
         for tuple in right_input {
             let tuple: Tuple = tuple?;
             let right_cols_len = tuple.columns.len();
-            let hash = Self::hash_row(&on_right_keys, &hash_random_state, &tuple);
+            let hash = Self::hash_row(&on_right_keys, &hash_random_state, &tuple)?;
 
             if !right_init_flag {
                 Self::columns_filling(&tuple, &mut join_columns, right_force_nullable);
@@ -122,7 +123,7 @@ impl HashJoin {
                 let mut filter_tuples = Vec::with_capacity(join_tuples.len());
 
                 for mut tuple in join_tuples {
-                    if let DataValue::Boolean(option) = expr.eval_column(&tuple).as_ref() {
+                    if let DataValue::Boolean(option) = expr.eval_column(&tuple)?.as_ref() {
                         if let Some(false) | None = option {
                             let full_cols_len = tuple.columns.len();
                             let left_cols_len = full_cols_len - right_cols_len;
@@ -200,13 +201,14 @@ impl HashJoin {
         on_keys: &[ScalarExpression],
         hash_random_state: &RandomState,
         tuple: &Tuple
-    ) -> u64 {
-        let values = on_keys
-            .iter()
-            .map(|expr| expr.eval_column(tuple))
-            .collect_vec();
+    ) -> Result<u64, TypeError> {
+        let mut values = Vec::with_capacity(on_keys.len());
+
+        for expr in on_keys {
+            values.push(expr.eval_column(tuple)?);
+        }
 
-        hash_random_state.hash_one(values)
+        Ok(hash_random_state.hash_one(values))
     }
 }
 
diff --git a/src/execution/executor/dql/projection.rs b/src/execution/executor/dql/projection.rs
@@ -39,7 +39,7 @@ impl Projection {
             let mut values = Vec::with_capacity(exprs.len());
 
             for expr in exprs.iter() {
-                values.push(expr.eval_column(&tuple));
+                values.push(expr.eval_column(&tuple)?);
                 columns.push(expr.output_columns(&tuple));
             }
 
diff --git a/src/execution/executor/dql/sort.rs b/src/execution/executor/dql/sort.rs
@@ -43,15 +43,14 @@ impl Sort {
             let mut ordering = Ordering::Equal;
 
             for SortField { expr, desc, nulls_first } in &sort_fields {
-                let value_1 = expr.eval_column(tuple_1);
-                let value_2 = expr.eval_column(tuple_2);
+                let value_1 = expr.eval_column(tuple_1).unwrap();
+                let value_2 = expr.eval_column(tuple_2).unwrap();
 
                 ordering = value_1.partial_cmp(&value_2)
                     .unwrap_or_else(|| match (value_1.is_null(), value_2.is_null()) {
                         (false, true) => if *nulls_first { Ordering::Less } else { Ordering::Greater },
                         (true, false) => if *nulls_first { Ordering::Greater } else { Ordering::Less },
-                        (true, true) => Ordering::Equal,
-                        _ => unreachable!(),
+                        _ => Ordering::Equal,
                     });
 
                 if *desc {
diff --git a/src/expression/evaluator.rs b/src/expression/evaluator.rs
@@ -2,40 +2,38 @@ use std::sync::Arc;
 use itertools::Itertools;
 use crate::expression::value_compute::binary_op;
 use crate::expression::ScalarExpression;
+use crate::types::errors::TypeError;
 use crate::types::tuple::Tuple;
 use crate::types::value::{DataValue, ValueRef};
 
 impl ScalarExpression {
-    pub fn eval_column(&self, tuple: &Tuple) -> ValueRef {
+    pub fn eval_column(&self, tuple: &Tuple) -> Result<ValueRef, TypeError> {
         match &self {
-            ScalarExpression::Constant(val) =>
-                val.clone(),
+            ScalarExpression::Constant(val) => Ok(val.clone()),
             ScalarExpression::ColumnRef(col) => {
                 let (index, _) = tuple
                     .columns
                     .iter()
                     .find_position(|tul_col| tul_col.name == col.name)
                     .unwrap();
 
-                tuple.values[index].clone()
+                Ok(tuple.values[index].clone())
             },
-            ScalarExpression::InputRef{ index, .. } =>
-                tuple.values[*index].clone(),
-            ScalarExpression::Alias{ expr, .. } =>
-                expr.eval_column(tuple),
+            ScalarExpression::InputRef{ index, .. } => Ok(tuple.values[*index].clone()),
+            ScalarExpression::Alias{ expr, .. } => expr.eval_column(tuple),
             ScalarExpression::TypeCast{ expr, ty, .. } => {
-                let value = expr.eval_column(tuple);
+                let value = expr.eval_column(tuple)?;
 
-                Arc::new(DataValue::clone(&value).cast(ty))
+                Ok(Arc::new(DataValue::clone(&value).cast(ty)?))
             }
             ScalarExpression::Binary{ left_expr, right_expr, op, .. } => {
-                let left = left_expr.eval_column(tuple);
-                let right = right_expr.eval_column(tuple);
+                let left = left_expr.eval_column(tuple)?;
+                let right = right_expr.eval_column(tuple)?;
 
-                Arc::new(binary_op(&left, &right, op))
+                Ok(Arc::new(binary_op(&left, &right, op)?))
             }
             ScalarExpression::IsNull{ expr } => {
-                Arc::new(DataValue::Boolean(Some(expr.nullable())))
+                Ok(Arc::new(DataValue::Boolean(Some(expr.nullable()))))
             }
             ScalarExpression::Unary{ .. } => todo!(),
             ScalarExpression::AggCall{ .. } => todo!()
diff --git a/src/expression/value_compute.rs b/src/expression/value_compute.rs
diff --git a/src/storage/kip.rs b/src/storage/kip.rs
diff --git a/src/storage/memory.rs b/src/storage/memory.rs
diff --git a/src/storage/mod.rs b/src/storage/mod.rs
diff --git a/src/types/errors.rs b/src/types/errors.rs
diff --git a/src/types/value.rs b/src/types/value.rs

Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ impl Insert {`
`51`	`51`	`});`
`52`	`52`
`53`	`53`	`let tuple_id = if let DataValue::Int64(Some(primary_id)) =`
`54`		`- DataValue::clone(&values[*primary_idx]).cast(&LogicalType::Bigint)`
	`54`	`+ DataValue::clone(&values[*primary_idx]).cast(&LogicalType::Bigint)?`
`55`	`55`	`{`
`56`	`56`	`primary_id`
`57`	`57`	`} else {`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ impl Accumulator for AvgAccumulator {`
`46`	`46`	`&value,`
`47`	`47`	`&quantity,`
`48`	`48`	`&BinaryOperator::Divide`
`49`		`- )`
	`49`	`+ )?`
`50`	`50`	`))`
`51`	`51`	`}`
`52`	`52`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ impl Accumulator for SumAccumulator {`
`27`	`27`	`&self.result,`
`28`	`28`	`value,`
`29`	`29`	`&BinaryOperator::Plus`
`30`		`- );`
	`30`	`+ )?;`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`Ok(())`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ impl Projection {`
`39`	`39`	`let mut values = Vec::with_capacity(exprs.len());`
`40`	`40`
`41`	`41`	`for expr in exprs.iter() {`
`42`		`- values.push(expr.eval_column(&tuple));`
	`42`	`+ values.push(expr.eval_column(&tuple)?);`
`43`	`43`	`columns.push(expr.output_columns(&tuple));`
`44`	`44`	`}`
`45`	`45`