Numeric ops

src/antlr4/Cypher.g4

@@ -309,15 +309,26 @@ oC_NotExpression
 NOT : ( 'N' | 'n' ) ( 'O' | 'o' ) ( 'T' | 't' ) ;
 
 oC_ComparisonExpression
-    : oC_AddOrSubtractExpression ( SP? kU_ComparisonOperator SP? oC_AddOrSubtractExpression )?
-        | oC_AddOrSubtractExpression ( SP? INVALID_NOT_EQUAL SP? oC_AddOrSubtractExpression ) { notifyInvalidNotEqualOperator($INVALID_NOT_EQUAL); }
-        | oC_AddOrSubtractExpression SP? kU_ComparisonOperator SP? oC_AddOrSubtractExpression ( SP? kU_ComparisonOperator SP? oC_AddOrSubtractExpression )+ { notifyNonBinaryComparison($ctx->start); }
+    : kU_BitwiseOrOperatorExpression ( SP? kU_ComparisonOperator SP? kU_BitwiseOrOperatorExpression )?
+        | kU_BitwiseOrOperatorExpression ( SP? INVALID_NOT_EQUAL SP? kU_BitwiseOrOperatorExpression ) { notifyInvalidNotEqualOperator($INVALID_NOT_EQUAL); }
+        | kU_BitwiseOrOperatorExpression SP? kU_ComparisonOperator SP? kU_BitwiseOrOperatorExpression ( SP? kU_ComparisonOperator SP? kU_BitwiseOrOperatorExpression )+ { notifyNonBinaryComparison($ctx->start); }
         ;
 
 kU_ComparisonOperator : '=' | '<>' | '<' | '<=' | '>' | '>=' ;
 
 INVALID_NOT_EQUAL : '!=' ;
 
+kU_BitwiseOrOperatorExpression
+    : kU_BitwiseAndOperatorExpression ( SP? '|' SP? kU_BitwiseAndOperatorExpression )* ;
+
+kU_BitwiseAndOperatorExpression
+    : kU_BitShiftOperatorExpression ( SP? '&' SP? kU_BitShiftOperatorExpression )* ;
+
+kU_BitShiftOperatorExpression
+    : oC_AddOrSubtractExpression ( SP? kU_BitShiftOperator SP? oC_AddOrSubtractExpression )* ;
+
+kU_BitShiftOperator : '>>' | '<<' ;
+
 oC_AddOrSubtractExpression
     : oC_MultiplyDivideModuloExpression ( SP? kU_AddOrSubtractOperator SP? oC_MultiplyDivideModuloExpression )* ;
 
@@ -329,13 +340,15 @@ oC_MultiplyDivideModuloExpression
 kU_MultiplyDivideModuloOperator : '*' | '/' | '%' ;
 
 oC_PowerOfExpression
-    : oC_UnaryAddOrSubtractExpression ( SP? '^' SP? oC_UnaryAddOrSubtractExpression )* ;
+    : oC_UnaryAddSubtractOrFactorialExpression ( SP? '^' SP? oC_UnaryAddSubtractOrFactorialExpression )* ;
 
-oC_UnaryAddOrSubtractExpression
-    : ( MINUS SP? )? oC_StringListNullOperatorExpression ;
+oC_UnaryAddSubtractOrFactorialExpression
+    : ( MINUS SP? )? oC_StringListNullOperatorExpression (SP? FACTORIAL)? ;
 
 MINUS : '-' ;
 
+FACTORIAL : '!' ;
+
 oC_StringListNullOperatorExpression
     : oC_PropertyOrLabelsExpression ( oC_StringOperatorExpression | oC_ListOperatorExpression | oC_NullOperatorExpression )? ;
 

src/function/built_in_vector_operations.cpp

@@ -188,6 +188,12 @@ void BuiltInVectorOperations::registerArithmeticOperations() {
     vectorOperations.insert({ATAN_FUNC_NAME, AtanVectorOperation::getDefinitions()});
     vectorOperations.insert({ATAN2_FUNC_NAME, Atan2VectorOperation::getDefinitions()});
     vectorOperations.insert({BITWISE_XOR_FUNC_NAME, BitwiseXorVectorOperation::getDefinitions()});
+    vectorOperations.insert({BITWISE_AND_FUNC_NAME, BitwiseAndVectorOperation::getDefinitions()});
+    vectorOperations.insert({BITWISE_OR_FUNC_NAME, BitwiseOrVectorOperation::getDefinitions()});
+    vectorOperations.insert(
+        {BITSHIFT_LEFT_FUNC_NAME, BitShiftLeftVectorOperation::getDefinitions()});
+    vectorOperations.insert(
+        {BITSHIFT_RIGHT_FUNC_NAME, BitShiftRightVectorOperation::getDefinitions()});
     vectorOperations.insert({CBRT_FUNC_NAME, CbrtVectorOperation::getDefinitions()});
     vectorOperations.insert({CEIL_FUNC_NAME, CeilVectorOperation::getDefinitions()});
     vectorOperations.insert({CEILING_FUNC_NAME, CeilVectorOperation::getDefinitions()});

src/function/vector_arithmetic_operations.cpp

@@ -363,6 +363,38 @@ vector<unique_ptr<VectorOperationDefinition>> BitwiseXorVectorOperation::getDefi
     return result;
 }
 
+vector<unique_ptr<VectorOperationDefinition>> BitwiseAndVectorOperation::getDefinitions() {
+    vector<unique_ptr<VectorOperationDefinition>> result;
+    result.push_back(make_unique<VectorOperationDefinition>(BITWISE_AND_FUNC_NAME,
+        vector<DataTypeID>{INT64, INT64}, INT64,
+        BinaryExecFunction<int64_t, int64_t, int64_t, operation::BitwiseAnd>));
+    return result;
+}
+
+vector<unique_ptr<VectorOperationDefinition>> BitwiseOrVectorOperation::getDefinitions() {
+    vector<unique_ptr<VectorOperationDefinition>> result;
+    result.push_back(make_unique<VectorOperationDefinition>(BITWISE_OR_FUNC_NAME,
+        vector<DataTypeID>{INT64, INT64}, INT64,
+        BinaryExecFunction<int64_t, int64_t, int64_t, operation::BitwiseOr>));
+    return result;
+}
+
+vector<unique_ptr<VectorOperationDefinition>> BitShiftLeftVectorOperation::getDefinitions() {
+    vector<unique_ptr<VectorOperationDefinition>> result;
+    result.push_back(make_unique<VectorOperationDefinition>(BITSHIFT_LEFT_FUNC_NAME,
+        vector<DataTypeID>{INT64, INT64}, INT64,
+        BinaryExecFunction<int64_t, int64_t, int64_t, operation::BitShiftLeft>));
+    return result;
+}
+
+vector<unique_ptr<VectorOperationDefinition>> BitShiftRightVectorOperation::getDefinitions() {
+    vector<unique_ptr<VectorOperationDefinition>> result;
+    result.push_back(make_unique<VectorOperationDefinition>(BITSHIFT_RIGHT_FUNC_NAME,
+        vector<DataTypeID>{INT64, INT64}, INT64,
+        BinaryExecFunction<int64_t, int64_t, int64_t, operation::BitShiftRight>));
+    return result;
+}
+
 vector<unique_ptr<VectorOperationDefinition>> PiVectorOperation::getDefinitions() {
     vector<unique_ptr<VectorOperationDefinition>> result;
     result.push_back(make_unique<VectorOperationDefinition>(

src/include/common/expression_type.h

@@ -80,6 +80,10 @@ const string ASIN_FUNC_NAME = "ASIN";
 const string ATAN_FUNC_NAME = "ATAN";
 const string ATAN2_FUNC_NAME = "ATAN2";
 const string BITWISE_XOR_FUNC_NAME = "BITWISE_XOR";
+const string BITWISE_AND_FUNC_NAME = "BITWISE_AND";
+const string BITWISE_OR_FUNC_NAME = "BITWISE_OR";
+const string BITSHIFT_LEFT_FUNC_NAME = "BITSHIFT_LEFT";
+const string BITSHIFT_RIGHT_FUNC_NAME = "BITSHIFT_RIGHT";
 const string CBRT_FUNC_NAME = "CBRT";
 const string CEIL_FUNC_NAME = "CEIL";
 const string CEILING_FUNC_NAME = "CEILING";

src/include/function/arithmetic/arithmetic_operations.h

@@ -263,6 +263,30 @@ struct BitwiseXor {
     }
 };
 
+struct BitwiseAnd {
+    static inline void operation(int64_t& left, int64_t& right, int64_t& result) {
+        result = left & right;
+    }
+};
+
+struct BitwiseOr {
+    static inline void operation(int64_t& left, int64_t& right, int64_t& result) {
+        result = left | right;
+    }
+};
+
+struct BitShiftLeft {
+    static inline void operation(int64_t& left, int64_t& right, int64_t& result) {
+        result = left << right;
+    }
+};
+
+struct BitShiftRight {
+    static inline void operation(int64_t& left, int64_t& right, int64_t& result) {
+        result = left >> right;
+    }
+};
+
 struct Pi {
     static inline void operation(double_t& result) { result = M_PI; }
 };

src/include/function/arithmetic/vector_arithmetic_operations.h

@@ -140,6 +140,22 @@ struct BitwiseXorVectorOperation : public VectorArithmeticOperations {
     static vector<unique_ptr<VectorOperationDefinition>> getDefinitions();
 };
 
+struct BitwiseAndVectorOperation : public VectorArithmeticOperations {
+    static vector<unique_ptr<VectorOperationDefinition>> getDefinitions();
+};
+
+struct BitwiseOrVectorOperation : public VectorArithmeticOperations {
+    static vector<unique_ptr<VectorOperationDefinition>> getDefinitions();
+};
+
+struct BitShiftLeftVectorOperation : public VectorArithmeticOperations {
+    static vector<unique_ptr<VectorOperationDefinition>> getDefinitions();
+};
+
+struct BitShiftRightVectorOperation : public VectorArithmeticOperations {
+    static vector<unique_ptr<VectorOperationDefinition>> getDefinitions();
+};
+
 struct CbrtVectorOperation : public VectorArithmeticOperations {
     static vector<unique_ptr<VectorOperationDefinition>> getDefinitions();
 };

src/include/parser/transformer.h

@@ -109,6 +109,15 @@ class Transformer {
     unique_ptr<ParsedExpression> transformComparisonExpression(
         CypherParser::OC_ComparisonExpressionContext& ctx);
 
+    unique_ptr<ParsedExpression> transformBitwiseOrOperatorExpression(
+        CypherParser::KU_BitwiseOrOperatorExpressionContext& ctx);
+
+    unique_ptr<ParsedExpression> transformBitwiseAndOperatorExpression(
+        CypherParser::KU_BitwiseAndOperatorExpressionContext& ctx);
+
+    unique_ptr<ParsedExpression> transformBitShiftOperatorExpression(
+        CypherParser::KU_BitShiftOperatorExpressionContext& ctx);
+
     unique_ptr<ParsedExpression> transformAddOrSubtractExpression(
         CypherParser::OC_AddOrSubtractExpressionContext& ctx);
 
@@ -118,8 +127,8 @@ class Transformer {
     unique_ptr<ParsedExpression> transformPowerOfExpression(
         CypherParser::OC_PowerOfExpressionContext& ctx);
 
-    unique_ptr<ParsedExpression> transformUnaryAddOrSubtractExpression(
-        CypherParser::OC_UnaryAddOrSubtractExpressionContext& ctx);
+    unique_ptr<ParsedExpression> transformUnaryAddSubtractOrFactorialExpression(
+        CypherParser::OC_UnaryAddSubtractOrFactorialExpressionContext& ctx);
 
     unique_ptr<ParsedExpression> transformStringListNullOperatorExpression(
         CypherParser::OC_StringListNullOperatorExpressionContext& ctx);

src/parser/transformer.cpp

@@ -386,14 +386,14 @@ unique_ptr<ParsedExpression> Transformer::transformNotExpression(
 
 unique_ptr<ParsedExpression> Transformer::transformComparisonExpression(
     CypherParser::OC_ComparisonExpressionContext& ctx) {
-    if (1 == ctx.oC_AddOrSubtractExpression().size()) {
-        return transformAddOrSubtractExpression(*ctx.oC_AddOrSubtractExpression(0));
+    if (1 == ctx.kU_BitwiseOrOperatorExpression().size()) {
+        return transformBitwiseOrOperatorExpression(*ctx.kU_BitwiseOrOperatorExpression(0));
     }
     // Antlr parser throws error for conjunctive comparison.
     // Transformer should only handle the case of single comparison operator.
     assert(ctx.kU_ComparisonOperator().size() == 1);
-    auto left = transformAddOrSubtractExpression(*ctx.oC_AddOrSubtractExpression(0));
-    auto right = transformAddOrSubtractExpression(*ctx.oC_AddOrSubtractExpression(1));
+    auto left = transformBitwiseOrOperatorExpression(*ctx.kU_BitwiseOrOperatorExpression(0));
+    auto right = transformBitwiseOrOperatorExpression(*ctx.kU_BitwiseOrOperatorExpression(1));
     auto comparisonOperator = ctx.kU_ComparisonOperator()[0]->getText();
     if (comparisonOperator == "=") {
         return make_unique<ParsedExpression>(
@@ -417,6 +417,62 @@ unique_ptr<ParsedExpression> Transformer::transformComparisonExpression(
     }
 }
 
+unique_ptr<ParsedExpression> Transformer::transformBitwiseOrOperatorExpression(
+    CypherParser::KU_BitwiseOrOperatorExpressionContext& ctx) {
+    unique_ptr<ParsedExpression> expression;
+    for (auto i = 0ul; i < ctx.kU_BitwiseAndOperatorExpression().size(); ++i) {
+        auto next = transformBitwiseAndOperatorExpression(*ctx.kU_BitwiseAndOperatorExpression(i));
+        if (!expression) {
+            expression = std::move(next);
+        } else {
+            auto rawName = expression->getRawName() + " | " + next->getRawName();
+            expression = make_unique<ParsedFunctionExpression>(
+                BITWISE_OR_FUNC_NAME, std::move(expression), std::move(next), rawName);
+        }
+    }
+    return expression;
+}
+
+unique_ptr<ParsedExpression> Transformer::transformBitwiseAndOperatorExpression(
+    CypherParser::KU_BitwiseAndOperatorExpressionContext& ctx) {
+    unique_ptr<ParsedExpression> expression;
+    for (auto i = 0ul; i < ctx.kU_BitShiftOperatorExpression().size(); ++i) {
+        auto next = transformBitShiftOperatorExpression(*ctx.kU_BitShiftOperatorExpression(i));
+        if (!expression) {
+            expression = std::move(next);
+        } else {
+            auto rawName = expression->getRawName() + " & " + next->getRawName();
+            expression = make_unique<ParsedFunctionExpression>(
+                BITWISE_AND_FUNC_NAME, std::move(expression), std::move(next), rawName);
+        }
+    }
+    return expression;
+}
+
+unique_ptr<ParsedExpression> Transformer::transformBitShiftOperatorExpression(
+    CypherParser::KU_BitShiftOperatorExpressionContext& ctx) {
+    unique_ptr<ParsedExpression> expression;
+    for (auto i = 0ul; i < ctx.oC_AddOrSubtractExpression().size(); ++i) {
+        auto next = transformAddOrSubtractExpression(*ctx.oC_AddOrSubtractExpression(i));
+        if (!expression) {
+            expression = std::move(next);
+        } else {
+            auto bitShiftOperator = ctx.kU_BitShiftOperator(i - 1)->getText();
+            auto rawName =
+                expression->getRawName() + " " + bitShiftOperator + " " + next->getRawName();
+            if (bitShiftOperator == "<<") {
+                expression = make_unique<ParsedFunctionExpression>(
+                    BITSHIFT_LEFT_FUNC_NAME, std::move(expression), std::move(next), rawName);
+            } else {
+                assert(bitwiseOperator == ">>");
+                expression = make_unique<ParsedFunctionExpression>(
+                    BITSHIFT_RIGHT_FUNC_NAME, std::move(expression), std::move(next), rawName);
+            }
+        }
+    }
+    return expression;
+}
+
 unique_ptr<ParsedExpression> Transformer::transformAddOrSubtractExpression(
     CypherParser::OC_AddOrSubtractExpressionContext& ctx) {
     unique_ptr<ParsedExpression> expression;
@@ -457,8 +513,8 @@ unique_ptr<ParsedExpression> Transformer::transformMultiplyDivideModuloExpressio
 unique_ptr<ParsedExpression> Transformer::transformPowerOfExpression(
     CypherParser::OC_PowerOfExpressionContext& ctx) {
     unique_ptr<ParsedExpression> expression;
-    for (auto& unaryAddOrSubtractExpression : ctx.oC_UnaryAddOrSubtractExpression()) {
-        auto next = transformUnaryAddOrSubtractExpression(*unaryAddOrSubtractExpression);
+    for (auto& unaryAddOrSubtractExpression : ctx.oC_UnaryAddSubtractOrFactorialExpression()) {
+        auto next = transformUnaryAddSubtractOrFactorialExpression(*unaryAddOrSubtractExpression);
         if (!expression) {
             expression = std::move(next);
         } else {
@@ -470,12 +526,22 @@ unique_ptr<ParsedExpression> Transformer::transformPowerOfExpression(
     return expression;
 }
 
-unique_ptr<ParsedExpression> Transformer::transformUnaryAddOrSubtractExpression(
-    CypherParser::OC_UnaryAddOrSubtractExpressionContext& ctx) {
-    if (ctx.MINUS()) {
+unique_ptr<ParsedExpression> Transformer::transformUnaryAddSubtractOrFactorialExpression(
+    CypherParser::OC_UnaryAddSubtractOrFactorialExpressionContext& ctx) {
+    if (ctx.MINUS() && ctx.FACTORIAL()) {
+        auto exp1 = make_unique<ParsedFunctionExpression>(FACTORIAL_FUNC_NAME,
+            transformStringListNullOperatorExpression(*ctx.oC_StringListNullOperatorExpression()),
+            ctx.getText());
+        return make_unique<ParsedFunctionExpression>(
+            NEGATE_FUNC_NAME, std::move(exp1), ctx.getText());
+    } else if (ctx.MINUS()) {
         return make_unique<ParsedFunctionExpression>(NEGATE_FUNC_NAME,
             transformStringListNullOperatorExpression(*ctx.oC_StringListNullOperatorExpression()),
             ctx.getText());
+    } else if (ctx.FACTORIAL()) {
+        return make_unique<ParsedFunctionExpression>(FACTORIAL_FUNC_NAME,
+            transformStringListNullOperatorExpression(*ctx.oC_StringListNullOperatorExpression()),
+            ctx.getText());
     }
     return transformStringListNullOperatorExpression(*ctx.oC_StringListNullOperatorExpression());
 }

test/test_files/tinysnb/function/arithmetic.test

@@ -123,6 +123,13 @@
 24
 87178291200
 
+-NAME factorialFunctionSyntaxInt64Test
+-QUERY MATCH (a:organisation) RETURN (a.orgCode % 20)!
+---- 3
+120
+24
+87178291200
+
 -NAME signFunctionOnDoubleTest
 -QUERY MATCH (a:organisation) RETURN sign(a.mark)
 ---- 3
@@ -332,3 +339,62 @@
 -2
 -100
 7
+
+-NAME BitwiseAndFunctionTest
+-QUERY MATCH (p:person) RETURN p.age & 21
+---- 8
+1
+20
+5
+20
+20
+17
+0
+17
+
+-NAME BitwiseOrFunctionTest
+-QUERY MATCH (o:organisation) RETURN o.score | 35
+---- 3
+-1
+-65
+39
+
+-NAME BitshiftLeftFunctionTest
+-QUERY MATCH (p:person) RETURN p.age << 2
+---- 8
+140
+120
+180
+80
+80
+100
+160
+332
+
+-NAME BitshiftRightFunctionTest
+-QUERY MATCH (o:organisation) RETURN o.orgCode >> 3
+---- 3
+40
+116
+103
+
+-NAME BitwiseOperatorPrecedenceTest
+-QUERY MATCH (o:organisation) RETURN o.orgCode >> 2 | o.score & 2 << 1
+---- 3
+85
+237
+206
+
+-NAME NumericalOperatorPrecedenceTest1
+-QUERY MATCH (o:organisation) RETURN 3 & (o.score + 50)
+---- 3
+0
+2
+1
+
+-NAME NumericalOperatorPrecedenceTest2
+-QUERY MATCH (o:organisation) RETURN 2 + 3 << 5 + 2 & 1 + o.orgCode
+---- 3
+0
+640
+512