This is an automated email from the ASF dual-hosted git repository.
alamb pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/arrow-datafusion.git
The following commit(s) were added to refs/heads/main by this push:
new a6f4a7719 feat: Support bitwise operations for unsigned integer types
(#5476)
a6f4a7719 is described below
commit a6f4a7719e4cf449fe3f85a68cdd06a7f9bece85
Author: Igor Izvekov <[email protected]>
AuthorDate: Mon Mar 6 21:32:06 2023 +0300
feat: Support bitwise operations for unsigned integer types (#5476)
* feat: Support bitwise operations for unsigned integer types
* fix: remove useless .unwrap()
* feat: add some tests to scalar.slt for uint types
* fix: tests in scalar.slt
* fix: merge tables into one table in scalat.slt
* fix: documentation for new tests in scalar.slt
* add: "query I rowsort" to selection in scalar.slt
---
.../core/tests/sqllogictests/test_files/scalar.slt | 50 ++-
datafusion/expr/src/type_coercion/binary.rs | 59 ++-
datafusion/physical-expr/src/expressions/binary.rs | 99 ++++-
.../src/expressions/binary/kernels.rs | 400 +++++++++++++++++++--
4 files changed, 567 insertions(+), 41 deletions(-)
diff --git a/datafusion/core/tests/sqllogictests/test_files/scalar.slt
b/datafusion/core/tests/sqllogictests/test_files/scalar.slt
index bd6346c16..348789bd0 100644
--- a/datafusion/core/tests/sqllogictests/test_files/scalar.slt
+++ b/datafusion/core/tests/sqllogictests/test_files/scalar.slt
@@ -22,11 +22,13 @@
statement ok
CREATE TABLE t1(
a INT,
- b INT
+ b INT,
+ c INT,
+ d INT
) as VALUES
- (1, 100),
- (2, 1000),
- (3, 10000)
+ (1, 100, 567, 1024),
+ (2, 1000, 123, 256),
+ (3, 10000, 978, 2048)
;
# log scalar function
@@ -68,3 +70,43 @@ query RR rowsort
select log(0) a, log(1, 64) b
----
-Infinity Infinity
+
+# bitwise and with column and scalar
+query I rowsort
+select c & 856 from t1;
+----
+528
+848
+88
+
+# bitwise or with column and scalar
+query I rowsort
+select c | 856 from t1;
+----
+891
+895
+986
+
+# bitwise xor with column and scalar
+query I rowsort
+select c ^ 856 from t1;
+----
+138
+367
+803
+
+# right shift with column and scalar
+query I rowsort
+select d >> 2 from t1;
+----
+256
+512
+64
+
+# left shift with column and scalar
+query I rowsort
+select d << 2 from t1;
+----
+1024
+4096
+8192
diff --git a/datafusion/expr/src/type_coercion/binary.rs
b/datafusion/expr/src/type_coercion/binary.rs
index ba24f4a90..d2e081af1 100644
--- a/datafusion/expr/src/type_coercion/binary.rs
+++ b/datafusion/expr/src/type_coercion/binary.rs
@@ -173,12 +173,27 @@ fn bitwise_coercion(left_type: &DataType, right_type:
&DataType) -> Option<DataT
return Some(left_type.clone());
}
- // TODO support other data type
match (left_type, right_type) {
- (Int64, _) | (_, Int64) => Some(Int64),
- (Int32, _) | (_, Int32) => Some(Int32),
- (Int16, _) | (_, Int16) => Some(Int16),
+ (UInt64, _) | (_, UInt64) => Some(UInt64),
+ (Int64, _)
+ | (_, Int64)
+ | (UInt32, Int8)
+ | (Int8, UInt32)
+ | (UInt32, Int16)
+ | (Int16, UInt32)
+ | (UInt32, Int32)
+ | (Int32, UInt32) => Some(Int64),
+ (Int32, _)
+ | (_, Int32)
+ | (UInt16, Int16)
+ | (Int16, UInt16)
+ | (UInt16, Int8)
+ | (Int8, UInt16) => Some(Int32),
+ (UInt32, _) | (_, UInt32) => Some(UInt32),
+ (Int16, _) | (_, Int16) | (Int8, UInt8) | (UInt8, Int8) => Some(Int16),
+ (UInt16, _) | (_, UInt16) => Some(UInt16),
(Int8, _) | (_, Int8) => Some(Int8),
+ (UInt8, _) | (_, UInt8) => Some(UInt8),
_ => None,
}
}
@@ -1035,6 +1050,42 @@ mod tests {
Operator::BitwiseAnd,
DataType::Int64
);
+ test_coercion_binary_rule!(
+ DataType::UInt64,
+ DataType::UInt64,
+ Operator::BitwiseAnd,
+ DataType::UInt64
+ );
+ test_coercion_binary_rule!(
+ DataType::Int8,
+ DataType::UInt32,
+ Operator::BitwiseAnd,
+ DataType::Int64
+ );
+ test_coercion_binary_rule!(
+ DataType::UInt32,
+ DataType::Int32,
+ Operator::BitwiseAnd,
+ DataType::Int64
+ );
+ test_coercion_binary_rule!(
+ DataType::UInt16,
+ DataType::Int16,
+ Operator::BitwiseAnd,
+ DataType::Int32
+ );
+ test_coercion_binary_rule!(
+ DataType::UInt32,
+ DataType::UInt32,
+ Operator::BitwiseAnd,
+ DataType::UInt32
+ );
+ test_coercion_binary_rule!(
+ DataType::UInt16,
+ DataType::UInt32,
+ Operator::BitwiseAnd,
+ DataType::UInt32
+ );
Ok(())
}
diff --git a/datafusion/physical-expr/src/expressions/binary.rs
b/datafusion/physical-expr/src/expressions/binary.rs
index a0dd9a41d..fe268c5a3 100644
--- a/datafusion/physical-expr/src/expressions/binary.rs
+++ b/datafusion/physical-expr/src/expressions/binary.rs
@@ -1663,16 +1663,28 @@ mod tests {
vec![0i64, 0i64, 1i64],
);
test_coercion!(
- Int16Array,
- DataType::Int16,
- vec![1i16, 2i16, 3i16],
- Int64Array,
- DataType::Int64,
- vec![10i64, 4i64, 5i64],
+ UInt16Array,
+ DataType::UInt16,
+ vec![1u16, 2u16, 3u16],
+ UInt64Array,
+ DataType::UInt64,
+ vec![10u64, 4u64, 5u64],
+ Operator::BitwiseAnd,
+ UInt64Array,
+ DataType::UInt64,
+ vec![0u64, 0u64, 1u64],
+ );
+ test_coercion!(
+ UInt16Array,
+ DataType::UInt16,
+ vec![1u16, 2u16, 3u16],
+ UInt64Array,
+ DataType::UInt64,
+ vec![10u64, 4u64, 5u64],
Operator::BitwiseOr,
- Int64Array,
- DataType::Int64,
- vec![11i64, 6i64, 7i64],
+ UInt64Array,
+ DataType::UInt64,
+ vec![11u64, 6u64, 7u64],
);
test_coercion!(
Int16Array,
@@ -1686,6 +1698,18 @@ mod tests {
DataType::Int64,
vec![9i64, 4i64, 6i64],
);
+ test_coercion!(
+ UInt16Array,
+ DataType::UInt16,
+ vec![3u16, 2u16, 3u16],
+ UInt64Array,
+ DataType::UInt64,
+ vec![10u64, 6u64, 5u64],
+ Operator::BitwiseXor,
+ UInt64Array,
+ DataType::UInt64,
+ vec![9u64, 4u64, 6u64],
+ );
Ok(())
}
@@ -4093,6 +4117,22 @@ mod tests {
let expected = Int32Array::from(vec![Some(13), None, Some(12)]);
assert_eq!(result.as_ref(), &expected);
+ let left =
+ Arc::new(UInt32Array::from(vec![Some(12), None, Some(11)])) as
ArrayRef;
+ let right =
+ Arc::new(UInt32Array::from(vec![Some(1), Some(3), Some(7)])) as
ArrayRef;
+ let mut result = bitwise_and(left.clone(), right.clone())?;
+ let expected = UInt32Array::from(vec![Some(0), None, Some(3)]);
+ assert_eq!(result.as_ref(), &expected);
+
+ result = bitwise_or(left.clone(), right.clone())?;
+ let expected = UInt32Array::from(vec![Some(13), None, Some(15)]);
+ assert_eq!(result.as_ref(), &expected);
+
+ result = bitwise_xor(left.clone(), right.clone())?;
+ let expected = UInt32Array::from(vec![Some(13), None, Some(12)]);
+ assert_eq!(result.as_ref(), &expected);
+
Ok(())
}
@@ -4109,6 +4149,17 @@ mod tests {
result = bitwise_shift_right(result.clone(), modules.clone())?;
assert_eq!(result.as_ref(), &input);
+ let input =
+ Arc::new(UInt32Array::from(vec![Some(2), None, Some(10)])) as
ArrayRef;
+ let modules =
+ Arc::new(UInt32Array::from(vec![Some(2), Some(4), Some(8)])) as
ArrayRef;
+ let mut result = bitwise_shift_left(input.clone(), modules.clone())?;
+
+ let expected = UInt32Array::from(vec![Some(8), None, Some(2560)]);
+ assert_eq!(result.as_ref(), &expected);
+
+ result = bitwise_shift_right(result.clone(), modules.clone())?;
+ assert_eq!(result.as_ref(), &input);
Ok(())
}
@@ -4121,6 +4172,12 @@ mod tests {
let expected = Int32Array::from(vec![Some(32)]);
assert_eq!(result.as_ref(), &expected);
+ let input = Arc::new(UInt32Array::from(vec![Some(2)])) as ArrayRef;
+ let modules = Arc::new(UInt32Array::from(vec![Some(100)])) as ArrayRef;
+ let result = bitwise_shift_left(input.clone(), modules.clone())?;
+
+ let expected = UInt32Array::from(vec![Some(32)]);
+ assert_eq!(result.as_ref(), &expected);
Ok(())
}
@@ -4139,6 +4196,21 @@ mod tests {
result = bitwise_xor_scalar(&left, right).unwrap()?;
let expected = Int32Array::from(vec![Some(15), None, Some(8)]);
assert_eq!(result.as_ref(), &expected);
+
+ let left =
+ Arc::new(UInt32Array::from(vec![Some(12), None, Some(11)])) as
ArrayRef;
+ let right = ScalarValue::from(3u32);
+ let mut result = bitwise_and_scalar(&left, right.clone()).unwrap()?;
+ let expected = UInt32Array::from(vec![Some(0), None, Some(3)]);
+ assert_eq!(result.as_ref(), &expected);
+
+ result = bitwise_or_scalar(&left, right.clone()).unwrap()?;
+ let expected = UInt32Array::from(vec![Some(15), None, Some(11)]);
+ assert_eq!(result.as_ref(), &expected);
+
+ result = bitwise_xor_scalar(&left, right).unwrap()?;
+ let expected = UInt32Array::from(vec![Some(15), None, Some(8)]);
+ assert_eq!(result.as_ref(), &expected);
Ok(())
}
@@ -4154,6 +4226,15 @@ mod tests {
result = bitwise_shift_right_scalar(&result, module).unwrap()?;
assert_eq!(result.as_ref(), &input);
+ let input = Arc::new(UInt32Array::from(vec![Some(2), None, Some(4)]))
as ArrayRef;
+ let module = ScalarValue::from(10u32);
+ let mut result = bitwise_shift_left_scalar(&input,
module.clone()).unwrap()?;
+
+ let expected = UInt32Array::from(vec![Some(2048), None, Some(4096)]);
+ assert_eq!(result.as_ref(), &expected);
+
+ result = bitwise_shift_right_scalar(&result, module).unwrap()?;
+ assert_eq!(result.as_ref(), &input);
Ok(())
}
diff --git a/datafusion/physical-expr/src/expressions/binary/kernels.rs
b/datafusion/physical-expr/src/expressions/binary/kernels.rs
index 9414ea11c..f38180e92 100644
--- a/datafusion/physical-expr/src/expressions/binary/kernels.rs
+++ b/datafusion/physical-expr/src/expressions/binary/kernels.rs
@@ -76,16 +76,28 @@ macro_rules! binary_bitwise_array_scalar {
pub(crate) fn bitwise_and(left: ArrayRef, right: ArrayRef) -> Result<ArrayRef>
{
match &left.data_type() {
DataType::Int8 => {
- binary_bitwise_array_op!(left, right, |a, b| a & b, Int8Array)
+ binary_bitwise_array_op!(left, right, |a: i8, b: i8| a & b,
Int8Array)
}
DataType::Int16 => {
- binary_bitwise_array_op!(left, right, |a, b| a & b, Int16Array)
+ binary_bitwise_array_op!(left, right, |a: i16, b: i16| a & b,
Int16Array)
}
DataType::Int32 => {
- binary_bitwise_array_op!(left, right, |a, b| a & b, Int32Array)
+ binary_bitwise_array_op!(left, right, |a: i32, b: i32| a & b,
Int32Array)
}
DataType::Int64 => {
- binary_bitwise_array_op!(left, right, |a, b| a & b, Int64Array)
+ binary_bitwise_array_op!(left, right, |a: i64, b: i64| a & b,
Int64Array)
+ }
+ DataType::UInt8 => {
+ binary_bitwise_array_op!(left, right, |a: u8, b: u8| a & b,
UInt8Array)
+ }
+ DataType::UInt16 => {
+ binary_bitwise_array_op!(left, right, |a: u16, b: u16| a & b,
UInt16Array)
+ }
+ DataType::UInt32 => {
+ binary_bitwise_array_op!(left, right, |a: u32, b: u32| a & b,
UInt32Array)
+ }
+ DataType::UInt64 => {
+ binary_bitwise_array_op!(left, right, |a: u64, b: u64| a & b,
UInt64Array)
}
other => Err(DataFusionError::Internal(format!(
"Data type {:?} not supported for binary operation '{}' on dyn
arrays",
@@ -129,6 +141,38 @@ pub(crate) fn bitwise_shift_right(left: ArrayRef, right:
ArrayRef) -> Result<Arr
Int64Array
)
}
+ DataType::UInt8 => {
+ binary_bitwise_array_op!(
+ left,
+ right,
+ |a: u8, b: u8| a.wrapping_shr(b as u32),
+ UInt8Array
+ )
+ }
+ DataType::UInt16 => {
+ binary_bitwise_array_op!(
+ left,
+ right,
+ |a: u16, b: u16| a.wrapping_shr(b as u32),
+ UInt16Array
+ )
+ }
+ DataType::UInt32 => {
+ binary_bitwise_array_op!(
+ left,
+ right,
+ |a: u32, b: u32| a.wrapping_shr(b),
+ UInt32Array
+ )
+ }
+ DataType::UInt64 => {
+ binary_bitwise_array_op!(
+ left,
+ right,
+ |a: u64, b: u64| a.wrapping_shr(b.try_into().unwrap()),
+ UInt64Array
+ )
+ }
other => Err(DataFusionError::Internal(format!(
"Data type {:?} not supported for binary operation '{}' on dyn
arrays",
other,
@@ -171,6 +215,38 @@ pub(crate) fn bitwise_shift_left(left: ArrayRef, right:
ArrayRef) -> Result<Arra
Int64Array
)
}
+ DataType::UInt8 => {
+ binary_bitwise_array_op!(
+ left,
+ right,
+ |a: u8, b: u8| a.wrapping_shl(b as u32),
+ UInt8Array
+ )
+ }
+ DataType::UInt16 => {
+ binary_bitwise_array_op!(
+ left,
+ right,
+ |a: u16, b: u16| a.wrapping_shl(b as u32),
+ UInt16Array
+ )
+ }
+ DataType::UInt32 => {
+ binary_bitwise_array_op!(
+ left,
+ right,
+ |a: u32, b: u32| a.wrapping_shl(b),
+ UInt32Array
+ )
+ }
+ DataType::UInt64 => {
+ binary_bitwise_array_op!(
+ left,
+ right,
+ |a: u64, b: u64| a.wrapping_shr(b.try_into().unwrap()),
+ UInt64Array
+ )
+ }
other => Err(DataFusionError::Internal(format!(
"Data type {:?} not supported for binary operation '{}' on dyn
arrays",
other,
@@ -182,16 +258,28 @@ pub(crate) fn bitwise_shift_left(left: ArrayRef, right:
ArrayRef) -> Result<Arra
pub(crate) fn bitwise_or(left: ArrayRef, right: ArrayRef) -> Result<ArrayRef> {
match &left.data_type() {
DataType::Int8 => {
- binary_bitwise_array_op!(left, right, |a, b| a | b, Int8Array)
+ binary_bitwise_array_op!(left, right, |a: i8, b: i8| a | b,
Int8Array)
}
DataType::Int16 => {
- binary_bitwise_array_op!(left, right, |a, b| a | b, Int16Array)
+ binary_bitwise_array_op!(left, right, |a: i16, b: i16| a | b,
Int16Array)
}
DataType::Int32 => {
- binary_bitwise_array_op!(left, right, |a, b| a | b, Int32Array)
+ binary_bitwise_array_op!(left, right, |a: i32, b: i32| a | b,
Int32Array)
}
DataType::Int64 => {
- binary_bitwise_array_op!(left, right, |a, b| a | b, Int64Array)
+ binary_bitwise_array_op!(left, right, |a: i64, b: i64| a | b,
Int64Array)
+ }
+ DataType::UInt8 => {
+ binary_bitwise_array_op!(left, right, |a: u8, b: u8| a | b,
UInt8Array)
+ }
+ DataType::UInt16 => {
+ binary_bitwise_array_op!(left, right, |a: u16, b: u16| a | b,
UInt16Array)
+ }
+ DataType::UInt32 => {
+ binary_bitwise_array_op!(left, right, |a: u32, b: u32| a | b,
UInt32Array)
+ }
+ DataType::UInt64 => {
+ binary_bitwise_array_op!(left, right, |a: u64, b: u64| a | b,
UInt64Array)
}
other => Err(DataFusionError::Internal(format!(
"Data type {:?} not supported for binary operation '{}' on dyn
arrays",
@@ -204,16 +292,28 @@ pub(crate) fn bitwise_or(left: ArrayRef, right: ArrayRef)
-> Result<ArrayRef> {
pub(crate) fn bitwise_xor(left: ArrayRef, right: ArrayRef) -> Result<ArrayRef>
{
match &left.data_type() {
DataType::Int8 => {
- binary_bitwise_array_op!(left, right, |a, b| a ^ b, Int8Array)
+ binary_bitwise_array_op!(left, right, |a: i8, b: i8| a ^ b,
Int8Array)
}
DataType::Int16 => {
- binary_bitwise_array_op!(left, right, |a, b| a ^ b, Int16Array)
+ binary_bitwise_array_op!(left, right, |a: i16, b: i16| a ^ b,
Int16Array)
}
DataType::Int32 => {
- binary_bitwise_array_op!(left, right, |a, b| a ^ b, Int32Array)
+ binary_bitwise_array_op!(left, right, |a: i32, b: i32| a ^ b,
Int32Array)
}
DataType::Int64 => {
- binary_bitwise_array_op!(left, right, |a, b| a ^ b, Int64Array)
+ binary_bitwise_array_op!(left, right, |a: i64, b: i64| a ^ b,
Int64Array)
+ }
+ DataType::UInt8 => {
+ binary_bitwise_array_op!(left, right, |a: u8, b: u8| a ^ b,
UInt8Array)
+ }
+ DataType::UInt16 => {
+ binary_bitwise_array_op!(left, right, |a: u16, b: u16| a ^ b,
UInt16Array)
+ }
+ DataType::UInt32 => {
+ binary_bitwise_array_op!(left, right, |a: u32, b: u32| a ^ b,
UInt32Array)
+ }
+ DataType::UInt64 => {
+ binary_bitwise_array_op!(left, right, |a: u64, b: u64| a ^ b,
UInt64Array)
}
other => Err(DataFusionError::Internal(format!(
"Data type {:?} not supported for binary operation '{}' on dyn
arrays",
@@ -229,16 +329,76 @@ pub(crate) fn bitwise_and_scalar(
) -> Option<Result<ArrayRef>> {
let result = match array.data_type() {
DataType::Int8 => {
- binary_bitwise_array_scalar!(array, scalar, |a, b| a & b,
Int8Array, i8)
+ binary_bitwise_array_scalar!(
+ array,
+ scalar,
+ |a: i8, b: i8| a & b,
+ Int8Array,
+ i8
+ )
}
DataType::Int16 => {
- binary_bitwise_array_scalar!(array, scalar, |a, b| a & b,
Int16Array, i16)
+ binary_bitwise_array_scalar!(
+ array,
+ scalar,
+ |a: i16, b: i16| a & b,
+ Int16Array,
+ i16
+ )
}
DataType::Int32 => {
- binary_bitwise_array_scalar!(array, scalar, |a, b| a & b,
Int32Array, i32)
+ binary_bitwise_array_scalar!(
+ array,
+ scalar,
+ |a: i32, b: i32| a & b,
+ Int32Array,
+ i32
+ )
}
DataType::Int64 => {
- binary_bitwise_array_scalar!(array, scalar, |a, b| a & b,
Int64Array, i64)
+ binary_bitwise_array_scalar!(
+ array,
+ scalar,
+ |a: i64, b: i64| a & b,
+ Int64Array,
+ i64
+ )
+ }
+ DataType::UInt8 => {
+ binary_bitwise_array_scalar!(
+ array,
+ scalar,
+ |a: u8, b: u8| a & b,
+ UInt8Array,
+ u8
+ )
+ }
+ DataType::UInt16 => {
+ binary_bitwise_array_scalar!(
+ array,
+ scalar,
+ |a: u16, b: u16| a & b,
+ UInt16Array,
+ u16
+ )
+ }
+ DataType::UInt32 => {
+ binary_bitwise_array_scalar!(
+ array,
+ scalar,
+ |a: u32, b: u32| a & b,
+ UInt32Array,
+ u32
+ )
+ }
+ DataType::UInt64 => {
+ binary_bitwise_array_scalar!(
+ array,
+ scalar,
+ |a: u64, b: u64| a & b,
+ UInt64Array,
+ u64
+ )
}
other => Err(DataFusionError::Internal(format!(
"Data type {:?} not supported for binary operation '{}' on dyn
arrays",
@@ -255,16 +415,76 @@ pub(crate) fn bitwise_or_scalar(
) -> Option<Result<ArrayRef>> {
let result = match array.data_type() {
DataType::Int8 => {
- binary_bitwise_array_scalar!(array, scalar, |a, b| a | b,
Int8Array, i8)
+ binary_bitwise_array_scalar!(
+ array,
+ scalar,
+ |a: i8, b: i8| a | b,
+ Int8Array,
+ i8
+ )
}
DataType::Int16 => {
- binary_bitwise_array_scalar!(array, scalar, |a, b| a | b,
Int16Array, i16)
+ binary_bitwise_array_scalar!(
+ array,
+ scalar,
+ |a: i16, b: i16| a | b,
+ Int16Array,
+ i16
+ )
}
DataType::Int32 => {
- binary_bitwise_array_scalar!(array, scalar, |a, b| a | b,
Int32Array, i32)
+ binary_bitwise_array_scalar!(
+ array,
+ scalar,
+ |a: i32, b: i32| a | b,
+ Int32Array,
+ i32
+ )
}
DataType::Int64 => {
- binary_bitwise_array_scalar!(array, scalar, |a, b| a | b,
Int64Array, i64)
+ binary_bitwise_array_scalar!(
+ array,
+ scalar,
+ |a: i64, b: i64| a | b,
+ Int64Array,
+ i64
+ )
+ }
+ DataType::UInt8 => {
+ binary_bitwise_array_scalar!(
+ array,
+ scalar,
+ |a: u8, b: u8| a | b,
+ UInt8Array,
+ u8
+ )
+ }
+ DataType::UInt16 => {
+ binary_bitwise_array_scalar!(
+ array,
+ scalar,
+ |a: u16, b: u16| a | b,
+ UInt16Array,
+ u16
+ )
+ }
+ DataType::UInt32 => {
+ binary_bitwise_array_scalar!(
+ array,
+ scalar,
+ |a: u32, b: u32| a | b,
+ UInt32Array,
+ u32
+ )
+ }
+ DataType::UInt64 => {
+ binary_bitwise_array_scalar!(
+ array,
+ scalar,
+ |a: u64, b: u64| a | b,
+ UInt64Array,
+ u64
+ )
}
other => Err(DataFusionError::Internal(format!(
"Data type {:?} not supported for binary operation '{}' on dyn
arrays",
@@ -281,16 +501,76 @@ pub(crate) fn bitwise_xor_scalar(
) -> Option<Result<ArrayRef>> {
let result = match array.data_type() {
DataType::Int8 => {
- binary_bitwise_array_scalar!(array, scalar, |a, b| a ^ b,
Int8Array, i8)
+ binary_bitwise_array_scalar!(
+ array,
+ scalar,
+ |a: i8, b: i8| a ^ b,
+ Int8Array,
+ i8
+ )
}
DataType::Int16 => {
- binary_bitwise_array_scalar!(array, scalar, |a, b| a ^ b,
Int16Array, i16)
+ binary_bitwise_array_scalar!(
+ array,
+ scalar,
+ |a: i16, b: i16| a ^ b,
+ Int16Array,
+ i16
+ )
}
DataType::Int32 => {
- binary_bitwise_array_scalar!(array, scalar, |a, b| a ^ b,
Int32Array, i32)
+ binary_bitwise_array_scalar!(
+ array,
+ scalar,
+ |a: i32, b: i32| a ^ b,
+ Int32Array,
+ i32
+ )
}
DataType::Int64 => {
- binary_bitwise_array_scalar!(array, scalar, |a, b| a ^ b,
Int64Array, i64)
+ binary_bitwise_array_scalar!(
+ array,
+ scalar,
+ |a: i64, b: i64| a ^ b,
+ Int64Array,
+ i64
+ )
+ }
+ DataType::UInt8 => {
+ binary_bitwise_array_scalar!(
+ array,
+ scalar,
+ |a: u8, b: u8| a ^ b,
+ UInt8Array,
+ u8
+ )
+ }
+ DataType::UInt16 => {
+ binary_bitwise_array_scalar!(
+ array,
+ scalar,
+ |a: u16, b: u16| a ^ b,
+ UInt16Array,
+ u16
+ )
+ }
+ DataType::UInt32 => {
+ binary_bitwise_array_scalar!(
+ array,
+ scalar,
+ |a: u32, b: u32| a ^ b,
+ UInt32Array,
+ u32
+ )
+ }
+ DataType::UInt64 => {
+ binary_bitwise_array_scalar!(
+ array,
+ scalar,
+ |a: u64, b: u64| a ^ b,
+ UInt64Array,
+ u64
+ )
}
other => Err(DataFusionError::Internal(format!(
"Data type {:?} not supported for binary operation '{}' on dyn
arrays",
@@ -342,6 +622,42 @@ pub(crate) fn bitwise_shift_right_scalar(
i64
)
}
+ DataType::UInt8 => {
+ binary_bitwise_array_scalar!(
+ array,
+ scalar,
+ |a: u8, b: u8| a.wrapping_shr(b as u32),
+ UInt8Array,
+ u8
+ )
+ }
+ DataType::UInt16 => {
+ binary_bitwise_array_scalar!(
+ array,
+ scalar,
+ |a: u16, b: u16| a.wrapping_shr(b as u32),
+ UInt16Array,
+ u16
+ )
+ }
+ DataType::UInt32 => {
+ binary_bitwise_array_scalar!(
+ array,
+ scalar,
+ |a: u32, b: u32| a.wrapping_shr(b),
+ UInt32Array,
+ u32
+ )
+ }
+ DataType::UInt64 => {
+ binary_bitwise_array_scalar!(
+ array,
+ scalar,
+ |a: u64, b: u32| a.wrapping_shr(b),
+ UInt64Array,
+ u32
+ )
+ }
other => Err(DataFusionError::Internal(format!(
"Data type {:?} not supported for binary operation '{}' on dyn
arrays",
other,
@@ -392,6 +708,42 @@ pub(crate) fn bitwise_shift_left_scalar(
i64
)
}
+ DataType::UInt8 => {
+ binary_bitwise_array_scalar!(
+ array,
+ scalar,
+ |a: u8, b: u8| a.wrapping_shl(b as u32),
+ UInt8Array,
+ u8
+ )
+ }
+ DataType::UInt16 => {
+ binary_bitwise_array_scalar!(
+ array,
+ scalar,
+ |a: u16, b: u16| a.wrapping_shl(b as u32),
+ UInt16Array,
+ u16
+ )
+ }
+ DataType::UInt32 => {
+ binary_bitwise_array_scalar!(
+ array,
+ scalar,
+ |a: u32, b: u32| a.wrapping_shl(b),
+ UInt32Array,
+ u32
+ )
+ }
+ DataType::UInt64 => {
+ binary_bitwise_array_scalar!(
+ array,
+ scalar,
+ |a: u64, b: u32| a.wrapping_shr(b),
+ UInt64Array,
+ u32
+ )
+ }
other => Err(DataFusionError::Internal(format!(
"Data type {:?} not supported for binary operation '{}' on dyn
arrays",
other,
