feat(expr): Implementation for bitwise operation

e2e_test/batch/bitwise.slt

@@ -0,0 +1,29 @@
+query I
+values(3&5);
+----
+1
+
+query I
+values(3|5);
+----
+7
+
+query I
+values(3#5);
+----
+6
+
+query I
+values(1<<2);
+----
+4
+
+query I
+values(4>>2);
+----
+1
+
+query I
+values(~1);
+----
+-2

proto/expr.proto

@@ -29,6 +29,13 @@ message ExprNode {
     OR = 22;
     NOT = 23;
     IN = 24;
+    // bitwise operators
+    BITWISE_AND = 31;
+    BITWISE_OR = 32;
+    BITWISE_XOR = 33;
+    BITWISE_NOT = 34;
+    BITWISE_SHIFT_LEFT = 35;
+    BITWISE_SHIFT_RIGHT = 36;
     // date functions
     EXTRACT = 101;
     TUMBLE_START = 103;

src/expr/src/expr/expr_binary_nonnull.rs

@@ -23,6 +23,7 @@ use crate::expr::template::BinaryExpression;
 use crate::expr::BoxedExpression;
 use crate::for_all_cmp_variants;
 use crate::vector_op::arithmetic_op::*;
+use crate::vector_op::bitwise_op::*;
 use crate::vector_op::cmp::*;
 use crate::vector_op::extract::{extract_from_date, extract_from_timestamp};
 use crate::vector_op::like::like_default;
@@ -102,6 +103,38 @@ macro_rules! gen_cmp_impl {
     };
 }
 
+/// This macro helps create bitwise shift expression. The Output type is same as LHS of the
+/// expression and the RHS of the expression is being match into u32. Similar to `gen_atm_impl`.
+macro_rules! gen_shift_impl {
+    ([$l:expr, $r:expr, $ret:expr], $( { $i1:ident, $i2:ident, $func:ident },)*) => {
+        match ($l.return_type(), $r.return_type()) {
+            $(
+                ($i1! { type_match_pattern }, $i2! { type_match_pattern }) => {
+                    Box::new(
+                        BinaryExpression::<
+                            $i1! { type_array },
+                            $i2! { type_array },
+                            $i1! { type_array },
+                            _
+                        >::new(
+                            $l,
+                            $r,
+                            $ret,
+                            $func::<
+                                <$i1! { type_array } as Array>::OwnedItem,
+                                <$i2! { type_array } as Array>::OwnedItem>,
+
+                        )
+                    )
+                },
+            )*
+            _ => {
+                unimplemented!("The expression ({:?}, {:?}, {:?}) using vectorized expression framework is not supported yet!", $l.return_type(), $r.return_type(), $ret)
+            }
+        }
+    };
+}
+
 /// Based on the data type of `$l`, `$r`, `$ret`, return corresponding expression struct with scalar
 /// function inside.
 /// * `$l`: left expression
@@ -206,6 +239,70 @@ macro_rules! gen_binary_expr_atm {
     };
 }
 
+/// `gen_binary_expr_bitwise` is similar to `gen_binary_expr_atm`.
+/// They are differentiate because bitwise operation only supports integral datatype.
+/// * `$general_f`: generic atm function (require a common ``TryInto`` type for two input)
+/// * `$i1`, `$i2`, `$rt`, `$func`: extra list passed to `$macro` directly
+macro_rules! gen_binary_expr_bitwise {
+    (
+        $macro:ident,
+        $l:expr,
+        $r:expr,
+        $ret:expr,
+        $general_f:ident,
+        {
+            $( { $i1:ident, $i2:ident, $rt:ident, $func:ident }, )*
+        } $(,)?
+    ) => {
+        $macro! {
+            [$l, $r, $ret],
+            { int16, int16, int16, $general_f },
+            { int16, int32, int32, $general_f },
+            { int16, int64, int64, $general_f },
+            { int32, int16, int32, $general_f },
+            { int32, int32, int32, $general_f },
+            { int32, int64, int64, $general_f },
+            { int64, int16,int64, $general_f },
+            { int64, int32,int64, $general_f },
+            { int64, int64, int64, $general_f },
+            $(
+                { $i1, $i2, $rt, $func },
+            )*
+        }
+    };
+}
+
+/// `gen_binary_expr_shift` is similar to `gen_binary_expr_bitwise`.
+/// They are differentiate because shift operation have different typing rules.
+/// * `$general_f`: generic atm function
+/// `$rt` is not required because Type of the output is same as the Type of LHS of expression.
+/// * `$i1`, `$i2`, `$func`: extra list passed to `$macro` directly
+macro_rules! gen_binary_expr_shift {
+    (
+        $macro:ident,
+        $l:expr,
+        $r:expr,
+        $ret:expr,
+        $general_f:ident,
+        {
+            $( { $i1:ident, $i2:ident, $func:ident }, )*
+        } $(,)?
+    ) => {
+        $macro! {
+            [$l, $r, $ret],
+            { int16, int16, $general_f },
+            { int32, int16, $general_f },
+            { int16, int32, $general_f },
+            { int32, int32, $general_f },
+            { int64, int16, $general_f },
+            { int64, int32, $general_f },
+            $(
+                { $i1, $i2, $func },
+            )*
+        }
+    };
+}
+
 fn build_extract_expr(ret: DataType, l: BoxedExpression, r: BoxedExpression) -> BoxedExpression {
     match r.return_type() {
         DataType::Date => Box::new(
@@ -315,6 +412,54 @@ pub fn new_binary_expr(
                 },
             }
         }
+        // BitWise Operation
+        Type::BitwiseShiftLeft => {
+            gen_binary_expr_shift! {
+                gen_shift_impl,
+                l, r, ret,
+                general_shl,
+                {
+
+                },
+            }
+        }
+        Type::BitwiseShiftRight => {
+            gen_binary_expr_shift! {
+                gen_shift_impl,
+                l, r, ret,
+                general_shr,
+                {
+
+                },
+            }
+        }
+        Type::BitwiseAnd => {
+            gen_binary_expr_bitwise! {
+                gen_atm_impl,
+                l, r, ret,
+                general_bitand,
+                {
+                },
+            }
+        }
+        Type::BitwiseOr => {
+            gen_binary_expr_bitwise! {
+                gen_atm_impl,
+                l, r, ret,
+                general_bitor,
+                {
+                },
+            }
+        }
+        Type::BitwiseXor => {
+            gen_binary_expr_bitwise! {
+                gen_atm_impl,
+                l, r, ret,
+                general_bitxor,
+                {
+                },
+            }
+        }
         Type::Extract => build_extract_expr(ret, l, r),
         Type::RoundDigit => Box::new(
             BinaryExpression::<DecimalArray, I32Array, DecimalArray, _>::new(
@@ -328,6 +473,7 @@ pub fn new_binary_expr(
             l, r, ret, position,
         )),
         Type::TumbleStart => new_tumble_start(l, r, ret),
+
         tp => {
             unimplemented!(
                 "The expression {:?} using vectorized expression framework is not supported yet!",

src/expr/src/expr/expr_unary.rs

@@ -25,6 +25,7 @@ use crate::expr::template::UnaryNullableExpression;
 use crate::expr::BoxedExpression;
 use crate::vector_op::arithmetic_op::{decimal_abs, general_abs, general_neg};
 use crate::vector_op::ascii::ascii;
+use crate::vector_op::bitwise_op::general_bitnot;
 use crate::vector_op::cast::*;
 use crate::vector_op::cmp::{is_false, is_not_false, is_not_true, is_true};
 use crate::vector_op::conjunction;
@@ -302,6 +303,15 @@ pub fn new_unary_expr(
                 }
             }
         }
+        (ProstType::BitwiseNot, _, _) => {
+            gen_unary_impl! {
+                [ "BitwiseNot", child_expr, return_type],
+                { int16, int16, general_bitnot },
+                { int32, int32, general_bitnot },
+                { int64, int64, general_bitnot },
+
+            }
+        }
         (ProstType::Ceil, _, _) => {
             gen_round_expr! {"Ceil", child_expr, return_type, ceil_f64, ceil_decimal}
         }

src/expr/src/expr/mod.rs

@@ -80,10 +80,14 @@ pub fn build_from_prost(prost: &ExprNode) -> Result<BoxedExpression> {
 
     match prost.get_expr_type()? {
         Cast | Upper | Lower | Md5 | Not | IsTrue | IsNotTrue | IsFalse | IsNotFalse | IsNull
-        | IsNotNull | Neg | Ascii | Abs | Ceil | Floor | Round => build_unary_expr_prost(prost),
+        | IsNotNull | Neg | Ascii | Abs | Ceil | Floor | Round | BitwiseNot => {
+            build_unary_expr_prost(prost)
+        }
         Equal | NotEqual | LessThan | LessThanOrEqual | GreaterThan | GreaterThanOrEqual | Add
         | Subtract | Multiply | Divide | Modulus | Extract | RoundDigit | TumbleStart
-        | Position => build_binary_expr_prost(prost),
+        | Position | BitwiseShiftLeft | BitwiseShiftRight | BitwiseAnd | BitwiseOr | BitwiseXor => {
+            build_binary_expr_prost(prost)
+        }
         And | Or | IsDistinctFrom | ArrayAccess => build_nullable_binary_expr_prost(prost),
         ToChar => build_to_char_expr(prost),
         Coalesce => CoalesceExpression::try_from(prost).map(Expression::boxed),

src/expr/src/lib.rs

@@ -30,6 +30,7 @@
 #![feature(is_sorted)]
 #![feature(backtrace)]
 #![feature(fn_traits)]
+#![feature(assert_matches)]
 
 pub mod expr;
 pub mod vector_op;

src/expr/src/vector_op/bitwise_op.rs

@@ -0,0 +1,105 @@
+// Copyright 2022 Singularity Data
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+use std::any::type_name;
+use std::convert::TryInto;
+use std::fmt::Debug;
+use std::ops::{BitAnd, BitOr, BitXor, Not};
+
+use num_traits::{CheckedShl, CheckedShr};
+use risingwave_common::error::ErrorCode::{InternalError, NumericValueOutOfRange};
+use risingwave_common::error::{Result, RwError};
+
+use crate::vector_op::arithmetic_op::general_atm;
+
+// Conscious decision for shl and shr is made here to diverge from PostgreSQL.
+// If overflow happens, instead of truncated to zero, we return overflow error as this is
+// undefined behaviour. If the RHS is negative, instead of having an unexpected answer, we return an
+// error. If PG had clearly defined behavior rather than relying on UB of C, we would follow it even
+// when it is different from rust std.
+#[inline(always)]
+pub fn general_shl<T1, T2>(l: T1, r: T2) -> Result<T1>
+where
+    T1: CheckedShl + Debug,
+    T2: TryInto<u32> + Debug,
+{
+    general_shift(l, r, |a, b| {
+        a.checked_shl(b)
+            .ok_or_else(|| RwError::from(NumericValueOutOfRange))
+    })
+}
+
+#[inline(always)]
+pub fn general_shr<T1, T2>(l: T1, r: T2) -> Result<T1>
+where
+    T1: CheckedShr + Debug,
+    T2: TryInto<u32> + Debug,
+{
+    general_shift(l, r, |a, b| {
+        a.checked_shr(b)
+            .ok_or_else(|| RwError::from(NumericValueOutOfRange))
+    })
+}
+
+#[inline(always)]
+pub fn general_shift<T1, T2, F>(l: T1, r: T2, atm: F) -> Result<T1>
+where
+    T1: Debug,
+    T2: TryInto<u32> + Debug,
+    F: FnOnce(T1, u32) -> Result<T1>,
+{
+    // TODO: We need to improve the error message
+    let r: u32 = r.try_into().map_err(|_| {
+        RwError::from(InternalError(format!(
+            "Can't convert {} to {}",
+            type_name::<T2>(),
+            type_name::<u32>()
+        )))
+    })?;
+    atm(l, r)
+}
+
+#[inline(always)]
+pub fn general_bitand<T1, T2, T3>(l: T1, r: T2) -> Result<T3>
+where
+    T1: TryInto<T3> + Debug,
+    T2: TryInto<T3> + Debug,
+    T3: BitAnd<Output = T3>,
+{
+    general_atm(l, r, |a, b| Ok(a.bitand(b)))
+}
+
+#[inline(always)]
+pub fn general_bitor<T1, T2, T3>(l: T1, r: T2) -> Result<T3>
+where
+    T1: TryInto<T3> + Debug,
+    T2: TryInto<T3> + Debug,
+    T3: BitOr<Output = T3>,
+{
+    general_atm(l, r, |a, b| Ok(a.bitor(b)))
+}
+
+#[inline(always)]
+pub fn general_bitxor<T1, T2, T3>(l: T1, r: T2) -> Result<T3>
+where
+    T1: TryInto<T3> + Debug,
+    T2: TryInto<T3> + Debug,
+    T3: BitXor<Output = T3>,
+{
+    general_atm(l, r, |a, b| Ok(a.bitxor(b)))
+}
+
+#[inline(always)]
+pub fn general_bitnot<T1: Not<Output = T1>>(expr: T1) -> Result<T1> {
+    Ok(expr.not())
+}

src/expr/src/vector_op/mod.rs

@@ -16,6 +16,7 @@ pub mod agg;
 pub mod arithmetic_op;
 pub mod array_access;
 pub mod ascii;
+pub mod bitwise_op;
 pub mod cast;
 pub mod cmp;
 pub mod conjunction;