diff --git a/src/parser/parser.yy b/src/parser/parser.yy
index 89322962188825eba208b0a55200bd4568a93f49..45480b40b9fdfb6dd6b8e969af001b1f149303d2 100644
--- a/src/parser/parser.yy
+++ b/src/parser/parser.yy
@@ -290,10 +290,11 @@ static constexpr size_t MAX_ABS_INTEGER = 9223372036854775808ULL;
 
 %left OR KW_OR KW_XOR
 %left AND KW_AND
+%right KW_NOT
 %left EQ NE LT LE GT GE KW_IN KW_NOT_IN KW_CONTAINS KW_NOT_CONTAINS KW_STARTS_WITH KW_ENDS_WITH KW_NOT_STARTS_WITH KW_NOT_ENDS_WITH
 %left PLUS MINUS
 %left STAR DIV MOD
-%right NOT KW_NOT
+%right NOT
 %nonassoc UNARY_PLUS
 %nonassoc UNARY_MINUS
 %nonassoc CASTING
diff --git a/src/parser/scanner.lex b/src/parser/scanner.lex
index f5a30c9316ab9dd973dbabdbb925ba84dbde6acc..7d5f3ef9ba5fd29070f04fb0cfb6f1423b88ac8a 100644
--- a/src/parser/scanner.lex
+++ b/src/parser/scanner.lex
@@ -376,9 +376,8 @@ FORMAT                      ([Ff][Oo][Rr][Mm][Aa][Tt])
 ">="                        { return TokenType::GE; }
 "=="                        { return TokenType::EQ; }
 "!="                        { return TokenType::NE; }
+"<>"                        { return TokenType::NE; }
 
-"||"                        { return TokenType::OR; }
-"&&"                        { return TokenType::AND; }
 "|"                         { return TokenType::PIPE; }
 
 "="                         { return TokenType::ASSIGN; }
diff --git a/src/parser/test/ExpressionParsingTest.cpp b/src/parser/test/ExpressionParsingTest.cpp
index a0ffc0767cad8ffa0b4d316a0dcd9534f815ba88..ba2da6b373d0c9fe2dc6d613466432a385737764 100644
--- a/src/parser/test/ExpressionParsingTest.cpp
+++ b/src/parser/test/ExpressionParsingTest.cpp
@@ -271,7 +271,7 @@ TEST_F(ExpressionParsingTest, Associativity) {
                                       make<LabelExpression>("a"),
                                       make<LabelExpression>("b")),
                                   make<LabelExpression>("c"));
-    add("a && b && c", ast);
+    add("a AND b AND c", ast);
 
     ast = make<LogicalExpression>(Kind::kLogicalAnd,
                                   make<LogicalExpression>(Kind::kLogicalAnd,
@@ -285,7 +285,7 @@ TEST_F(ExpressionParsingTest, Associativity) {
                                       make<LabelExpression>("a"),
                                       make<LabelExpression>("b")),
                                   make<LabelExpression>("c"));
-    add("a || b || c", ast);
+    add("a OR b OR c", ast);
 
     ast = make<LogicalExpression>(Kind::kLogicalOr,
                                   make<LogicalExpression>(Kind::kLogicalOr,
@@ -381,7 +381,30 @@ TEST_F(ExpressionParsingTest, Precedence) {
                                       make<RelationalExpression>(Kind::kRelEQ,
                                           make<ConstantExpression>(3),
                                           make<ConstantExpression>(4))));
-    add("+1 || 1 != 2 - 1 AND 3 == 4", ast);
+    add("+1 OR 1 != 2 - 1 AND 3 == 4", ast);
+
+    ast = make<UnaryExpression>(Kind::kUnaryNot,
+            make<RelationalExpression>(Kind::kRelLT,
+                make<ArithmeticExpression>(Kind::kAdd,
+                    make<ConstantExpression>(1),
+                    make<ConstantExpression>(2)),
+                make<ConstantExpression>(3)));
+    add("NOT 1 + 2 < 3", ast);
+
+    ast = make<LogicalExpression>(Kind::kLogicalAnd,
+            make<UnaryExpression>(Kind::kUnaryNot,
+                make<RelationalExpression>(Kind::kRelLT,
+                    make<ArithmeticExpression>(Kind::kAdd,
+                        make<ConstantExpression>(1),
+                        make<ConstantExpression>(2)),
+                    make<ConstantExpression>(3))),
+            make<UnaryExpression>(Kind::kUnaryNot,
+                make<RelationalExpression>(Kind::kRelLT,
+                    make<ArithmeticExpression>(Kind::kAdd,
+                        make<ConstantExpression>(1),
+                        make<ConstantExpression>(2)),
+                    make<ConstantExpression>(3))));
+    add("NOT 1 + 2 < 3 AND NOT 1 + 2 < 3", ast);
 
     ast = make<ArithmeticExpression>(Kind::kMinus,
                                      make<ArithmeticExpression>(Kind::kMultiply,
@@ -405,13 +428,13 @@ TEST_F(ExpressionParsingTest, Precedence) {
     add("$var[0]['1'].m", ast);
 
     ast = make<LogicalExpression>(Kind::kLogicalXor,
-                                  make<ArithmeticExpression>(Kind::kMultiply,
-                                      make<UnaryExpression>(Kind::kUnaryNot,
+                                  make<UnaryExpression>(Kind::kUnaryNot,
+                                      make<ArithmeticExpression>(Kind::kMultiply,
                                           make<AttributeExpression>(
                                               make<LabelAttributeExpression>(
                                                   make<LabelExpression>("a"),
                                                   make<LabelExpression>("b")),
-                                              make<LabelExpression>("c"))),
+                                              make<LabelExpression>("c")),
                                       make<SubscriptExpression>(
                                           make<SubscriptExpression>(
                                               make<AttributeExpression>(
@@ -420,7 +443,7 @@ TEST_F(ExpressionParsingTest, Precedence) {
                                                       new std::string("p")),
                                                   make<LabelExpression>("q")),
                                               make<LabelExpression>("r")),
-                                          make<LabelExpression>("s"))),
+                                          make<LabelExpression>("s")))),
                                   make<RelationalExpression>(Kind::kRelIn,
                                       make<InputPropertyExpression>(
                                           new std::string("m")),
diff --git a/src/parser/test/ParserTest.cpp b/src/parser/test/ParserTest.cpp
index 7e82ab5cfe41159ab05338bd7fd277e5cb9a42a1..2ccff0f67650aff95abae8ced852c1de9bd3786f 100644
--- a/src/parser/test/ParserTest.cpp
+++ b/src/parser/test/ParserTest.cpp
@@ -738,7 +738,7 @@ TEST(Parser, UpdateVertex) {
         std::string query = "UPDATE VERTEX \"12345\" "
                             "SET person.name=\"Tom\", person.age=$^.person.age + 1, "
                             "person.married=true "
-                            "WHEN $^.job.salary > 10000 && $^.person.age > 30";
+                            "WHEN $^.job.salary > 10000 AND $^.person.age > 30";
         auto result = parser.parse(query);
         ASSERT_TRUE(result.ok()) << result.status();
     }
@@ -747,7 +747,7 @@ TEST(Parser, UpdateVertex) {
         std::string query = "UPDATE VERTEX \"12345\" "
                             "SET name=\"Tom\", age=age + 1, "
                             "married=true "
-                            "WHEN salary > 10000 && age > 30";
+                            "WHEN salary > 10000 AND age > 30";
         auto result = parser.parse(query);
         ASSERT_TRUE(result.ok()) << result.status();
     }
@@ -773,7 +773,7 @@ TEST(Parser, UpdateVertex) {
         GQLParser parser;
         std::string query = "UPDATE VERTEX \"12345\" "
                             "SET person.name=\"Tom\", person.age=30, person.married=true "
-                            "WHEN $^.job.salary > 10000 && $^.job.name == \"CTO\" || "
+                            "WHEN $^.job.salary > 10000 AND $^.job.name == \"CTO\" OR "
                             "$^.person.age < 30"
                             "YIELD $^.person.name AS Name, $^.job.salary AS Salary, "
                             "$^.person.create_time AS Time";
@@ -784,7 +784,7 @@ TEST(Parser, UpdateVertex) {
         GQLParser parser;
         std::string query = "UPDATE VERTEX ON person \"12345\" "
                             "SET name=\"Tom\", age=30, married=true "
-                            "WHEN salary > 10000 && name == \"CTO\" || age < 30"
+                            "WHEN salary > 10000 AND name == \"CTO\" OR age < 30"
                             "YIELD name AS Name, salary AS Salary, create_time AS Time";
         auto result = parser.parse(query);
         ASSERT_TRUE(result.ok()) << result.status();
@@ -899,7 +899,7 @@ TEST(Parser, UpdateEdge) {
         GQLParser parser;
         std::string query = "UPDATE EDGE \"12345\" -> \"54321\"@789 OF transfer "
                             "SET amount=3.14,time=1537408527 "
-                            "WHEN transfer.amount > 3.14 && $^.person.name == \"Tom\"";
+                            "WHEN transfer.amount > 3.14 AND $^.person.name == \"Tom\"";
         auto result = parser.parse(query);
         ASSERT_TRUE(result.ok()) << result.status();
     }
@@ -915,7 +915,7 @@ TEST(Parser, UpdateEdge) {
         GQLParser parser;
         std::string query = "UPDATE EDGE \"12345\" -> \"54321\" OF transfer "
                             "SET amount = 3.14 + $^.job.salary, time = 1537408527 "
-                            "WHEN transfer.amount > 3.14 || $^.job.salary >= 10000 "
+                            "WHEN transfer.amount > 3.14 OR $^.job.salary >= 10000 "
                             "YIELD transfer.amount, transfer.time AS Time, "
                             "$^.person.name AS PayFrom";
         auto result = parser.parse(query);
@@ -934,7 +934,7 @@ TEST(Parser, UpdateEdge) {
         GQLParser parser;
         std::string query = "UPSERT EDGE \"12345\" -> \"54321\" @789 OF transfer "
                             "SET amount=$^.job.salary + 3.14, time=1537408527 "
-                            "WHEN transfer.amount > 3.14 && $^.job.salary >= 10000 "
+                            "WHEN transfer.amount > 3.14 AND $^.job.salary >= 10000 "
                             "YIELD transfer.amount,transfer.time, $^.person.name AS Name";
         auto result = parser.parse(query);
         ASSERT_TRUE(result.ok()) << result.status();
@@ -943,7 +943,7 @@ TEST(Parser, UpdateEdge) {
         GQLParser parser;
         std::string query = "UPSERT EDGE ON transfer \"12345\" -> \"54321\" @789 "
                             "SET amount=$^.job.salary + 3.14, time=1537408527 "
-                            "WHEN amount > 3.14 && salary >= 10000 "
+                            "WHEN amount > 3.14 AND salary >= 10000 "
                             "YIELD amount, time, name AS Name";
         auto result = parser.parse(query);
         ASSERT_TRUE(result.ok()) << result.status();
diff --git a/src/parser/test/ScannerTest.cpp b/src/parser/test/ScannerTest.cpp
index 286b1bbba3cf2d427fd4d964e1a0017df98c8132..b7126718e8b8e8aaaa4d58f559add50d5307bab5 100644
--- a/src/parser/test/ScannerTest.cpp
+++ b/src/parser/test/ScannerTest.cpp
@@ -151,9 +151,8 @@ TEST(Scanner, Basic) {
         CHECK_SEMANTIC_TYPE(">=", TokenType::GE),
         CHECK_SEMANTIC_TYPE("==", TokenType::EQ),
         CHECK_SEMANTIC_TYPE("!=", TokenType::NE),
+        CHECK_SEMANTIC_TYPE("<>", TokenType::NE),
 
-        CHECK_SEMANTIC_TYPE("||", TokenType::OR),
-        CHECK_SEMANTIC_TYPE("&&", TokenType::AND),
         CHECK_SEMANTIC_TYPE("|", TokenType::PIPE),
         CHECK_SEMANTIC_TYPE("=", TokenType::ASSIGN),
         CHECK_SEMANTIC_TYPE("(", TokenType::L_PAREN),
diff --git a/src/validator/test/YieldValidatorTest.cpp b/src/validator/test/YieldValidatorTest.cpp
index ce9854df210f85432cd644d8869841e758809088..88087a25d08320870b0050141ab3d6566d8b2f92 100644
--- a/src/validator/test/YieldValidatorTest.cpp
+++ b/src/validator/test/YieldValidatorTest.cpp
@@ -66,20 +66,20 @@ TEST_F(YieldValidatorTest, HashCall) {
 
 TEST_F(YieldValidatorTest, Logic) {
     {
-        std::string query = "YIELD NOT TRUE || !FALSE";
+        std::string query = "YIELD NOT TRUE OR !FALSE";
         EXPECT_TRUE(checkResult(query, expected_));
     }
 #if 0
     {
-        std::string query = "YIELD NOT 0 || 0 AND 0 XOR 0";
+        std::string query = "YIELD NOT 0 OR 0 AND 0 XOR 0";
         EXPECT_TRUE(checkResult(query, expected_));
     }
     {
-        std::string query = "YIELD !0 OR 0 && 0 XOR 1";
+        std::string query = "YIELD !0 OR 0 AND 0 XOR 1";
         EXPECT_TRUE(checkResult(query, expected_));
     }
     {
-        std::string query = "YIELD (NOT 0 || 0) AND 0 XOR 1";
+        std::string query = "YIELD (NOT 0 OR 0) AND 0 XOR 1";
         EXPECT_TRUE(checkResult(query, expected_));
     }
     {
diff --git a/src/visitor/test/FoldConstantExprVisitorTest.cpp b/src/visitor/test/FoldConstantExprVisitorTest.cpp
index b636e44de0a9f75ac51c79251edf871d56ff32bb..e59badf642024fc5989b8dc70aff26a449ad6d81 100644
--- a/src/visitor/test/FoldConstantExprVisitorTest.cpp
+++ b/src/visitor/test/FoldConstantExprVisitorTest.cpp
@@ -137,7 +137,7 @@ TEST_F(FoldConstantExprVisitorTest, TestRelationExpr) {
 }
 
 TEST_F(FoldConstantExprVisitorTest, TestLogicalExpr) {
-    // false && (false || (3 > (1 + 1))) => false && true
+    // false AND (false || (3 > (1 + 1))) => false AND true
     auto expr = pool.add(
         andExpr(constantExpr(false),
                 orExpr(constantExpr(false),
@@ -148,7 +148,7 @@ TEST_F(FoldConstantExprVisitorTest, TestLogicalExpr) {
     ASSERT_EQ(*expr, *expected) << expr->toString() << " vs. " << expected->toString();
     ASSERT(visitor.canBeFolded());
 
-    // false && true => false
+    // false AND true => false
     auto root = pool.add(visitor.fold(expr));
     auto rootExpected = pool.add(constantExpr(false));
     ASSERT_EQ(*root, *rootExpected) << root->toString() << " vs. " << rootExpected->toString();
diff --git a/tests/maintain/test_tag_edge.py b/tests/maintain/test_tag_edge.py
index c263676edc768c91fb0916563f97b4b8b9dfbb3e..a44f95d208835d80c5c5d2b18052967f8ae227cd 100644
--- a/tests/maintain/test_tag_edge.py
+++ b/tests/maintain/test_tag_edge.py
@@ -193,7 +193,7 @@ class TestSchema(NebulaTestSuite):
                                    '(id int64 DEFAULT 3/2*4-5, '
                                    'male bool DEFAULT 3 > 2, '
                                    'height double DEFAULT abs(-176.0), '
-                                   'adult bool DEFAULT true && false)')
+                                   'adult bool DEFAULT true AND false)')
         self.check_resp_succeeded(resp)
 
     def test_drop_tag(self):
@@ -358,7 +358,7 @@ class TestSchema(NebulaTestSuite):
                                    '(id int DEFAULT 3/2*4-5, '
                                    'male bool DEFAULT 3 > 2, '
                                    'height double DEFAULT abs(-176.0), '
-                                   'adult bool DEFAULT true && false)')
+                                   'adult bool DEFAULT true AND false)')
         self.check_resp_succeeded(resp)
 
     def test_drop_edge(self):
diff --git a/tests/mutate/test_update_upsert.py b/tests/mutate/test_update_upsert.py
index 58af277b0a41925f8c68a492d36866a1a0c85a50..1036118d372315ad1f433f6bf9caae22a2810f6d 100644
--- a/tests/mutate/test_update_upsert.py
+++ b/tests/mutate/test_update_upsert.py
@@ -98,19 +98,19 @@ class TestUpdateVertex(NebulaTestSuite):
         # filter out
         resp = self.execute('UPDATE VERTEX "101" '
                             'SET course.credits = $^.course.credits + 1 '
-                            'WHEN $^.course.name == "English" && $^.course.credits > 2')
+                            'WHEN $^.course.name == "English" AND $^.course.credits > 2')
         self.check_resp_succeeded(resp)
 
         # set filter
         resp = self.execute('UPDATE VERTEX "101" '
                             'SET course.credits = $^.course.credits + 1 '
-                            'WHEN $^.course.name == "Math" && $^.course.credits > 2')
+                            'WHEN $^.course.name == "Math" AND $^.course.credits > 2')
         self.check_resp_succeeded(resp)
 
         # update with uuid
         # resp = self.execute('UPDATE VERTEX ON course uuid("Math") '
         #                     'SET credits = $^.course.credits + 1 '
-        #                     'WHEN $^.course.name == "Math" && $^.course.credits > 2')
+        #                     'WHEN $^.course.name == "Math" AND $^.course.credits > 2')
         # self.check_resp_succeeded(resp)
 
         # set yield
@@ -132,7 +132,7 @@ class TestUpdateVertex(NebulaTestSuite):
         # set filter and yield
         resp = self.execute_query('UPDATE VERTEX "101" '
                                   'SET course.credits = $^.course.credits + 1 '
-                                  'WHEN $^.course.name == "Math" && $^.course.credits > 2 '
+                                  'WHEN $^.course.name == "Math" AND $^.course.credits > 2 '
                                   'YIELD $^.course.name AS Name, $^.course.credits AS Credits')
         self.check_resp_succeeded(resp)
         expected_result = [["Math", 7]]
@@ -141,7 +141,7 @@ class TestUpdateVertex(NebulaTestSuite):
         # set filter and yield with uuid
         # resp = self.execute_query('UPDATE VERTEX ON course uuid("Math") '
         #                           'SET credits = $^.course.credits + 1 '
-        #                           'WHEN $^.course.name == "Math" && $^.course.credits > 2 '
+        #                           'WHEN $^.course.name == "Math" AND $^.course.credits > 2 '
         #                           'YIELD $^.course.name AS Name, $^.course.credits AS Credits')
         # self.check_resp_succeeded(resp)
         # expected_result = [["Math", 7]]
@@ -150,7 +150,7 @@ class TestUpdateVertex(NebulaTestSuite):
         # set filter out and yield
         resp = self.execute_query('UPDATE VERTEX "101" '
                                   'SET course.credits = $^.course.credits + 1 '
-                                  'WHEN $^.course.name == "notexist" && $^.course.credits > 2'
+                                  'WHEN $^.course.name == "notexist" AND $^.course.credits > 2'
                                   'YIELD $^.course.name AS Name, $^.course.credits AS Credits')
         self.check_resp_succeeded(resp)
         expected_result = [["Math", 7]]
@@ -159,7 +159,7 @@ class TestUpdateVertex(NebulaTestSuite):
         # set filter out and yield with uuid
         # resp = self.execute_query('UPDATE VERTEX ON course uuid("Math") '
         #                           'SET credits = $^.course.credits + 1 '
-        #                           'WHEN $^.course.name == "notexist" && $^.course.credits > 2'
+        #                           'WHEN $^.course.name == "notexist" AND $^.course.credits > 2'
         #                           'YIELD $^.course.name AS Name, $^.course.credits AS Credits')
         # self.check_resp_succeeded(resp)
         # expected_result = [["Math", 7]]
@@ -198,7 +198,7 @@ class TestUpdateVertex(NebulaTestSuite):
         # filter out, 2.0 storage not support update edge can use vertex
         resp = self.execute('UPDATE EDGE "200" -> "101"@0 OF select '
                             'SET grade = select.grade + 1, year = 2000 '
-                            'WHEN select.grade > 1024 && $^.student.age > 15;')
+                            'WHEN select.grade > 1024 AND $^.student.age > 15;')
         self.check_resp_failed(resp)
 
         # 2.0 test, filter out
@@ -210,7 +210,7 @@ class TestUpdateVertex(NebulaTestSuite):
         # set filter, 2.0 storage not support update edge can use vertex
         resp = self.execute('UPDATE EDGE "200" -> "101"@0 OF select '
                             'SET grade = select.grade + 1, year = 2000 '
-                            'WHEN select.grade > 4 && $^.student.age > 15;')
+                            'WHEN select.grade > 4 AND $^.student.age > 15;')
         self.check_resp_failed(resp)
 
         # set filter
@@ -223,7 +223,7 @@ class TestUpdateVertex(NebulaTestSuite):
         # set filter
         # resp = self.execute('UPDATE EDGE ON select uuid("Monica") -> uuid("Math")@0 '
         #                     'SET grade = select.grade + 1, year = 2000'
-        #                     'WHEN select.grade > 4 && $^.student.age > 15;')
+        #                     'WHEN select.grade > 4 AND $^.student.age > 15;')
         self.check_resp_succeeded(resp)
 
         # set yield, 2.0 storage not support update edge can use vertex
@@ -252,7 +252,7 @@ class TestUpdateVertex(NebulaTestSuite):
         # set filter and yield, 2.0 storage not support update edge can use vertex
         resp = self.execute_query('UPDATE EDGE "200" -> "101"@0 OF select '
                             'SET grade = select.grade + 1, year = 2019 '
-                            'WHEN select.grade > 4 && $^.student.age > 15 '
+                            'WHEN select.grade > 4 AND $^.student.age > 15 '
                             'YIELD $^.student.name AS Name, select.grade AS Grade, select.year AS Year')
         self.check_resp_failed(resp)
 
@@ -267,7 +267,7 @@ class TestUpdateVertex(NebulaTestSuite):
         # set filter and yield with uuid
         # resp = self.execute('UPDATE EDGE ON select uuid("Monica") -> uuid("Math"@0 '
         #                     'SET grade = select.grade + 1, year = 2018 '
-        #                     'WHEN select.grade > 4 && $^.student.age > 15 '
+        #                     'WHEN select.grade > 4 AND $^.student.age > 15 '
         #                     'YIELD $^.student.name AS Name, select.grade AS Grade, select.year AS Year')
         # self.check_resp_succeeded(resp)
         # expected_result = [["Monica", 9, 2019]]
@@ -277,7 +277,7 @@ class TestUpdateVertex(NebulaTestSuite):
         # set filter out and yield, 2.0 storage not support update edge can use vertex
         resp = self.execute_query('UPDATE EDGE "200" -> "101"@0 OF select '
                             'SET grade = select.grade + 1, year = 2019 '
-                            'WHEN select.grade > 233333333333 && $^.student.age > 15 '
+                            'WHEN select.grade > 233333333333 AND $^.student.age > 15 '
                             'YIELD $^.student.name AS Name, select.grade AS Grade, select.year AS Year')
         self.check_resp_failed(resp)
 
@@ -293,7 +293,7 @@ class TestUpdateVertex(NebulaTestSuite):
         # set filter out and yield
         # resp = self.execute('UPDATE EDGE ON select uuid("Monica") -> uuid("Math"@0 '
         #                     'SET grade = select.grade + 1, year = 2018 '
-        #                     'WHEN select.grade > 233333333333 && $^.student.age > 15 '
+        #                     'WHEN select.grade > 233333333333 AND $^.student.age > 15 '
         #                     'YIELD $^.student.name AS Name, select.grade AS Grade, select.year AS Year')
         # self.check_resp_succeeded(resp)
         # expected_result = [["Monica", 9, 2019]]
@@ -308,7 +308,7 @@ class TestUpdateVertex(NebulaTestSuite):
         # the $$.TagName.PropName expressions are not allowed in any update sentence
         resp = self.execute_query('UPDATE VERTEX "101" '
                                   'SET course.credits = $$.course.credits + 1 '
-                                  'WHEN $$.course.name == "Math" && $^.course.credits > $$.course.credits + 1 '
+                                  'WHEN $$.course.name == "Math" AND $^.course.credits > $$.course.credits + 1 '
                                   'YIELD $^.course.name AS Name, $^.course.credits AS Credits, $$.building.name')
         self.check_resp_failed(resp)
 
@@ -326,7 +326,7 @@ class TestUpdateVertex(NebulaTestSuite):
         # make sure EdgeName and PropertyName must exist in all clauses
         resp = self.execute_query('UPDATE EDGE "200" -> "101"@0 OF select '
                                   'SET nonexistentProperty = select.grade + 1, year = 2019 '
-                                  'WHEN nonexistentEdgeName.grade > 4 && $^.student.nonexistentProperty > 15 '
+                                  'WHEN nonexistentEdgeName.grade > 4 AND $^.student.nonexistentProperty > 15 '
                                   'YIELD $^.nonexistentTag.name AS Name, select.nonexistentProperty AS Grade')
         self.check_resp_failed(resp)
 
@@ -351,7 +351,7 @@ class TestUpdateVertex(NebulaTestSuite):
         # update: vertex 103 ("CS", 5) --> ("CS", 6), TODO: storage not ready
         # resp = self.execute_query('UPDATE VERTEX "103" '
         #                           'SET course.credits = $^.course.credits + 1 '
-        #                           'WHEN $^.course.name == "CS" && $^.course.credits > 2 '
+        #                           'WHEN $^.course.name == "CS" AND $^.course.credits > 2 '
         #                           "YIELD $^.course.name AS Name, $^.course.credits AS Credits")
         # self.check_resp_succeeded(resp)
         # expected_result = [["CS", 6]]
@@ -360,7 +360,7 @@ class TestUpdateVertex(NebulaTestSuite):
         # when tag on vertex not exists, update failed
         resp = self.execute_query('UPDATE VERTEX "104" '
                                   'SET course.credits = $^.course.credits + 1  '
-                                  'WHEN $^.course.name == "CS" && $^.course.credits > 2 '
+                                  'WHEN $^.course.name == "CS" AND $^.course.credits > 2 '
                                   "YIELD $^.course.name AS Name, $^.course.credits AS Credits")
         self.check_resp_failed(resp)
 
@@ -407,7 +407,7 @@ class TestUpdateVertex(NebulaTestSuite):
         # when tag on vertex not exists, update failed
         resp = self.execute_query('UPDATE VERTEX "104" '
                                   'SET course.credits = $^.course.credits + 1 '
-                                  'WHEN $^.course.name == \"CS\" && $^.course.credits > 2 '
+                                  'WHEN $^.course.name == \"CS\" AND $^.course.credits > 2 '
                                   'YIELD $^.course.name AS Name, $^.course.credits AS Credits')
         self.check_resp_failed(resp)
 
@@ -460,7 +460,7 @@ class TestUpdateVertex(NebulaTestSuite):
         # Insertable, upsert when edge exists, 2.0 storage not support update edge with vertex prop
         resp = self.execute_query('UPSERT EDGE ON select "201" -> "101"@0'
                                   'SET grade = 3, year = 2019 '
-                                  'WHEN $^.student.age > 15 && $^.student.gender == "male" '
+                                  'WHEN $^.student.age > 15 AND $^.student.gender == "male" '
                                   'YIELD select.grade AS Grade, select.year AS Year')
         self.check_resp_failed(resp)
 
@@ -538,21 +538,21 @@ class TestUpdateVertex(NebulaTestSuite):
         # make sure the vertex must not exist
         resp = self.execute_query('UPDATE VERTEX "1010000" '
                                   'SET course.credits = $^.course.credits + 1, name = "No9" '
-                                  'WHEN $^.course.name == "Math" && $^.course.credits > 2 '
+                                  'WHEN $^.course.name == "Math" AND $^.course.credits > 2 '
                                   'YIELD select_default.grade AS Grade, select_default.year AS Year')
         self.check_resp_failed(resp)
 
         # make sure the edge(src, dst) must not exist
         resp = self.execute_query('UPDATE EDGE ON select "200" -> "101000000000000"@0  '
                                   'SET grade = select.grade + 1, year = 2019 '
-                                  'WHEN select.grade > 4 && $^.student.age > 15 '
+                                  'WHEN select.grade > 4 AND $^.student.age > 15 '
                                   'YIELD $^.student.name AS Name, select.grade AS Grade, select.year AS Year')
         self.check_resp_failed(resp)
 
         # make sure the edge(src, ranking, dst) must not exist
         resp = self.execute_query('UPDATE EDGE ON select "200" -> "101"@123456789  '
                                   'SET grade = select.grade + 1, year = 2019 '
-                                  'WHEN select.grade > 4 && $^.student.age > 15 '
+                                  'WHEN select.grade > 4 AND $^.student.age > 15 '
                                   'YIELD $^.student.name AS Name, select.grade AS Grade, select.year AS Year')
         self.check_resp_failed(resp)
         self.check_resp_failed(resp)
diff --git a/tests/mutate/test_update_upsert_2.py b/tests/mutate/test_update_upsert_2.py
index 0ea359950f14625f25a529379be4442eb6b7c917..cc957b72c5f73b98a8d9a04901c7d63ade686799 100644
--- a/tests/mutate/test_update_upsert_2.py
+++ b/tests/mutate/test_update_upsert_2.py
@@ -66,13 +66,13 @@ class TestUpdateVertex(NebulaTestSuite):
         # filter out
         resp = self.execute('UPDATE VERTEX ON course "101" '
                             'SET credits = credits + 1 '
-                            'WHEN name == "English" && credits > 2')
+                            'WHEN name == "English" AND credits > 2')
         self.check_resp_succeeded(resp)
 
         # set filter
         resp = self.execute('UPDATE VERTEX ON course "101" '
                             'SET credits = credits + 1 '
-                            'WHEN name == "Math" && credits > 2')
+                            'WHEN name == "Math" AND credits > 2')
         self.check_resp_succeeded(resp)
 
         # set yield
@@ -86,7 +86,7 @@ class TestUpdateVertex(NebulaTestSuite):
         # set filter and yield
         resp = self.execute_query('UPDATE VERTEX ON course "101" '
                                   'SET credits = credits + 1 '
-                                  'WHEN name == "Math" && credits > 2 '
+                                  'WHEN name == "Math" AND credits > 2 '
                                   'YIELD name AS Name, credits AS Credits')
         self.check_resp_succeeded(resp)
         expected_result = [["Math", 7]]
@@ -95,7 +95,7 @@ class TestUpdateVertex(NebulaTestSuite):
         # set filter out and yield
         resp = self.execute_query('UPDATE VERTEX ON course "101" '
                                   'SET credits = credits + 1 '
-                                  'WHEN name == "notexist" && credits > 2'
+                                  'WHEN name == "notexist" AND credits > 2'
                                   'YIELD name AS Name, credits AS Credits')
         self.check_resp_succeeded(resp)
         expected_result = [["Math", 7]]
@@ -130,7 +130,7 @@ class TestUpdateVertex(NebulaTestSuite):
         # filter out, 2.0 storage not support update edge can use vertex
         resp = self.execute('UPDATE EDGE ON select "200" -> "101"@0 '
                             'SET grade = select.grade + 1, year = 2000 '
-                            'WHEN select.grade > 1024 && $^.student.age > 15;')
+                            'WHEN select.grade > 1024 AND $^.student.age > 15;')
         self.check_resp_failed(resp)
 
         # 2.0 test, filter out
@@ -142,7 +142,7 @@ class TestUpdateVertex(NebulaTestSuite):
         # set filter, 2.0 storage not support update edge can use vertex
         resp = self.execute('UPDATE EDGE ON select "200" -> "101"@0 '
                             'SET grade = select.grade + 1, year = 2000 '
-                            'WHEN select.grade > 4 && $^.student.age > 15;')
+                            'WHEN select.grade > 4 AND $^.student.age > 15;')
         self.check_resp_failed(resp)
 
         # set filter
@@ -169,7 +169,7 @@ class TestUpdateVertex(NebulaTestSuite):
         # set filter and yield, 2.0 storage not support update edge can use vertex
         resp = self.execute_query('UPDATE EDGE ON select "200" -> "101"@0 '
                             'SET grade = select.grade + 1, year = 2019 '
-                            'WHEN select.grade > 4 && $^.student.age > 15 '
+                            'WHEN select.grade > 4 AND $^.student.age > 15 '
                             'YIELD $^.student.name AS Name, select.grade AS Grade, select.year AS Year')
         self.check_resp_failed(resp)
 
@@ -184,7 +184,7 @@ class TestUpdateVertex(NebulaTestSuite):
         # set filter out and yield, 2.0 storage not support update edge can use vertex
         resp = self.execute_query('UPDATE EDGE ON select "200" -> "101"@0 '
                             'SET grade = select.grade + 1, year = 2019 '
-                            'WHEN select.grade > 233333333333 && $^.student.age > 15 '
+                            'WHEN select.grade > 233333333333 AND $^.student.age > 15 '
                             'YIELD $^.student.name AS Name, select.grade AS Grade, select.year AS Year')
         self.check_resp_failed(resp)
 
@@ -206,14 +206,14 @@ class TestUpdateVertex(NebulaTestSuite):
         # the $$.TagName.PropName expressions are not allowed in any update sentence
         resp = self.execute_query('UPDATE VERTEX ON course "101" '
                                   'SET credits = $$.course.credits + 1 '
-                                  'WHEN $$.course.name == "Math" && credits > $$.course.credits + 1 '
+                                  'WHEN $$.course.name == "Math" AND credits > $$.course.credits + 1 '
                                   'YIELD name AS Name, credits AS Credits, $$.building.name')
         self.check_resp_failed(resp)
 
         # make sure TagName and PropertyName must exist in all clauses
         resp = self.execute_query('UPDATE VERTEX ON nonexistentTag "101" '
                                   'SET credits = credits + 1, name = "No9" '
-                                  'WHEN name == "Math" && nonexistentProperty > 2 '
+                                  'WHEN name == "Math" AND nonexistentProperty > 2 '
                                   'YIELD name AS Name, $^.nonexistentTag.nonexistentProperty')
         self.check_resp_failed(resp)
 
@@ -226,7 +226,7 @@ class TestUpdateVertex(NebulaTestSuite):
         # make sure EdgeName and PropertyName must exist in all clauses
         resp = self.execute_query('UPDATE EDGE ON select "200" -> "101"@0 '
                                   'SET nonexistentProperty = select.grade + 1, year = 2019 '
-                                  'WHEN nonexistentEdgeName.grade > 4 && $^.student.nonexistentProperty > 15 '
+                                  'WHEN nonexistentEdgeName.grade > 4 AND $^.student.nonexistentProperty > 15 '
                                   'YIELD $^.nonexistentTag.name AS Name, select.nonexistentProperty AS Grade')
         self.check_resp_failed(resp)
 
@@ -251,7 +251,7 @@ class TestUpdateVertex(NebulaTestSuite):
         # update: vertex 103 ("CS", 5) --> ("CS", 6)
         resp = self.execute_query('UPDATE VERTEX ON course "103" '
                                   'SET credits = credits + 1 '
-                                  'WHEN name == "CS" && credits > 2 '
+                                  'WHEN name == "CS" AND credits > 2 '
                                   "YIELD name AS Name, credits AS Credits")
         self.check_resp_succeeded(resp)
         expected_result = [["CS", 6]]
@@ -260,7 +260,7 @@ class TestUpdateVertex(NebulaTestSuite):
         # when tag on vertex not exists, update failed
         resp = self.execute_query('UPDATE VERTEX ON course "104" '
                                   'SET credits = credits + 1  '
-                                  'WHEN name == "CS" && credits > 2 '
+                                  'WHEN name == "CS" AND credits > 2 '
                                   "YIELD name AS Name, credits AS Credits")
         self.check_resp_failed(resp)
 
@@ -307,7 +307,7 @@ class TestUpdateVertex(NebulaTestSuite):
         # when tag on vertex not exists, update failed
         resp = self.execute_query('UPDATE VERTEX ON course "104" '
                                   'SET credits = credits + 1 '
-                                  'WHEN name == \"CS\" && credits > 2 '
+                                  'WHEN name == \"CS\" AND credits > 2 '
                                   'YIELD name AS Name, credits AS Credits')
         self.check_resp_failed(resp)
 
@@ -356,7 +356,7 @@ class TestUpdateVertex(NebulaTestSuite):
         # Insertable, upsert when edge exists, 2.0 storage not support
         resp = self.execute_query('UPSERT EDGE ON select "201" -> "101"@0'
                                   'SET grade = 3, year = 2019 '
-                                  'WHEN $^.student.age > 15 && $^.student.gender == "male" '
+                                  'WHEN $^.student.age > 15 AND $^.student.gender == "male" '
                                   'YIELD select.grade AS Grade, select.year AS Year')
         self.check_resp_failed(resp)
 
@@ -435,7 +435,7 @@ class TestUpdateVertex(NebulaTestSuite):
         # make sure the vertex must not exist
         resp = self.execute_query('UPDATE VERTEX ON course "1010000" '
                                   'SET credits = credits + 1, name = "No9" '
-                                  'WHEN name == "Math" && credits > 2 '
+                                  'WHEN name == "Math" AND credits > 2 '
                                   'YIELD name as Name')
         self.check_resp_failed(resp)
 
diff --git a/tests/query/stateless/test_go.py b/tests/query/stateless/test_go.py
index e5be2057f2fc548bd69000dde641846515923abe..c3b80fb48494a2928884827779cfd1e57987f0b7 100644
--- a/tests/query/stateless/test_go.py
+++ b/tests/query/stateless/test_go.py
@@ -179,7 +179,7 @@ class TestGoQuery(NebulaTestSuite):
         self.check_out_of_order_result(resp, expect_result)
 
         # go 2 step over * YIELD with filter
-        cmd = 'GO 2 STEPS FROM "1016" over * WHERE $$.student.grade > 4 && $$.person.age > 10 \
+        cmd = 'GO 2 STEPS FROM "1016" over * WHERE $$.student.grade > 4 AND $$.person.age > 10 \
                 YIELD $$.person.name as name, $$.person.age as age, $$.student.grade as grade;'
         resp = self.execute_query(cmd)
         expect_result = [['Sonya', 11, 6], ['Sonya', 11, 6], ['XiaMei', 11, 6]]
diff --git a/tests/query/stateless/test_schema.py b/tests/query/stateless/test_schema.py
index cb555e9f84a32bb28c3f36959eacde4af6ef26e6..b0976cbdbe3305f242e97e59da394b8773e6649d 100644
--- a/tests/query/stateless/test_schema.py
+++ b/tests/query/stateless/test_schema.py
@@ -360,14 +360,14 @@ class TestSchema(NebulaTestSuite):
             '(id int DEFAULT 3/2*4-5, '  # arithmetic
             'male bool DEFAULT 3 > 2, '  # relation
             'height double DEFAULT abs(-176.0), '  # built-in function
-            'adult bool DEFAULT true && false)')  # logic
+            'adult bool DEFAULT true AND false)')  # logic
         self.check_resp_succeeded(resp)
         # Edge
         resp = self.execute('CREATE EDGE default_edge_expr'
             '(id int DEFAULT 3/2*4-5, '  # arithmetic
             'male bool DEFAULT 3 > 2, '  # relation
             'height double DEFAULT abs(-176.0), '  # built-in function
-            'adult bool DEFAULT true && false)')  # logic
+            'adult bool DEFAULT true AND false)')  # logic
         self.check_resp_succeeded(resp)
 
     @classmethod
diff --git a/tests/query/v1/test_go.py b/tests/query/v1/test_go.py
index a8a042f2d777fd8e45f5c2dc5121531e58be25bc..789f6bcb96f30db40feeda78e2c243dda0a77c83 100644
--- a/tests/query/v1/test_go.py
+++ b/tests/query/v1/test_go.py
@@ -74,7 +74,7 @@ class TestGoQuery(NebulaTestSuite):
         self.check_out_of_order_result(resp, expected_data["rows"])
 
         stmt = '''GO FROM "Rajon Rondo" OVER serve WHERE \
-            serve.start_year >= 2013 && serve.end_year <= 2018 YIELD \
+            serve.start_year >= 2013 AND serve.end_year <= 2018 YIELD \
             $^.player.name, serve.start_year, serve.end_year, $$.team.name'''
         resp = self.execute_query(stmt)
         self.check_resp_succeeded(resp)
@@ -760,7 +760,7 @@ class TestGoQuery(NebulaTestSuite):
         self.check_out_of_order_result(resp, expected_data["rows"])
 
         stmt = '''GO FROM 'Tim Duncan' OVER like YIELD like._dst AS id \
-            | GO FROM  $-.id OVER serve WHERE udf_is_in($-.id, 'Tony Parker', 123) && 1 == 1'''
+            | GO FROM  $-.id OVER serve WHERE udf_is_in($-.id, 'Tony Parker', 123) AND 1 == 1'''
         resp = self.execute_query(stmt)
         self.check_resp_succeeded(resp)
         expected_data = {
diff --git a/tests/query/v1/test_yield.py b/tests/query/v1/test_yield.py
index 41b7491cc37321616b8d322f9e815534f9790a8c..660597ef0d6d6dc91a81cb83e166f92b4c2d487d 100644
--- a/tests/query/v1/test_yield.py
+++ b/tests/query/v1/test_yield.py
@@ -85,52 +85,52 @@ class TestYield(NebulaTestSuite):
         # self.check_result(resp, expect_result)
 
     def test_logic(self):
-        query = 'YIELD NOT FALSE || FALSE AND FALSE XOR FALSE'
+        query = 'YIELD NOT FALSE OR FALSE AND FALSE XOR FALSE'
         resp = self.execute_query(query)
         self.check_resp_succeeded(resp)
-        columns = ["((!(false)||(false&&false)) XOR false)"]
+        columns = ["((!(false) OR (false AND false)) XOR false)"]
         self.check_column_names(resp, columns)
         expect_result = [[True]]
         self.check_result(resp, expect_result)
 
-        query = 'YIELD !false OR false && false XOR true'
+        query = 'YIELD !false OR false AND false XOR true'
         resp = self.execute_query(query)
         self.check_resp_succeeded(resp)
-        columns = ["((!(false)||(false&&false)) XOR true)"]
+        columns = ["((!(false) OR (false AND false)) XOR true)"]
         self.check_column_names(resp, columns)
         expect_result = [[False]]
         self.check_result(resp, expect_result)
 
-        query = 'YIELD (NOT false || false) AND false XOR true'
+        query = 'YIELD (NOT false OR false) AND false XOR true'
         resp = self.execute_query(query)
         self.check_resp_succeeded(resp)
-        columns = ["(((!(false)||false)&&false) XOR true)"]
+        columns = ["(((!(false) OR false) AND false) XOR true)"]
         self.check_column_names(resp, columns)
         expect_result = [[True]]
         self.check_result(resp, expect_result)
 
     @pytest.mark.skip(reason="")
     def test_logic_2(self):
-        query = 'YIELD NOT 0 || 0 AND 0 XOR 0'
+        query = 'YIELD NOT 0 OR 0 AND 0 XOR 0'
         resp = self.execute_query(query)
         self.check_resp_succeeded(resp)
-        columns = ["((!(0)||(0&&0)) XOR 0)"]
+        columns = ["((!(0) OR (0 AND 0)) XOR 0)"]
         self.check_column_names(resp, columns)
         expect_result = [[True]]
         self.check_result(resp, expect_result)
 
-        query = 'YIELD !0 OR 0 && 0 XOR 1'
+        query = 'YIELD !0 OR 0 AND 0 XOR 1'
         resp = self.execute_query(query)
         self.check_resp_succeeded(resp)
-        columns = ["((!(0)||(0&&0)) XOR 1)"]
+        columns = ["((!(0) OR (0 AND 0)) XOR 1)"]
         self.check_column_names(resp, columns)
         expect_result = [[False]]
         self.check_result(resp, expect_result)
 
-        query = 'YIELD (NOT 0 || 0) AND 0 XOR 1'
+        query = 'YIELD (NOT 0 OR 0) AND 0 XOR 1'
         resp = self.execute_query(query)
         self.check_resp_succeeded(resp)
-        columns = ["(((!(0)||0)&&0) XOR 1)"]
+        columns = ["(((!(0) OR 0) AND 0) XOR 1)"]
         self.check_column_names(resp, columns)
         expect_result = [[True]]
         self.check_result(resp, expect_result)