This is an automated email from the ASF dual-hosted git repository.
liukun pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/arrow-datafusion.git
The following commit(s) were added to refs/heads/master by this push:
new 48732b4cb Support arithmetic operation on DictionaryArray (#5194)
48732b4cb is described below
commit 48732b4cb2c8e42fbe5be295429bbc465e5f5491
Author: Liang-Chi Hsieh <[email protected]>
AuthorDate: Mon Feb 6 20:43:25 2023 -0800
Support arithmetic operation on DictionaryArray (#5194)
* Support arithmetic operation on DictionaryArray
* Add tests
* Add some nulls to tests
---
datafusion/expr/src/type_coercion/binary.rs | 8 +-
datafusion/physical-expr/src/expressions/binary.rs | 438 ++++++++++++++++++++-
.../src/expressions/binary/kernels_arrow.rs | 89 +++--
3 files changed, 478 insertions(+), 57 deletions(-)
diff --git a/datafusion/expr/src/type_coercion/binary.rs
b/datafusion/expr/src/type_coercion/binary.rs
index ce28a2dc3..3a2ca9c79 100644
--- a/datafusion/expr/src/type_coercion/binary.rs
+++ b/datafusion/expr/src/type_coercion/binary.rs
@@ -328,7 +328,10 @@ fn mathematics_numerical_coercion(
// same type => all good
// TODO: remove this
// bug: https://github.com/apache/arrow-datafusion/issues/3387
- if lhs_type == rhs_type {
+ if lhs_type == rhs_type
+ && !(matches!(lhs_type, DataType::Dictionary(_, _))
+ || matches!(rhs_type, DataType::Dictionary(_, _)))
+ {
return Some(lhs_type.clone());
}
@@ -341,6 +344,9 @@ fn mathematics_numerical_coercion(
(Null, dec_type @ Decimal128(_, _)) | (dec_type @ Decimal128(_, _),
Null) => {
Some(dec_type.clone())
}
+ (Dictionary(_, lhs_value_type), Dictionary(_, rhs_value_type)) => {
+ mathematics_numerical_coercion(mathematics_op, lhs_value_type,
rhs_value_type)
+ }
(Dictionary(key_type, value_type), _) => {
let value_type =
mathematics_numerical_coercion(mathematics_op, value_type,
rhs_type);
diff --git a/datafusion/physical-expr/src/expressions/binary.rs
b/datafusion/physical-expr/src/expressions/binary.rs
index b20235748..624a3b408 100644
--- a/datafusion/physical-expr/src/expressions/binary.rs
+++ b/datafusion/physical-expr/src/expressions/binary.rs
@@ -24,9 +24,9 @@ use std::{any::Any, sync::Arc};
use arrow::array::*;
use arrow::compute::kernels::arithmetic::{
- add, add_scalar_dyn as add_dyn_scalar, divide_opt,
- divide_scalar_dyn as divide_dyn_scalar, modulus, modulus_scalar, multiply,
- multiply_scalar_dyn as multiply_dyn_scalar, subtract,
+ add_dyn, add_scalar_dyn as add_dyn_scalar, divide_dyn_opt,
+ divide_scalar_dyn as divide_dyn_scalar, modulus, modulus_scalar,
multiply_dyn,
+ multiply_scalar_dyn as multiply_dyn_scalar, subtract_dyn,
subtract_scalar_dyn as subtract_dyn_scalar,
};
use arrow::compute::kernels::boolean::{and_kleene, not, or_kleene};
@@ -61,12 +61,13 @@ use kernels::{
bitwise_xor, bitwise_xor_scalar,
};
use kernels_arrow::{
- add_decimal, add_decimal_dyn_scalar, divide_decimal_dyn_scalar,
divide_opt_decimal,
- is_distinct_from, is_distinct_from_bool, is_distinct_from_decimal,
- is_distinct_from_null, is_distinct_from_utf8, is_not_distinct_from,
- is_not_distinct_from_bool, is_not_distinct_from_decimal,
is_not_distinct_from_null,
- is_not_distinct_from_utf8, modulus_decimal, modulus_decimal_scalar,
multiply_decimal,
- multiply_decimal_dyn_scalar, subtract_decimal, subtract_decimal_dyn_scalar,
+ add_decimal_dyn_scalar, add_dyn_decimal, divide_decimal_dyn_scalar,
+ divide_dyn_opt_decimal, is_distinct_from, is_distinct_from_bool,
+ is_distinct_from_decimal, is_distinct_from_null, is_distinct_from_utf8,
+ is_not_distinct_from, is_not_distinct_from_bool,
is_not_distinct_from_decimal,
+ is_not_distinct_from_null, is_not_distinct_from_utf8, modulus_decimal,
+ modulus_decimal_scalar, multiply_decimal_dyn_scalar, multiply_dyn_decimal,
+ subtract_decimal_dyn_scalar, subtract_dyn_decimal,
};
use arrow::datatypes::{DataType, Schema, TimeUnit};
@@ -418,6 +419,27 @@ macro_rules! binary_primitive_array_op {
}};
}
+/// Invoke a compute kernel on a pair of arrays
+/// The binary_primitive_array_op macro only evaluates for primitive types
+/// like integers and floats.
+macro_rules! binary_primitive_array_op_dyn {
+ ($LEFT:expr, $RIGHT:expr, $OP:ident) => {{
+ match $LEFT.data_type() {
+ DataType::Decimal128(_, _) => {
+ Ok(paste::expr! {[<$OP _decimal>]}(&$LEFT, &$RIGHT)?)
+ }
+ DataType::Dictionary(_, value_type)
+ if matches!(value_type.as_ref(), &DataType::Decimal128(_, _))
=>
+ {
+ Ok(paste::expr! {[<$OP _decimal>]}(&$LEFT, &$RIGHT)?)
+ }
+ _ => Ok(Arc::new(
+ $OP(&$LEFT, &$RIGHT).map_err(|err|
DataFusionError::ArrowError(err))?,
+ )),
+ }
+ }};
+}
+
/// Invoke a compute dyn kernel on an array and a scalar
/// The binary_primitive_array_op_dyn_scalar macro only evaluates for primitive
/// types like integers and floats.
@@ -1116,10 +1138,14 @@ impl BinaryExpr {
Operator::IsNotDistinctFrom => {
binary_array_op!(left, right, is_not_distinct_from)
}
- Operator::Plus => binary_primitive_array_op!(left, right, add),
- Operator::Minus => binary_primitive_array_op!(left, right,
subtract),
- Operator::Multiply => binary_primitive_array_op!(left, right,
multiply),
- Operator::Divide => binary_primitive_array_op!(left, right,
divide_opt),
+ Operator::Plus => binary_primitive_array_op_dyn!(left, right,
add_dyn),
+ Operator::Minus => binary_primitive_array_op_dyn!(left, right,
subtract_dyn),
+ Operator::Multiply => {
+ binary_primitive_array_op_dyn!(left, right, multiply_dyn)
+ }
+ Operator::Divide => {
+ binary_primitive_array_op_dyn!(left, right, divide_dyn_opt)
+ }
Operator::Modulo => binary_primitive_array_op!(left, right,
modulus),
Operator::And => {
if left_data_type == &DataType::Boolean {
@@ -1639,6 +1665,100 @@ mod tests {
Ok(())
}
+ #[test]
+ #[cfg(feature = "dictionary_expressions")]
+ fn plus_op_dict() -> Result<()> {
+ let schema = Schema::new(vec![
+ Field::new(
+ "a",
+ DataType::Dictionary(Box::new(DataType::Int8),
Box::new(DataType::Int32)),
+ true,
+ ),
+ Field::new(
+ "b",
+ DataType::Dictionary(Box::new(DataType::Int8),
Box::new(DataType::Int32)),
+ true,
+ ),
+ ]);
+
+ let a = Int32Array::from(vec![1, 2, 3, 4, 5]);
+ let keys = Int8Array::from(vec![Some(0), None, Some(1), Some(3),
None]);
+ let a = DictionaryArray::try_new(&keys, &a)?;
+
+ let b = Int32Array::from(vec![1, 2, 4, 8, 16]);
+ let keys = Int8Array::from(vec![0, 1, 1, 2, 1]);
+ let b = DictionaryArray::try_new(&keys, &b)?;
+
+ apply_arithmetic::<Int32Type>(
+ Arc::new(schema),
+ vec![Arc::new(a), Arc::new(b)],
+ Operator::Plus,
+ Int32Array::from(vec![Some(2), None, Some(4), Some(8), None]),
+ )?;
+
+ Ok(())
+ }
+
+ #[test]
+ #[cfg(feature = "dictionary_expressions")]
+ fn plus_op_dict_decimal() -> Result<()> {
+ let schema = Schema::new(vec![
+ Field::new(
+ "a",
+ DataType::Dictionary(
+ Box::new(DataType::Int8),
+ Box::new(DataType::Decimal128(10, 0)),
+ ),
+ true,
+ ),
+ Field::new(
+ "b",
+ DataType::Dictionary(
+ Box::new(DataType::Int8),
+ Box::new(DataType::Decimal128(10, 0)),
+ ),
+ true,
+ ),
+ ]);
+
+ let value = 123;
+ let decimal_array = Arc::new(create_decimal_array(
+ &[
+ Some(value),
+ Some(value + 2),
+ Some(value - 1),
+ Some(value + 1),
+ ],
+ 10,
+ 0,
+ )) as ArrayRef;
+
+ let keys = Int8Array::from(vec![Some(0), Some(2), None, Some(3),
Some(0)]);
+ let a = DictionaryArray::try_new(&keys, &decimal_array)?;
+
+ let keys = Int8Array::from(vec![Some(0), None, Some(3), Some(2),
Some(2)]);
+ let decimal_array = create_decimal_array(
+ &[
+ Some(value + 1),
+ Some(value + 3),
+ Some(value),
+ Some(value + 2),
+ ],
+ 10,
+ 0,
+ );
+ let b = DictionaryArray::try_new(&keys, &decimal_array)?;
+
+ apply_arithmetic(
+ Arc::new(schema),
+ vec![Arc::new(a), Arc::new(b)],
+ Operator::Plus,
+ create_decimal_array(&[Some(247), None, None, Some(247),
Some(246)], 10, 0),
+ )?;
+
+ Ok(())
+ }
+
#[test]
fn plus_op_scalar() -> Result<()> {
let schema = Schema::new(vec![Field::new("a", DataType::Int32,
false)]);
@@ -1764,6 +1884,100 @@ mod tests {
Ok(())
}
+ #[test]
+ #[cfg(feature = "dictionary_expressions")]
+ fn minus_op_dict() -> Result<()> {
+ let schema = Schema::new(vec![
+ Field::new(
+ "a",
+ DataType::Dictionary(Box::new(DataType::Int8),
Box::new(DataType::Int32)),
+ true,
+ ),
+ Field::new(
+ "b",
+ DataType::Dictionary(Box::new(DataType::Int8),
Box::new(DataType::Int32)),
+ true,
+ ),
+ ]);
+
+ let a = Int32Array::from(vec![1, 2, 3, 4, 5]);
+ let keys = Int8Array::from(vec![Some(0), None, Some(1), Some(3),
None]);
+ let a = DictionaryArray::try_new(&keys, &a)?;
+
+ let b = Int32Array::from(vec![1, 2, 4, 8, 16]);
+ let keys = Int8Array::from(vec![0, 1, 1, 2, 1]);
+ let b = DictionaryArray::try_new(&keys, &b)?;
+
+ apply_arithmetic::<Int32Type>(
+ Arc::new(schema),
+ vec![Arc::new(a), Arc::new(b)],
+ Operator::Minus,
+ Int32Array::from(vec![Some(0), None, Some(0), Some(0), None]),
+ )?;
+
+ Ok(())
+ }
+
+ #[test]
+ #[cfg(feature = "dictionary_expressions")]
+ fn minus_op_dict_decimal() -> Result<()> {
+ let schema = Schema::new(vec![
+ Field::new(
+ "a",
+ DataType::Dictionary(
+ Box::new(DataType::Int8),
+ Box::new(DataType::Decimal128(10, 0)),
+ ),
+ true,
+ ),
+ Field::new(
+ "b",
+ DataType::Dictionary(
+ Box::new(DataType::Int8),
+ Box::new(DataType::Decimal128(10, 0)),
+ ),
+ true,
+ ),
+ ]);
+
+ let value = 123;
+ let decimal_array = Arc::new(create_decimal_array(
+ &[
+ Some(value),
+ Some(value + 2),
+ Some(value - 1),
+ Some(value + 1),
+ ],
+ 10,
+ 0,
+ )) as ArrayRef;
+
+ let keys = Int8Array::from(vec![Some(0), Some(2), None, Some(3),
Some(0)]);
+ let a = DictionaryArray::try_new(&keys, &decimal_array)?;
+
+ let keys = Int8Array::from(vec![Some(0), None, Some(3), Some(2),
Some(2)]);
+ let decimal_array = create_decimal_array(
+ &[
+ Some(value + 1),
+ Some(value + 3),
+ Some(value),
+ Some(value + 2),
+ ],
+ 10,
+ 0,
+ );
+ let b = DictionaryArray::try_new(&keys, &decimal_array)?;
+
+ apply_arithmetic(
+ Arc::new(schema),
+ vec![Arc::new(a), Arc::new(b)],
+ Operator::Minus,
+ create_decimal_array(&[Some(-1), None, None, Some(1), Some(0)],
10, 0),
+ )?;
+
+ Ok(())
+ }
+
#[test]
fn minus_op_scalar() -> Result<()> {
let schema = Schema::new(vec![Field::new("a", DataType::Int32,
false)]);
@@ -1881,6 +2095,104 @@ mod tests {
Ok(())
}
+ #[test]
+ #[cfg(feature = "dictionary_expressions")]
+ fn multiply_op_dict() -> Result<()> {
+ let schema = Schema::new(vec![
+ Field::new(
+ "a",
+ DataType::Dictionary(Box::new(DataType::Int8),
Box::new(DataType::Int32)),
+ true,
+ ),
+ Field::new(
+ "b",
+ DataType::Dictionary(Box::new(DataType::Int8),
Box::new(DataType::Int32)),
+ true,
+ ),
+ ]);
+
+ let a = Int32Array::from(vec![1, 2, 3, 4, 5]);
+ let keys = Int8Array::from(vec![Some(0), None, Some(1), Some(3),
None]);
+ let a = DictionaryArray::try_new(&keys, &a)?;
+
+ let b = Int32Array::from(vec![1, 2, 4, 8, 16]);
+ let keys = Int8Array::from(vec![0, 1, 1, 2, 1]);
+ let b = DictionaryArray::try_new(&keys, &b)?;
+
+ apply_arithmetic::<Int32Type>(
+ Arc::new(schema),
+ vec![Arc::new(a), Arc::new(b)],
+ Operator::Multiply,
+ Int32Array::from(vec![Some(1), None, Some(4), Some(16), None]),
+ )?;
+
+ Ok(())
+ }
+
+ #[test]
+ #[cfg(feature = "dictionary_expressions")]
+ fn multiply_op_dict_decimal() -> Result<()> {
+ let schema = Schema::new(vec![
+ Field::new(
+ "a",
+ DataType::Dictionary(
+ Box::new(DataType::Int8),
+ Box::new(DataType::Decimal128(10, 0)),
+ ),
+ true,
+ ),
+ Field::new(
+ "b",
+ DataType::Dictionary(
+ Box::new(DataType::Int8),
+ Box::new(DataType::Decimal128(10, 0)),
+ ),
+ true,
+ ),
+ ]);
+
+ let value = 123;
+ let decimal_array = Arc::new(create_decimal_array(
+ &[
+ Some(value),
+ Some(value + 2),
+ Some(value - 1),
+ Some(value + 1),
+ ],
+ 10,
+ 0,
+ )) as ArrayRef;
+
+ let keys = Int8Array::from(vec![Some(0), Some(2), None, Some(3),
Some(0)]);
+ let a = DictionaryArray::try_new(&keys, &decimal_array)?;
+
+ let keys = Int8Array::from(vec![Some(0), None, Some(3), Some(2),
Some(2)]);
+ let decimal_array = create_decimal_array(
+ &[
+ Some(value + 1),
+ Some(value + 3),
+ Some(value),
+ Some(value + 2),
+ ],
+ 10,
+ 0,
+ );
+ let b = DictionaryArray::try_new(&keys, &decimal_array)?;
+
+ apply_arithmetic(
+ Arc::new(schema),
+ vec![Arc::new(a), Arc::new(b)],
+ Operator::Multiply,
+ create_decimal_array(
+ &[Some(15252), None, None, Some(15252), Some(15129)],
+ 10,
+ 0,
+ ),
+ )?;
+
+ Ok(())
+ }
+
#[test]
fn multiply_op_scalar() -> Result<()> {
let schema = Schema::new(vec![Field::new("a", DataType::Int32,
false)]);
@@ -1995,6 +2307,106 @@ mod tests {
Ok(())
}
+ #[test]
+ #[cfg(feature = "dictionary_expressions")]
+ fn divide_op_dict() -> Result<()> {
+ let schema = Schema::new(vec![
+ Field::new(
+ "a",
+ DataType::Dictionary(Box::new(DataType::Int8),
Box::new(DataType::Int32)),
+ true,
+ ),
+ Field::new(
+ "b",
+ DataType::Dictionary(Box::new(DataType::Int8),
Box::new(DataType::Int32)),
+ true,
+ ),
+ ]);
+
+ let mut dict_builder = PrimitiveDictionaryBuilder::<Int8Type,
Int32Type>::new();
+
+ dict_builder.append(1)?;
+ dict_builder.append_null();
+ dict_builder.append(2)?;
+ dict_builder.append(5)?;
+ dict_builder.append(0)?;
+
+ let a = dict_builder.finish();
+
+ let b = Int32Array::from(vec![1, 2, 4, 8, 16]);
+ let keys = Int8Array::from(vec![0, 1, 1, 2, 1]);
+ let b = DictionaryArray::try_new(&keys, &b)?;
+
+ apply_arithmetic::<Int32Type>(
+ Arc::new(schema),
+ vec![Arc::new(a), Arc::new(b)],
+ Operator::Divide,
+ Int32Array::from(vec![Some(1), None, Some(1), Some(1), Some(0)]),
+ )?;
+
+ Ok(())
+ }
+
+ #[test]
+ #[cfg(feature = "dictionary_expressions")]
+ fn divide_op_dict_decimal() -> Result<()> {
+ let schema = Schema::new(vec![
+ Field::new(
+ "a",
+ DataType::Dictionary(
+ Box::new(DataType::Int8),
+ Box::new(DataType::Decimal128(10, 0)),
+ ),
+ true,
+ ),
+ Field::new(
+ "b",
+ DataType::Dictionary(
+ Box::new(DataType::Int8),
+ Box::new(DataType::Decimal128(10, 0)),
+ ),
+ true,
+ ),
+ ]);
+
+ let value = 123;
+ let decimal_array = Arc::new(create_decimal_array(
+ &[
+ Some(value),
+ Some(value + 2),
+ Some(value - 1),
+ Some(value + 1),
+ ],
+ 10,
+ 0,
+ )) as ArrayRef;
+
+ let keys = Int8Array::from(vec![Some(0), Some(2), None, Some(3),
Some(0)]);
+ let a = DictionaryArray::try_new(&keys, &decimal_array)?;
+
+ let keys = Int8Array::from(vec![Some(0), None, Some(3), Some(2),
Some(2)]);
+ let decimal_array = create_decimal_array(
+ &[
+ Some(value + 1),
+ Some(value + 3),
+ Some(value),
+ Some(value + 2),
+ ],
+ 10,
+ 0,
+ );
+ let b = DictionaryArray::try_new(&keys, &decimal_array)?;
+
+ apply_arithmetic(
+ Arc::new(schema),
+ vec![Arc::new(a), Arc::new(b)],
+ Operator::Divide,
+ create_decimal_array(&[Some(0), None, None, Some(1), Some(1)], 10,
0),
+ )?;
+
+ Ok(())
+ }
+
#[test]
fn divide_op_scalar() -> Result<()> {
let schema = Schema::new(vec![Field::new("a", DataType::Int32,
false)]);
diff --git a/datafusion/physical-expr/src/expressions/binary/kernels_arrow.rs
b/datafusion/physical-expr/src/expressions/binary/kernels_arrow.rs
index b75040f41..7bbce39a4 100644
--- a/datafusion/physical-expr/src/expressions/binary/kernels_arrow.rs
+++ b/datafusion/physical-expr/src/expressions/binary/kernels_arrow.rs
@@ -19,9 +19,8 @@
//! destined for arrow-rs but are in datafusion until they are ported.
use arrow::compute::{
- add, add_scalar_dyn, divide_opt, divide_scalar, divide_scalar_dyn, modulus,
- modulus_scalar, multiply, multiply_scalar, multiply_scalar_dyn, subtract,
- subtract_scalar_dyn,
+ add_dyn, add_scalar_dyn, divide_dyn_opt, divide_scalar_dyn, modulus,
modulus_scalar,
+ multiply_dyn, multiply_scalar_dyn, subtract_dyn, subtract_scalar_dyn,
};
use arrow::datatypes::Decimal128Type;
use arrow::{array::*, datatypes::ArrowNumericType, downcast_dictionary_array};
@@ -179,13 +178,10 @@ pub(crate) fn is_not_distinct_from_decimal(
.collect())
}
-pub(crate) fn add_decimal(
- left: &Decimal128Array,
- right: &Decimal128Array,
-) -> Result<Decimal128Array> {
- let array =
- add(left, right)?.with_precision_and_scale(left.precision(),
left.scale())?;
- Ok(array)
+pub(crate) fn add_dyn_decimal(left: &dyn Array, right: &dyn Array) ->
Result<ArrayRef> {
+ let (precision, scale) = get_precision_scale(left)?;
+ let array = add_dyn(left, right)?;
+ decimal_array_with_precision_scale(array, precision, scale)
}
pub(crate) fn add_decimal_dyn_scalar(left: &dyn Array, right: i128) ->
Result<ArrayRef> {
@@ -282,35 +278,38 @@ pub(crate) fn divide_decimal_dyn_scalar(
decimal_array_with_precision_scale(array, precision, scale)
}
-pub(crate) fn subtract_decimal(
- left: &Decimal128Array,
- right: &Decimal128Array,
-) -> Result<Decimal128Array> {
- let array = subtract(left, right)?
- .with_precision_and_scale(left.precision(), left.scale())?;
- Ok(array)
+pub(crate) fn subtract_dyn_decimal(
+ left: &dyn Array,
+ right: &dyn Array,
+) -> Result<ArrayRef> {
+ let (precision, scale) = get_precision_scale(left)?;
+ let array = subtract_dyn(left, right)?;
+ decimal_array_with_precision_scale(array, precision, scale)
}
-pub(crate) fn multiply_decimal(
- left: &Decimal128Array,
- right: &Decimal128Array,
-) -> Result<Decimal128Array> {
- let divide = 10_i128.pow(left.scale() as u32);
- let array = multiply(left, right)?;
- let array = divide_scalar(&array, divide)?
- .with_precision_and_scale(left.precision(), left.scale())?;
- Ok(array)
+pub(crate) fn multiply_dyn_decimal(
+ left: &dyn Array,
+ right: &dyn Array,
+) -> Result<ArrayRef> {
+ let (precision, scale) = get_precision_scale(left)?;
+
+ let divide = 10_i128.pow(scale as u32);
+ let array = multiply_dyn(left, right)?;
+ let array = divide_scalar_dyn::<Decimal128Type>(&array, divide)?;
+ decimal_array_with_precision_scale(array, precision, scale)
}
-pub(crate) fn divide_opt_decimal(
- left: &Decimal128Array,
- right: &Decimal128Array,
-) -> Result<Decimal128Array> {
- let mul = 10_i128.pow(left.scale() as u32);
- let array = multiply_scalar(left, mul)?;
- let array = divide_opt(&array, right)?
- .with_precision_and_scale(left.precision(), left.scale())?;
- Ok(array)
+pub(crate) fn divide_dyn_opt_decimal(
+ left: &dyn Array,
+ right: &dyn Array,
+) -> Result<ArrayRef> {
+ let (precision, scale) = get_precision_scale(left)?;
+
+ let mul = 10_i128.pow(scale as u32);
+ let array = multiply_scalar_dyn::<Decimal128Type>(left, mul)?;
+ let array = decimal_array_with_precision_scale(array, precision, scale)?;
+ let array = divide_dyn_opt(&array, right)?;
+ decimal_array_with_precision_scale(array, precision, scale)
}
pub(crate) fn modulus_decimal(
@@ -425,28 +424,31 @@ mod tests {
3,
);
// add
- let result = add_decimal(&left_decimal_array, &right_decimal_array)?;
+ let result = add_dyn_decimal(&left_decimal_array,
&right_decimal_array)?;
+ let result = as_decimal128_array(&result)?;
let expect =
create_decimal_array(&[Some(246), None, Some(245), Some(247)], 25,
3);
- assert_eq!(expect, result);
+ assert_eq!(&expect, result);
let result = add_decimal_dyn_scalar(&left_decimal_array, 10)?;
let result = as_decimal128_array(&result)?;
let expect =
create_decimal_array(&[Some(133), None, Some(132), Some(134)], 25,
3);
assert_eq!(&expect, result);
// subtract
- let result = subtract_decimal(&left_decimal_array,
&right_decimal_array)?;
+ let result = subtract_dyn_decimal(&left_decimal_array,
&right_decimal_array)?;
+ let result = as_decimal128_array(&result)?;
let expect = create_decimal_array(&[Some(0), None, Some(-1), Some(1)],
25, 3);
- assert_eq!(expect, result);
+ assert_eq!(&expect, result);
let result = subtract_decimal_dyn_scalar(&left_decimal_array, 10)?;
let result = as_decimal128_array(&result)?;
let expect =
create_decimal_array(&[Some(113), None, Some(112), Some(114)], 25,
3);
assert_eq!(&expect, result);
// multiply
- let result = multiply_decimal(&left_decimal_array,
&right_decimal_array)?;
+ let result = multiply_dyn_decimal(&left_decimal_array,
&right_decimal_array)?;
+ let result = as_decimal128_array(&result)?;
let expect = create_decimal_array(&[Some(15), None, Some(15),
Some(15)], 25, 3);
- assert_eq!(expect, result);
+ assert_eq!(&expect, result);
let result = multiply_decimal_dyn_scalar(&left_decimal_array, 10)?;
let result = as_decimal128_array(&result)?;
let expect = create_decimal_array(&[Some(1), None, Some(1), Some(1)],
25, 3);
@@ -468,13 +470,14 @@ mod tests {
25,
3,
);
- let result = divide_opt_decimal(&left_decimal_array,
&right_decimal_array)?;
+ let result = divide_dyn_opt_decimal(&left_decimal_array,
&right_decimal_array)?;
+ let result = as_decimal128_array(&result)?;
let expect = create_decimal_array(
&[Some(123456700), None, Some(22446672), Some(-10037130), None],
25,
3,
);
- assert_eq!(expect, result);
+ assert_eq!(&expect, result);
let result = divide_decimal_dyn_scalar(&left_decimal_array, 10)?;
let result = as_decimal128_array(&result)?;
let expect = create_decimal_array(
