Add update executor and test (#58)

* add update executor and test

* address yixinglu's comment

* update expression

* rebase upstream

* update

* rebase upstream

* modify common url

* rebase upstream

* add test

* update tests

* Compatible with 1.0 syntax

* update test

* address comment

* rebase upstream

* rebase upstream

* add test

* address comment

* address comment

src/exec/CMakeLists.txt

@@ -33,6 +33,7 @@ nebula_add_library(
     maintain/EdgeExecutor.cpp
     mutate/InsertExecutor.cpp
     mutate/DeleteExecutor.cpp
+    mutate/UpdateExecutor.cpp
 )
 
 nebula_add_subdirectory(query/test)

src/exec/Executor.cpp

@@ -24,6 +24,7 @@
 #include "exec/maintain/TagExecutor.h"
 #include "exec/mutate/InsertExecutor.h"
 #include "exec/mutate/DeleteExecutor.h"
+#include "exec/mutate/UpdateExecutor.h"
 #include "exec/query/AggregateExecutor.h"
 #include "exec/query/DataCollectExecutor.h"
 #include "exec/query/DataJoinExecutor.h"
@@ -384,6 +385,20 @@ Executor *Executor::makeExecutor(const PlanNode *node,
             exec->dependsOn(input);
             break;
         }
+        case PlanNode::Kind::kUpdateVertex: {
+            auto updateV = asNode<UpdateVertex>(node);
+            auto input = makeExecutor(updateV->dep(), qctx, visited);
+            exec = new UpdateVertexExecutor(updateV, qctx);
+            exec->dependsOn(input);
+            break;
+        }
+        case PlanNode::Kind::kUpdateEdge: {
+            auto updateE = asNode<UpdateEdge>(node);
+            auto input = makeExecutor(updateE->dep(), qctx, visited);
+            exec = new UpdateEdgeExecutor(updateE, qctx);
+            exec->dependsOn(input);
+            break;
+        }
         case PlanNode::Kind::kUnknown:
         default:
             LOG(FATAL) << "Unknown plan node kind " << static_cast<int32_t>(node->kind());

src/exec/mutate/UpdateExecutor.cpp

+/* Copyright (c) 2020 vesoft inc. All rights reserved.
+ *
+ * This source code is licensed under Apache 2.0 License,
+ * attached with Common Clause Condition 1.0, found in the LICENSES directory.
+ */
+
+#include "UpdateExecutor.h"
+#include "planner/Mutate.h"
+#include "util/SchemaUtil.h"
+#include "context/QueryContext.h"
+#include "util/ScopedTimer.h"
+
+
+namespace nebula {
+namespace graph {
+
+StatusOr<DataSet> UpdateBaseExecutor::handleResult(DataSet &&data) {
+    if (data.colNames.size() <= 1) {
+        if (yieldNames_.empty()) {
+            return Status::OK();
+        }
+        LOG(ERROR) << "Empty return props";
+        return Status::Error("Empty return props");
+    }
+
+    if (yieldNames_.size() != data.colNames.size() - 1) {
+        LOG(ERROR) << "Expect colName size is " << yieldNames_.size()
+                   << ", return colName size is " << data.colNames.size() - 1;
+        return Status::Error("Wrong return prop size");
+    }
+    DataSet result;
+    result.colNames = std::move(yieldNames_);
+    for (auto &row : data.rows) {
+        std::vector<Value> columns;
+        for (auto i = 1u; i < row.values.size(); i++) {
+            columns.emplace_back(std::move(row.values[i]));
+        }
+        result.rows.emplace_back(std::move(columns));
+    }
+    return result;
+}
+
+Status UpdateBaseExecutor::handleErrorCode(nebula::storage::cpp2::ErrorCode code,
+                                           PartitionID partId) {
+    switch (code) {
+        case storage::cpp2::ErrorCode::E_INVALID_FIELD_VALUE:
+            return Status::Error(
+                    "Invalid field value: may be the filed without default value or wrong schema");
+        case storage::cpp2::ErrorCode::E_INVALID_FILTER:
+            return Status::Error("Invalid filter.");
+        case storage::cpp2::ErrorCode::E_INVALID_UPDATER:
+            return Status::Error("Invalid Update col or yield col.");
+        case storage::cpp2::ErrorCode::E_TAG_NOT_FOUND:
+            return Status::Error("Tag `%s' not found.", schemaName_.c_str());
+        case storage::cpp2::ErrorCode::E_TAG_PROP_NOT_FOUND:
+            return Status::Error("Tag prop not found.");
+        case storage::cpp2::ErrorCode::E_EDGE_NOT_FOUND:
+            return Status::Error("Edge `%s' not found.", schemaName_.c_str());
+        case storage::cpp2::ErrorCode::E_EDGE_PROP_NOT_FOUND:
+            return Status::Error("Edge prop not found.");
+        case storage::cpp2::ErrorCode::E_INVALID_DATA:
+            return Status::Error("Invalid data, may be wrong value type.");
+        case storage::cpp2::ErrorCode::E_NOT_NULLABLE:
+            return Status::Error("The not null field cannot be null.");
+        case storage::cpp2::ErrorCode::E_FIELD_UNSET:
+            return Status::Error("The not null field doesn't have a default value.");
+        case storage::cpp2::ErrorCode::E_OUT_OF_RANGE:
+            return Status::Error("Out of range value.");
+        case storage::cpp2::ErrorCode::E_ATOMIC_OP_FAILED:
+            return Status::Error("Atomic operation failed.");
+        case storage::cpp2::ErrorCode::E_FILTER_OUT:
+            return Status::OK();
+        default:
+            auto status = Status::Error("Unknown error, part: %d, error code: %d.",
+                                         partId, static_cast<int32_t>(code));
+            LOG(ERROR) << status;
+            return status;
+    }
+    return Status::OK();
+}
+
+folly::Future<Status> UpdateVertexExecutor::execute() {
+    SCOPED_TIMER(&execTime_);
+    auto *uvNode = asNode<UpdateVertex>(node());
+    yieldNames_ = uvNode->getYieldNames();
+    schemaName_ = uvNode->getName();
+    time::Duration updateVertTime;
+    return qctx()->getStorageClient()->updateVertex(uvNode->getSpaceId(),
+                                                    uvNode->getVId(),
+                                                    uvNode->getTagId(),
+                                                    uvNode->getUpdatedProps(),
+                                                    uvNode->getInsertable(),
+                                                    uvNode->getReturnProps(),
+                                                    uvNode->getCondition())
+        .via(runner())
+        .ensure([updateVertTime]() {
+            VLOG(1) << "Update vertice time: " << updateVertTime.elapsedInUSec() << "us";
+        })
+        .then([this](StatusOr<storage::cpp2::UpdateResponse> resp) {
+            SCOPED_TIMER(&execTime_);
+            if (!resp.ok()) {
+                LOG(ERROR) << resp.status();
+                return resp.status();
+            }
+            auto value = std::move(resp).value();
+            for (auto& code : value.get_result().get_failed_parts()) {
+                NG_RETURN_IF_ERROR(handleErrorCode(code.get_code(), code.get_part_id()));
+            }
+            if (value.__isset.props) {
+                auto status = handleResult(std::move(*value.get_props()));
+                if (!status.ok()) {
+                    return status.status();
+                }
+                return finish(ResultBuilder()
+                                  .value(std::move(status).value())
+                                  .iter(Iterator::Kind::kDefault)
+                                  .finish());
+            }
+            return Status::OK();
+        });
+}
+
+folly::Future<Status> UpdateEdgeExecutor::execute() {
+    SCOPED_TIMER(&execTime_);
+    auto *ueNode = asNode<UpdateEdge>(node());
+    schemaName_ = ueNode->getName();
+    storage::cpp2::EdgeKey edgeKey;
+    edgeKey.set_src(ueNode->getSrcId());
+    edgeKey.set_ranking(ueNode->getRank());
+    edgeKey.set_edge_type(ueNode->getEdgeType());
+    edgeKey.set_dst(ueNode->getDstId());
+    yieldNames_ = ueNode->getYieldNames();
+
+    time::Duration updateEdgeTime;
+    return qctx()->getStorageClient()->updateEdge(ueNode->getSpaceId(),
+                                                  edgeKey,
+                                                  ueNode->getUpdatedProps(),
+                                                  ueNode->getInsertable(),
+                                                  ueNode->getReturnProps(),
+                                                  ueNode->getCondition())
+            .via(runner())
+            .ensure([updateEdgeTime]() {
+                VLOG(1) << "Update edge time: " << updateEdgeTime.elapsedInUSec() << "us";
+            })
+            .then([this](StatusOr<storage::cpp2::UpdateResponse> resp) {
+                SCOPED_TIMER(&execTime_);
+                if (!resp.ok()) {
+                    LOG(ERROR) << "Update edge failed: " << resp.status();
+                    return resp.status();
+                }
+                auto value = std::move(resp).value();
+                for (auto& code : value.get_result().get_failed_parts()) {
+                    NG_RETURN_IF_ERROR(handleErrorCode(code.get_code(), code.get_part_id()));
+                }
+                if (value.__isset.props) {
+                    auto status = handleResult(std::move(*value.get_props()));
+                    if (!status.ok()) {
+                        return status.status();
+                    }
+                    return finish(ResultBuilder()
+                                    .value(std::move(status).value())
+                                    .iter(Iterator::Kind::kDefault)
+                                    .finish());
+                }
+                return Status::OK();
+            });
+}
+}   // namespace graph
+}   // namespace nebula

src/exec/mutate/UpdateExecutor.h

+/* Copyright (c) 2020 vesoft inc. All rights reserved.
+ *
+ * This source code is licensed under Apache 2.0 License,
+ * attached with Common Clause Condition 1.0, found in the LICENSES directory.
+ */
+
+#ifndef EXEC_MUTATE_UPDATEEXECUTOR_H_
+#define EXEC_MUTATE_UPDATEEXECUTOR_H_
+
+#include "common/base/StatusOr.h"
+#include "exec/Executor.h"
+
+namespace nebula {
+namespace graph {
+
+class UpdateBaseExecutor : public Executor {
+public:
+    UpdateBaseExecutor(const std::string &execName,
+                       const PlanNode *node,
+                       QueryContext *ectx)
+        : Executor(execName, node, ectx) {}
+
+    virtual ~UpdateBaseExecutor() {}
+
+protected:
+    StatusOr<DataSet> handleResult(DataSet &&data);
+
+    Status handleErrorCode(nebula::storage::cpp2::ErrorCode code, PartitionID partId);
+
+protected:
+    std::vector<std::string>         yieldNames_;
+    std::string                      schemaName_;
+};
+
+class UpdateVertexExecutor final : public UpdateBaseExecutor {
+public:
+    UpdateVertexExecutor(const PlanNode *node, QueryContext *ectx)
+        : UpdateBaseExecutor("UpdateVertexExecutor", node, ectx) {}
+
+    folly::Future<Status> execute() override;
+};
+
+class UpdateEdgeExecutor final : public UpdateBaseExecutor {
+public:
+    UpdateEdgeExecutor(const PlanNode *node, QueryContext *ectx)
+        : UpdateBaseExecutor("UpdateEdgeExecutor", node, ectx) {}
+
+    folly::Future<Status> execute() override;
+};
+
+}   // namespace graph
+}   // namespace nebula
+
+#endif   // EXEC_MUTATE_UPDATEEXECUTOR_H_

src/mock/CMakeLists.txt

@@ -6,13 +6,13 @@
 
 nebula_add_library(
     mock_obj OBJECT
-        MetaCache.cpp
-        StorageCache.cpp
-        MockMetaServiceHandler.cpp
-        MockStorageServiceHandler.cpp
-        test/TestMain.cpp
-        test/TestEnv.cpp
-        test/TestBase.cpp
+    MetaCache.cpp
+    StorageCache.cpp
+    MockMetaServiceHandler.cpp
+    MockStorageServiceHandler.cpp
+    test/TestMain.cpp
+    test/TestEnv.cpp
+    test/TestBase.cpp
 )
 
-nebula_add_subdirectory(test)
\ No newline at end of file
+nebula_add_subdirectory(test)

src/parser/AdminSentences.h

@@ -130,23 +130,23 @@ public:
         optValue_ = val;
     }
 
-    int64_t asInt() {
+    int64_t asInt() const {
         return boost::get<int64_t>(optValue_);
     }
 
-    const std::string& asString() {
+    const std::string& asString() const {
         return boost::get<std::string>(optValue_);
     }
 
-    bool isInt() {
+    bool isInt() const {
         return optValue_.which() == 0;
     }
 
-    bool isString() {
+    bool isString() const {
         return optValue_.which() == 1;
     }
 
-    int64_t getPartitionNum() {
+    int64_t getPartitionNum() const {
         if (isInt()) {
             return asInt();
         } else {
@@ -155,7 +155,7 @@ public:
         }
     }
 
-    int64_t getReplicaFactor() {
+    int64_t getReplicaFactor() const {
         if (isInt()) {
             return asInt();
         } else {
@@ -164,7 +164,7 @@ public:
         }
     }
 
-    int32_t getVidSize() {
+    int32_t getVidSize() const {
         if (isInt()) {
             return asInt();
         } else {
@@ -173,7 +173,7 @@ public:
         }
     }
 
-    std::string getCharset() {
+    std::string getCharset() const {
         if (isString()) {
             return asString();
         } else {
@@ -182,7 +182,7 @@ public:
         }
     }
 
-    std::string getCollate() {
+    std::string getCollate() const {
         if (isString()) {
             return asString();
         } else {
@@ -191,7 +191,7 @@ public:
         }
     }
 
-    OptionType getOptType() {
+    OptionType getOptType() const {
         return optType_;
     }
 

src/parser/MutateSentences.cpp

@@ -156,7 +156,12 @@ std::string InsertEdgesSentence::toString() const {
 std::string UpdateItem::toString() const {
     std::string buf;
     buf.reserve(256);
-    buf += *field_;
+    if (fieldStr_ != nullptr)  {
+        buf += *fieldStr_;
+    } else if (fieldExpr_ != nullptr) {
+        buf += fieldExpr_->toString();
+    }
+
     buf += "=";
     buf += value_->toString();
     return buf;
@@ -196,7 +201,6 @@ StatusOr<std::string> UpdateList::toEvaledString() const {
     return buf;
 }
 
-
 std::string UpdateVertexSentence::toString() const {
     std::string buf;
     buf.reserve(256);
@@ -206,6 +210,7 @@ std::string UpdateVertexSentence::toString() const {
         buf += "UPDATE ";
     }
     buf += "VERTEX ";
+    buf += "ON " + *name_ + " ";
     buf += vid_->toString();
     buf += " SET ";
     buf += updateList_->toString();
@@ -231,13 +236,11 @@ std::string UpdateEdgeSentence::toString() const {
         buf += "UPDATE ";
     }
     buf += "EDGE ";
-    buf += srcid_->toString();
+    buf += srcId_->toString();
     buf += "->";
-    buf += dstid_->toString();
-    if (hasRank_) {
-        buf += " AT" + std::to_string(rank_);
-    }
-    buf += " OF " + *edgeType_;
+    buf += dstId_->toString();
+    buf += " AT" + std::to_string(rank_);
+    buf += " OF " + *name_;
     buf += " SET ";
     buf += updateList_->toString();
     if (whenClause_ != nullptr) {

src/parser/MutateSentences.h

@@ -303,22 +303,24 @@ private:
 class UpdateItem final {
 public:
     UpdateItem(std::string *field, Expression *value) {
-        field_.reset(field);
+        fieldStr_.reset(field);
         value_.reset(value);
     }
 
     UpdateItem(Expression *field, Expression *value) {
-        // TODO
-        UNUSED(field);
-        field_ = std::make_unique<std::string>("");
+        fieldExpr_.reset(field);
         value_.reset(value);
     }
 
-    std::string* field() const {
-        return field_.get();
+    std::string* getFieldName() const {
+        return fieldStr_.get();
     }
 
-    Expression* value() const {
+    const Expression* getFieldExpr() const {
+        return fieldExpr_.get();
+    }
+
+    const Expression* value() const {
         return value_.get();
     }
 
@@ -327,13 +329,17 @@ public:
     StatusOr<std::string> toEvaledString() const;
 
 private:
-    std::unique_ptr<std::string>                field_;
+    std::unique_ptr<std::string>                fieldStr_;
+    std::unique_ptr<Expression>                 fieldExpr_;
     std::unique_ptr<Expression>                 value_;
 };
 
 
 class UpdateList final {
 public:
+    UpdateList() = default;
+    ~UpdateList() = default;
+
     void addItem(UpdateItem *item) {
         items_.emplace_back(item);
     }
@@ -355,147 +361,137 @@ private:
     std::vector<std::unique_ptr<UpdateItem>>    items_;
 };
 
-
-class UpdateVertexSentence final : public Sentence {
+class UpdateBaseSentence : public Sentence {
 public:
-    UpdateVertexSentence() {
-        kind_ = Kind::kUpdateVertex;
+    UpdateBaseSentence(UpdateList *updateList,
+                       WhenClause *whenClause,
+                       YieldClause *yieldClause,
+                       std::string* name,
+                       bool isInsertable = false) {
+        updateList_.reset(updateList);
+        whenClause_.reset(whenClause);
+        yieldClause_.reset(yieldClause);
+        name_.reset(name);
+        insertable_ = isInsertable;
     }
 
-    void setInsertable(bool insertable) {
-        insertable_ = insertable;
-    }
+    virtual ~UpdateBaseSentence() = default;
 
     bool getInsertable() const {
         return insertable_;
     }
 
-    void setVid(Expression *vid) {
-        vid_.reset(vid);
-    }
-
-    Expression* getVid() const {
-        return vid_.get();
-    }
-
-    void setUpdateList(UpdateList *updateList) {
-        updateList_.reset(updateList);
-    }
-
     const UpdateList* updateList() const {
         return updateList_.get();
     }
 
-    void setWhenClause(WhenClause *clause) {
-        whenClause_.reset(clause);
-    }
-
     const WhenClause* whenClause() const {
         return whenClause_.get();
     }
 
-    void setYieldClause(YieldClause *clause) {
-        yieldClause_.reset(clause);
-    }
-
     const YieldClause* yieldClause() const {
         return yieldClause_.get();
     }
 
-    std::string toString() const override;
+    const std::string* getName() const {
+        return name_.get();
+    }
 
-private:
+protected:
     bool                                        insertable_{false};
-    std::unique_ptr<Expression>                 vid_;
     std::unique_ptr<UpdateList>                 updateList_;
     std::unique_ptr<WhenClause>                 whenClause_;
     std::unique_ptr<YieldClause>                yieldClause_;
+    std::unique_ptr<std::string>                name_;
 };
 
-
-class UpdateEdgeSentence final : public Sentence {
+class UpdateVertexSentence final : public UpdateBaseSentence {
 public:
-    UpdateEdgeSentence() {
-        kind_ = Kind::kUpdateEdge;
+    UpdateVertexSentence(Expression *vid,
+                         std::string *tagName,
+                         UpdateList *updateList,
+                         WhenClause *whenClause,
+                         YieldClause *yieldClause,
+                         bool isInsertable = false)
+        : UpdateBaseSentence(updateList, whenClause, yieldClause, tagName, isInsertable) {
+        kind_ = Kind::kUpdateVertex;
+        vid_.reset(vid);
     }
 
-    void setInsertable(bool insertable) {
-        insertable_ = insertable;
+    UpdateVertexSentence(Expression *vid,
+                         UpdateList *updateList,
+                         WhenClause *whenClause,
+                         YieldClause *yieldClause,
+                         bool isInsertable = false)
+        : UpdateBaseSentence(updateList, whenClause, yieldClause, nullptr, isInsertable) {
+        kind_ = Kind::kUpdateVertex;
+        vid_.reset(vid);
     }
 
+    ~UpdateVertexSentence() {}
+
     bool getInsertable() const {
         return insertable_;
     }
 
-    void setSrcId(Expression* srcid) {
-        srcid_.reset(srcid);
-    }
-
-    Expression* getSrcId() const {
-        return srcid_.get();
-    }
-
-    void setDstId(Expression* dstid) {
-        dstid_.reset(dstid);
-    }
-
-    Expression* getDstId() const {
-        return dstid_.get();
+    Expression* getVid() const {
+        return vid_.get();
     }
 
-    void setRank(int64_t rank) {
-        rank_ = rank;
-        hasRank_ = true;
+    const UpdateList* updateList() const {
+        return updateList_.get();
     }
 
-    int64_t getRank() const {
-        return rank_;
+    const WhenClause* whenClause() const {
+        return whenClause_.get();
     }
 
-    void setEdgeType(std::string* edgeType) {
-        edgeType_.reset(edgeType);
+    const YieldClause* yieldClause() const {
+        return yieldClause_.get();
     }
 
-    const std::string* getEdgeType() const {
-        return edgeType_.get();
-    }
+    std::string toString() const override;
 
-    void setUpdateList(UpdateList *updateList) {
-        updateList_.reset(updateList);
-    }
+private:
+    std::unique_ptr<Expression>                 vid_;
+};
 
-    const UpdateList* updateList() const {
-        return updateList_.get();
-    }
 
-    void setWhenClause(WhenClause *clause) {
-        whenClause_.reset(clause);
+class UpdateEdgeSentence final : public UpdateBaseSentence {
+public:
+    UpdateEdgeSentence(Expression *srcId,
+                       Expression *dstId,
+                       int64_t rank,
+                       std::string *edgeName,
+                       UpdateList *updateList,
+                       WhenClause *whenClause,
+                       YieldClause *yieldClause,
+                       bool isInsertable = false)
+        : UpdateBaseSentence(updateList, whenClause, yieldClause, edgeName, isInsertable) {
+        kind_ = Kind::kUpdateEdge;
+        srcId_.reset(srcId);
+        dstId_.reset(dstId);
+        rank_ = rank;
     }
 
-    const WhenClause* whenClause() const {
-        return whenClause_.get();
+    Expression* getSrcId() const {
+        return srcId_.get();
     }
 
-    void setYieldClause(YieldClause *clause) {
-        yieldClause_.reset(clause);
+    Expression* getDstId() const {
+        return dstId_.get();
     }
 
-    const YieldClause* yieldClause() const {
-        return yieldClause_.get();
+    int64_t getRank() const {
+        return rank_;
     }
 
     std::string toString() const override;
 
 private:
-    bool                                        insertable_{false};
-    bool                                        hasRank_{false};
-    std::unique_ptr<Expression>                 srcid_;
-    std::unique_ptr<Expression>                 dstid_;
+    std::unique_ptr<Expression>                 srcId_;
+    std::unique_ptr<Expression>                 dstId_;
     int64_t                                     rank_{0L};
-    std::unique_ptr<std::string>                edgeType_;
-    std::unique_ptr<UpdateList>                 updateList_;
-    std::unique_ptr<WhenClause>                 whenClause_;
-    std::unique_ptr<YieldClause>                yieldClause_;
 };
 
 

src/parser/parser.yy

@@ -390,6 +390,10 @@ base_expression
     | function_call_expression {
         $$ = $1;
     }
+    | name_label {
+        // need to rewrite the expression
+        $$ = new SymbolPropertyExpression(Expression::Kind::kSymProperty, new std::string(""), new std::string(""), $1);
+    }
     ;
 
 input_ref_expression
@@ -1492,26 +1496,6 @@ edge_row_item
 
 rank: unary_integer { $$ = $1; };
 
-update_vertex_sentence
-    : KW_UPDATE KW_VERTEX vid KW_SET update_list when_clause yield_clause {
-        auto sentence = new UpdateVertexSentence();
-        sentence->setVid($3);
-        sentence->setUpdateList($5);
-        sentence->setWhenClause($6);
-        sentence->setYieldClause($7);
-        $$ = sentence;
-    }
-    | KW_UPSERT KW_VERTEX vid KW_SET update_list when_clause yield_clause {
-        auto sentence = new UpdateVertexSentence();
-        sentence->setInsertable(true);
-        sentence->setVid($3);
-        sentence->setUpdateList($5);
-        sentence->setWhenClause($6);
-        sentence->setYieldClause($7);
-        $$ = sentence;
-    }
-    ;
-
 update_list
     : update_item {
         $$ = new UpdateList();
@@ -1527,59 +1511,74 @@ update_item
     : name_label ASSIGN expression {
         $$ = new UpdateItem($1, $3);
     }
-    | alias_ref_expression ASSIGN expression {
-        $$ = new UpdateItem($1, $3);
-        delete $1;
+    | name_label DOT name_label ASSIGN expression {
+        auto symExpr = new SymbolPropertyExpression(Expression::Kind::kSymProperty, new std::string(""), $1, $3);
+        $$ = new UpdateItem(symExpr, $5);
+    }
+    ;
+
+update_vertex_sentence
+    // ======== Begin: Compatible with 1.0 =========
+    : KW_UPDATE KW_VERTEX vid KW_SET update_list when_clause yield_clause {
+        auto sentence = new UpdateVertexSentence($3, $5, $6, $7);
+        $$ = sentence;
+    }
+    | KW_UPSERT KW_VERTEX vid KW_SET update_list when_clause yield_clause {
+        auto sentence = new UpdateVertexSentence($3, $5, $6, $7,true);
+        $$ = sentence;
+    }
+     // ======== End: Compatible with 1.0 =========
+    | KW_UPDATE KW_VERTEX KW_ON name_label vid KW_SET update_list when_clause yield_clause {
+        auto sentence = new UpdateVertexSentence($5, $4, $7, $8, $9);
+        $$ = sentence;
+    }
+    | KW_UPSERT KW_VERTEX KW_ON name_label vid KW_SET update_list when_clause yield_clause {
+        auto sentence = new UpdateVertexSentence($5, $4, $7, $8, $9, true);
+        $$ = sentence;
     }
     ;
 
 update_edge_sentence
+    // ======== Begin: Compatible with 1.0 =========
     : KW_UPDATE KW_EDGE vid R_ARROW vid KW_OF name_label
       KW_SET update_list when_clause yield_clause {
-        auto sentence = new UpdateEdgeSentence();
-        sentence->setSrcId($3);
-        sentence->setDstId($5);
-        sentence->setEdgeType($7);
-        sentence->setUpdateList($9);
-        sentence->setWhenClause($10);
-        sentence->setYieldClause($11);
+        auto sentence = new UpdateEdgeSentence($3, $5, 0, $7, $9, $10, $11);
         $$ = sentence;
     }
     | KW_UPSERT KW_EDGE vid R_ARROW vid KW_OF name_label
       KW_SET update_list when_clause yield_clause {
-        auto sentence = new UpdateEdgeSentence();
-        sentence->setInsertable(true);
-        sentence->setSrcId($3);
-        sentence->setDstId($5);
-        sentence->setEdgeType($7);
-        sentence->setUpdateList($9);
-        sentence->setWhenClause($10);
-        sentence->setYieldClause($11);
+        auto sentence = new UpdateEdgeSentence($3, $5, 0, $7, $9, $10, $11, true);
         $$ = sentence;
     }
     | KW_UPDATE KW_EDGE vid R_ARROW vid AT rank KW_OF name_label
       KW_SET update_list when_clause yield_clause {
-        auto sentence = new UpdateEdgeSentence();
-        sentence->setSrcId($3);
-        sentence->setDstId($5);
-        sentence->setRank($7);
-        sentence->setEdgeType($9);
-        sentence->setUpdateList($11);
-        sentence->setWhenClause($12);
-        sentence->setYieldClause($13);
+        auto sentence = new UpdateEdgeSentence($3, $5, $7, $9, $11, $12, $13);
         $$ = sentence;
     }
     | KW_UPSERT KW_EDGE vid R_ARROW vid AT rank KW_OF name_label
       KW_SET update_list when_clause yield_clause {
-        auto sentence = new UpdateEdgeSentence();
-        sentence->setInsertable(true);
-        sentence->setSrcId($3);
-        sentence->setDstId($5);
-        sentence->setRank($7);
-        sentence->setEdgeType($9);
-        sentence->setUpdateList($11);
-        sentence->setWhenClause($12);
-        sentence->setYieldClause($13);
+        auto sentence = new UpdateEdgeSentence($3, $5, $7, $9, $11, $12, $13, true);
+        $$ = sentence;
+    }
+    // ======== End: Compatible with 1.0 =========
+    | KW_UPDATE KW_EDGE KW_ON name_label vid R_ARROW vid
+      KW_SET update_list when_clause yield_clause {
+        auto sentence = new UpdateEdgeSentence($5, $7, 0, $4, $9, $10, $11);
+        $$ = sentence;
+    }
+    | KW_UPSERT KW_EDGE KW_ON name_label vid R_ARROW vid
+      KW_SET update_list when_clause yield_clause {
+        auto sentence = new UpdateEdgeSentence($5, $7, 0, $4, $9, $10, $11, true);
+        $$ = sentence;
+    }
+    | KW_UPDATE KW_EDGE KW_ON name_label vid R_ARROW vid AT rank
+      KW_SET update_list when_clause yield_clause {
+        auto sentence = new UpdateEdgeSentence($5, $7, $9, $4, $11, $12, $13);
+        $$ = sentence;
+    }
+    | KW_UPSERT KW_EDGE KW_ON name_label vid R_ARROW vid AT rank
+      KW_SET update_list when_clause yield_clause {
+        auto sentence = new UpdateEdgeSentence($5, $7, $9, $4, $11, $12, $13, true);
         $$ = sentence;
     }
     ;

src/parser/test/ParserTest.cpp

@@ -145,7 +145,7 @@ TEST(Parser, Go) {
     }
     {
         GQLParser parser;
-        std::string query = "GO FROM \"1\",\"2\",\"3\" OVER friend WHERE person.name == \"dutor\"";
+        std::string query = "GO FROM \"1\",\"2\",\"3\" OVER friend WHERE person.name == \"Tom\"";
         auto result = parser.parse(query);
         ASSERT_TRUE(result.ok()) << result.status();
     }
@@ -643,7 +643,7 @@ TEST(Parser, InsertVertex) {
     {
         GQLParser parser;
         std::string query = "INSERT VERTEX person(name,age,married,salary,create_time) "
-                            "VALUES \"dutor\":(\"dutor\", 30, true, 3.14, 1551331900)";
+                            "VALUES \"Tom\":(\"Tom\", 30, true, 3.14, 1551331900)";
         auto result = parser.parse(query);
         ASSERT_TRUE(result.ok()) << result.status();
     }
@@ -679,21 +679,21 @@ TEST(Parser, InsertVertex) {
     {
         GQLParser parser;
         std::string query = "INSERT VERTEX person(name,age,married,salary,create_time) "
-                            "VALUES \"dutor\":(\"dutor\", 30, true, 3.14, 1551331900)";
+                            "VALUES \"Tom\":(\"Tom\", 30, true, 3.14, 1551331900)";
         auto result = parser.parse(query);
         ASSERT_TRUE(result.ok()) << result.status();
     }
     {
         GQLParser parser;
         std::string query = "INSERT VERTEX person(name,age,married,salary,create_time) "
-                            "VALUES \"dutor\":(\"dutor\", 30, true, 3.14, 1551331900)";
+                            "VALUES \"Tom\":(\"Tom\", 30, true, 3.14, 1551331900)";
         auto result = parser.parse(query);
         ASSERT_TRUE(result.ok()) << result.status();
     }
     {
         GQLParser parser;
         std::string query = "INSERT VERTEX person(name,age,married,salary,create_time) "
-                            "VALUES \"dutor\":(\"dutor\", 30, true, 3.14, 1551331900)";
+                            "VALUES \"Tom\":(\"Tom\", 30, true, 3.14, 1551331900)";
         auto result = parser.parse(query);
         ASSERT_TRUE(result.ok()) << result.status();
     }
@@ -709,7 +709,7 @@ TEST(Parser, InsertVertex) {
     {
         GQLParser parser;
         std::string query = "INSERT VERTEX person(name, age) "
-                            "VALUES \"dutor\":(\"dutor, 30)";
+                            "VALUES \"Tom\":(\"Tom, 30)";
         auto result = parser.parse(query);
         ASSERT_TRUE(result.status().isSyntaxError());
     }
@@ -717,21 +717,21 @@ TEST(Parser, InsertVertex) {
     {
         GQLParser parser;
         std::string query = "INSERT VERTEX person(name, age) "
-                            "VALUES \"dutor\":(\'dutor, 30)";
+                            "VALUES \"Tom\":(\'Tom, 30)";
         auto result = parser.parse(query);
         ASSERT_TRUE(result.status().isSyntaxError());
     }
     {
         GQLParser parser;
         std::string query = "INSERT VERTEX person(name, age) "
-                            "VALUES \"dutor\":(\'dutor, 30)";
+                            "VALUES \"Tom\":(\'Tom, 30)";
         auto result = parser.parse(query);
         ASSERT_TRUE(result.status().isSyntaxError());
     }
     {
         GQLParser parser;
         std::string query = "INSERT VERTEX person(name, age) "
-                            "VALUES \"dutor\":(\'dutor, 30)";
+                            "VALUES \"Tom\":(\'Tom, 30)";
         auto result = parser.parse(query);
         ASSERT_TRUE(result.status().isSyntaxError());
     }
@@ -740,49 +740,91 @@ TEST(Parser, InsertVertex) {
 TEST(Parser, UpdateVertex) {
     {
         GQLParser parser;
-        std::string query = "UPDATE VERTEX \"dutor\" "
-                            "SET person.name=\"dutor\", person.age=30, "
-                                "job.salary=10000, person.create_time=1551331999";
+        std::string query = "UPDATE VERTEX \"12345\" "
+                            "SET person.name=\"Tome\", person.age=30, "
+                            "job.salary=10000, person.create_time=1551331999";
         auto result = parser.parse(query);
         ASSERT_TRUE(result.ok()) << result.status();
     }
     {
         GQLParser parser;
-        std::string query = "UPDATE VERTEX \"dutor\" "
-                            "SET person.name=\"dutor\", person.age=$^.person.age + 1, "
-                                "person.married=true "
+        std::string query = "UPDATE VERTEX ON person \"12345\" "
+                            "SET name=\"Tome\", age=30";
+        auto result = parser.parse(query);
+        ASSERT_TRUE(result.ok()) << result.status();
+    }
+    {
+        GQLParser parser;
+        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";
         auto result = parser.parse(query);
         ASSERT_TRUE(result.ok()) << result.status();
     }
     {
         GQLParser parser;
-        std::string query = "UPDATE VERTEX \"dutor\" "
-                            "SET person.name=\"dutor\", person.age=31, person.married=true, "
-                                "job.salary=1.1 * $^.person.create_time / 31536000 "
+        std::string query = "UPDATE VERTEX \"12345\" "
+                            "SET name=\"Tom\", age=age + 1, "
+                            "married=true "
+                            "WHEN salary > 10000 && age > 30";
+        auto result = parser.parse(query);
+        ASSERT_TRUE(result.ok()) << result.status();
+    }
+    {
+        GQLParser parser;
+        std::string query = "UPDATE VERTEX \"12345\" "
+                            "SET person.name=\"Tom\", person.age=31, person.married=true, "
+                            "job.salary=1.1 * $^.person.create_time / 31536000 "
                             "YIELD $^.person.name AS Name, job.name AS Title, "
-                                  "$^.job.salary AS Salary";
+                            "$^.job.salary AS Salary";
+        auto result = parser.parse(query);
+        ASSERT_TRUE(result.ok()) << result.status();
+    }
+    {
+        GQLParser parser;
+        std::string query = "UPDATE VERTEX ON person \"12345\" "
+                            "SET name=\"Tom\", age=31, married=true "
+                            "YIELD name AS Name";
         auto result = parser.parse(query);
         ASSERT_TRUE(result.ok()) << result.status();
     }
     {
         GQLParser parser;
-        std::string query = "UPDATE VERTEX \"dutor\" "
-                            "SET person.name=\"dutor\", person.age=30, person.married=true "
+        std::string query = "UPDATE VERTEX \"12345\" "
+                            "SET person.name=\"Tom\", person.age=30, person.married=true "
                             "WHEN $^.job.salary > 10000 && $^.job.name == \"CTO\" || "
-                                  "$^.person.age < 30"
+                            "$^.person.age < 30"
                             "YIELD $^.person.name AS Name, $^.job.salary AS Salary, "
-                                  "$^.person.create_time AS Time";
+                            "$^.person.create_time AS Time";
         auto result = parser.parse(query);
         ASSERT_TRUE(result.ok()) << result.status();
     }
     {
         GQLParser parser;
-        std::string query = "UPSERT VERTEX \"dutor\" "
-                            "SET person.name=\"dutor\", person.age = 30, job.name =\"CTO\" "
+        std::string query = "UPDATE VERTEX ON person \"12345\" "
+                            "SET name=\"Tom\", age=30, married=true "
+                            "WHEN salary > 10000 && name == \"CTO\" || age < 30"
+                            "YIELD name AS Name, salary AS Salary, create_time AS Time";
+        auto result = parser.parse(query);
+        ASSERT_TRUE(result.ok()) << result.status();
+    }
+    {
+        GQLParser parser;
+        std::string query = "UPSERT VERTEX \"12345\" "
+                            "SET person.name=\"Tom\", person.age = 30, job.name =\"CTO\" "
                             "WHEN $^.job.salary > 10000 "
                             "YIELD $^.person.name AS Name, $^.job.salary AS Salary, "
-                                  "$^.person.create_time AS Time";
+                            "$^.person.create_time AS Time";
+        auto result = parser.parse(query);
+        ASSERT_TRUE(result.ok()) << result.status();
+    }
+    {
+        GQLParser parser;
+        std::string query = "UPSERT VERTEX ON person \"12345\" "
+                            "SET name=\"Tom\", age = 30, name =\"CTO\" "
+                            "WHEN salary > 10000 "
+                            "YIELD name AS Name, salary AS Salary, create_time AS Time";
         auto result = parser.parse(query);
         ASSERT_TRUE(result.ok()) << result.status();
     }
@@ -866,11 +908,26 @@ TEST(Parser, UpdateEdge) {
         auto result = parser.parse(query);
         ASSERT_TRUE(result.ok()) << result.status();
     }
+    {
+        GQLParser parser;
+        std::string query = "UPDATE EDGE ON transfer \"12345\" -> \"54321\" "
+                            "SET amount=3.14, time=1537408527";
+        auto result = parser.parse(query);
+        ASSERT_TRUE(result.ok()) << result.status();
+    }
     {
         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 == \"dutor\"";
+                            "WHEN transfer.amount > 3.14 && $^.person.name == \"Tom\"";
+        auto result = parser.parse(query);
+        ASSERT_TRUE(result.ok()) << result.status();
+    }
+    {
+        GQLParser parser;
+        std::string query = "UPDATE EDGE ON transfer \"12345\" -> \"54321\"@789 "
+                            "SET amount=3.14,time=1537408527 "
+                            "WHEN amount > 3.14";
         auto result = parser.parse(query);
         ASSERT_TRUE(result.ok()) << result.status();
     }
@@ -880,7 +937,16 @@ TEST(Parser, UpdateEdge) {
                             "SET amount = 3.14 + $^.job.salary, time = 1537408527 "
                             "WHEN transfer.amount > 3.14 || $^.job.salary >= 10000 "
                             "YIELD transfer.amount, transfer.time AS Time, "
-                                "$^.person.name AS PayFrom";
+                            "$^.person.name AS PayFrom";
+        auto result = parser.parse(query);
+        ASSERT_TRUE(result.ok()) << result.status();
+    }
+    {
+        GQLParser parser;
+        std::string query = "UPDATE EDGE ON transfer \"12345\" -> \"54321\" "
+                            "SET amount = 3.14 + amount, time = 1537408527 "
+                            "WHEN amount > 3.14 "
+                            "YIELD amount, time AS Time";
         auto result = parser.parse(query);
         ASSERT_TRUE(result.ok()) << result.status();
     }
@@ -893,6 +959,15 @@ TEST(Parser, UpdateEdge) {
         auto result = parser.parse(query);
         ASSERT_TRUE(result.ok()) << result.status();
     }
+    {
+        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 "
+                            "YIELD amount, time, name AS Name";
+        auto result = parser.parse(query);
+        ASSERT_TRUE(result.ok()) << result.status();
+    }
 }
 
 TEST(Parser, DeleteVertex) {
@@ -988,26 +1063,26 @@ TEST(Parser, FetchVertex) {
     }
     {
         GQLParser parser;
-        std::string query = "FETCH PROP ON person \"dutor\"";
+        std::string query = "FETCH PROP ON person \"Tom\"";
         auto result = parser.parse(query);
         ASSERT_TRUE(result.ok()) << result.status();
     }
     {
         GQLParser parser;
-        std::string query = "FETCH PROP ON person \"dutor\", \"darion\"";
+        std::string query = "FETCH PROP ON person \"Tom\", \"darion\"";
         auto result = parser.parse(query);
         ASSERT_TRUE(result.ok()) << result.status();
     }
     {
         GQLParser parser;
-        std::string query = "FETCH PROP ON person \"dutor\" "
+        std::string query = "FETCH PROP ON person \"Tom\" "
                             "YIELD person.name, person.age";
         auto result = parser.parse(query);
         ASSERT_TRUE(result.ok()) << result.status();
     }
     {
         GQLParser parser;
-        std::string query = "FETCH PROP ON person \"dutor\", \"darion\" "
+        std::string query = "FETCH PROP ON person \"Tom\", \"darion\" "
                             "YIELD person.name, person.age";
         auto result = parser.parse(query);
         ASSERT_TRUE(result.ok()) << result.status();
@@ -1035,26 +1110,26 @@ TEST(Parser, FetchVertex) {
     }
     {
         GQLParser parser;
-        std::string query = "FETCH PROP ON person uuid(\"dutor\")";
+        std::string query = "FETCH PROP ON person uuid(\"Tom\")";
         auto result = parser.parse(query);
         ASSERT_TRUE(result.ok()) << result.status();
     }
     {
         GQLParser parser;
-        std::string query = "FETCH PROP ON person \"dutor\", \"darion\"";
+        std::string query = "FETCH PROP ON person \"Tom\", \"darion\"";
         auto result = parser.parse(query);
         ASSERT_TRUE(result.ok()) << result.status();
     }
     {
         GQLParser parser;
-        std::string query = "FETCH PROP ON person \"dutor\" "
+        std::string query = "FETCH PROP ON person \"Tom\" "
                             "YIELD person.name, person.age";
         auto result = parser.parse(query);
         ASSERT_TRUE(result.ok()) << result.status();
     }
     {
         GQLParser parser;
-        std::string query = "FETCH PROP ON person \"dutor\", \"darion\" "
+        std::string query = "FETCH PROP ON person \"Tom\", \"darion\" "
                             "YIELD person.name, person.age";
         auto result = parser.parse(query);
         ASSERT_TRUE(result.ok()) << result.status();
@@ -2037,22 +2112,6 @@ TEST(Parser, UseReservedKeyword) {
     }
 }
 
-TEST(Parser, IssueLabelAsExpression) {
-    // name label is not a valid expression, it's not value
-    {
-        GQLParser parser;
-        std::string query = "INSERT VERTEX person(name) VALUES \"1\":(name_label)";
-        auto result = parser.parse(query);
-        ASSERT_FALSE(result.ok());
-    }
-    {
-        GQLParser parser;
-        std::string query = "INSERT VERTEX person(name) VALUES \"1\":(`name_label`)";
-        auto result = parser.parse(query);
-        ASSERT_FALSE(result.ok());
-    }
-}
-
 TEST(Parser, TypeCast) {
     {
         GQLParser parser;

src/planner/Mutate.h

@@ -132,18 +132,223 @@ private:
     bool                                       overwritable_;
 };
 
-class UpdateVertex final : public SingleInputNode {
+class Update : public SingleInputNode {
 public:
+    bool getInsertable() const {
+        return insertable_;
+    }
+
+    const std::vector<std::string>& getReturnProps() const {
+        return returnProps_;
+    }
+
+    const std::string getCondition() const {
+        return condition_;
+    }
+
+    const std::vector<std::string>& getYieldNames() const {
+        return yieldNames_;
+    }
+
+    GraphSpaceID getSpaceId() const {
+        return spaceId_;
+    }
+
+    const std::vector<storage::cpp2::UpdatedProp>& getUpdatedProps() const {
+        return updatedProps_;
+    }
+
+    const std::string& getName() const {
+        return schemaName_;
+    }
+
+protected:
+    Update(Kind kind,
+           ExecutionPlan* plan,
+           PlanNode* input,
+           GraphSpaceID spaceId,
+           std::string name,
+           bool insertable,
+           std::vector<storage::cpp2::UpdatedProp> updatedProps,
+           std::vector<std::string> returnProps,
+           std::string condition,
+           std::vector<std::string> yieldNames)
+        : SingleInputNode(plan, kind, input)
+        , spaceId_(spaceId)
+        , schemaName_(std::move(name))
+        , insertable_(insertable)
+        , updatedProps_(std::move(updatedProps))
+        , returnProps_(std::move(returnProps))
+        , condition_(std::move(condition))
+        , yieldNames_(std::move(yieldNames)) {}
+
+protected:
+    GraphSpaceID                                        spaceId_{-1};
+    std::string                                         schemaName_;
+    bool                                                insertable_;
+    std::vector<storage::cpp2::UpdatedProp>             updatedProps_;
+    std::vector<std::string>                            returnProps_;
+    std::string                                         condition_;
+    std::vector<std::string>                            yieldNames_;
+};
+
+class UpdateVertex final : public Update {
+public:
+    static UpdateVertex* make(ExecutionPlan* plan,
+                              PlanNode* input,
+                              GraphSpaceID spaceId,
+                              std::string name,
+                              std::string vId,
+                              TagID tagId,
+                              bool insertable,
+                              std::vector<storage::cpp2::UpdatedProp> updatedProps,
+                              std::vector<std::string> returnProps,
+                              std::string condition,
+                              std::vector<std::string> yieldNames) {
+        return new UpdateVertex(plan,
+                                input,
+                                spaceId,
+                                std::move(name),
+                                std::move(vId),
+                                tagId,
+                                insertable,
+                                std::move(updatedProps),
+                                std::move(returnProps),
+                                std::move(condition),
+                                std::move(yieldNames));
+    }
+
     std::string explain() const override {
         return "UpdateVertex";
     }
+
+    const std::string& getVId() const {
+        return vId_;
+    }
+
+    TagID getTagId() const {
+        return tagId_;
+    }
+
+private:
+    UpdateVertex(ExecutionPlan* plan,
+                 PlanNode* input,
+                 GraphSpaceID spaceId,
+                 std::string name,
+                 std::string vId,
+                 TagID tagId,
+                 bool insertable,
+                 std::vector<storage::cpp2::UpdatedProp> updatedProps,
+                 std::vector<std::string> returnProps,
+                 std::string condition,
+                 std::vector<std::string> yieldNames)
+        : Update(Kind::kUpdateVertex,
+                 plan,
+                 input,
+                 spaceId,
+                 std::move(name),
+                 insertable,
+                 std::move(updatedProps),
+                 std::move(returnProps),
+                 std::move(condition),
+                 std::move(yieldNames))
+        , vId_(std::move(vId))
+        , tagId_(tagId) {}
+
+private:
+    std::string                                     vId_;
+    TagID                                           tagId_{-1};
 };
 
-class UpdateEdge final : public SingleInputNode {
+class UpdateEdge final : public Update {
 public:
+    static UpdateEdge* make(ExecutionPlan* plan,
+                            PlanNode* input,
+                            GraphSpaceID spaceId,
+                            std::string name,
+                            std::string srcId,
+                            std::string dstId,
+                            EdgeType edgeType,
+                            int64_t rank,
+                            bool insertable,
+                            std::vector<storage::cpp2::UpdatedProp> updatedProps,
+                            std::vector<std::string> returnProps,
+                            std::string condition,
+                            std::vector<std::string> yieldNames) {
+        return new UpdateEdge(plan,
+                              input,
+                              spaceId,
+                              std::move(name),
+                              std::move(srcId),
+                              std::move(dstId),
+                              edgeType,
+                              rank,
+                              insertable,
+                              std::move(updatedProps),
+                              std::move(returnProps),
+                              std::move(condition),
+                              std::move(yieldNames));
+    }
+
     std::string explain() const override {
         return "UpdateEdge";
     }
+
+    const std::string& getSrcId() const {
+        return srcId_;
+    }
+
+    const std::string& getDstId() const {
+        return dstId_;
+    }
+
+    int64_t getRank() const {
+        return rank_;
+    }
+
+    int64_t getEdgeType() const {
+        return edgeType_;
+    }
+
+    const std::vector<storage::cpp2::UpdatedProp>& getUpdatedProps() const {
+        return updatedProps_;
+    }
+
+private:
+    UpdateEdge(ExecutionPlan* plan,
+               PlanNode* input,
+               GraphSpaceID spaceId,
+               std::string name,
+               std::string srcId,
+               std::string dstId,
+               EdgeType edgeType,
+               int64_t rank,
+               bool insertable,
+               std::vector<storage::cpp2::UpdatedProp> updatedProps,
+               std::vector<std::string> returnProps,
+               std::string condition,
+               std::vector<std::string> yieldNames)
+        : Update(Kind::kUpdateEdge,
+                 plan,
+                 input,
+                 spaceId,
+                 std::move(name),
+                 insertable,
+                 std::move(updatedProps),
+                 std::move(returnProps),
+                 std::move(condition),
+                 std::move(yieldNames))
+
+        , srcId_(std::move(srcId))
+        , dstId_(std::move(dstId))
+        , rank_(rank)
+        , edgeType_(edgeType) {}
+
+private:
+    std::string                                         srcId_;
+    std::string                                         dstId_;
+    int64_t                                             rank_{0};
+    EdgeType                                            edgeType_{-1};
 };
 
 class DeleteVertices final : public SingleInputNode {

src/planner/PlanNode.cpp

@@ -108,6 +108,10 @@ const char* PlanNode::toString(PlanNode::Kind kind) {
             return "DeleteVertices";
         case Kind::kDeleteEdges:
             return "DeleteEdges";
+        case Kind::kUpdateVertex:
+            return "UpdateVertex";
+        case Kind::kUpdateEdge:
+            return "UpdateEdge";
     }
     LOG(FATAL) << "Impossible kind plan node " << static_cast<int>(kind);
 }

src/planner/PlanNode.h

@@ -68,6 +68,8 @@ public:
         kDataJoin,
         kDeleteVertices,
         kDeleteEdges,
+        kUpdateVertex,
+        kUpdateEdge,
     };
 
     PlanNode(ExecutionPlan* plan, Kind kind);

src/validator/MutateValidator.cpp

@@ -88,13 +88,25 @@ Status InsertVerticesValidator::prepareVertices() {
     for (auto i = 0u; i < rows_.size(); i++) {
         auto *row = rows_[i];
         if (propSize_ != row->values().size()) {
-            return Status::Error("Wrong number of value");
+            return Status::Error("Column count doesn't match value count.");
+        }
+        if (!evaluableExpr(row->id())) {
+            LOG(ERROR) << "Wrong vid expression `" << row->id()->toString() << "\"";
+            return Status::Error("Wrong vid expression `%s'", row->id()->toString().c_str());
         }
         auto idStatus = SchemaUtil::toVertexID(row->id());
         if (!idStatus.ok()) {
             return idStatus.status();
         }
         auto vertexId = std::move(idStatus).value();
+
+        // check value expr
+        for (auto &value : row->values()) {
+            if (!evaluableExpr(value)) {
+                LOG(ERROR) << "Insert wrong value: `" << value->toString() << "'.";
+                return Status::Error("Insert wrong value: `%s'.", value->toString().c_str());
+            }
+        }
         auto valsRet = SchemaUtil::toValueVec(row->values());
         if (!valsRet.ok()) {
             return valsRet.status();
@@ -195,8 +207,18 @@ Status InsertEdgesValidator::prepareEdges() {;
     for (auto i = 0u; i < rows_.size(); i++) {
         auto *row = rows_[i];
         if (propNames_.size() != row->values().size()) {
-            return Status::Error("Wrong number of value");
+            return Status::Error("Column count doesn't match value count.");
+        }
+        if (!evaluableExpr(row->srcid())) {
+            LOG(ERROR) << "Wrong src vid expression `" << row->srcid()->toString() << "\"";
+            return Status::Error("Wrong src vid expression `%s'", row->srcid()->toString().c_str());
+        }
+
+        if (!evaluableExpr(row->dstid())) {
+            LOG(ERROR) << "Wrong dst vid expression `" << row->dstid()->toString() << "\"";
+            return Status::Error("Wrong dst vid expression `%s'", row->dstid()->toString().c_str());
         }
+
         auto idStatus = SchemaUtil::toVertexID(row->srcid());
         if (!idStatus.ok()) {
             return idStatus.status();
@@ -210,6 +232,14 @@ Status InsertEdgesValidator::prepareEdges() {;
 
         int64_t rank = row->rank();
 
+        // check value expr
+        for (auto &value : row->values()) {
+            if (!evaluableExpr(value)) {
+                LOG(ERROR) << "Insert wrong value: `" << value->toString() << "'.";
+                return Status::Error("Insert wrong value: `%s'.", value->toString().c_str());
+            }
+        }
+
         auto valsRet = SchemaUtil::toValueVec(row->values());
         if (!valsRet.ok()) {
             return valsRet.status();
@@ -484,5 +514,322 @@ Status DeleteEdgesValidator::toPlan() {
     return Status::OK();
 }
 
+Status UpdateValidator::initProps() {
+    spaceId_ = vctx_->whichSpace().id;
+    insertable_ = sentence_->getInsertable();
+    if (sentence_->getName() != nullptr) {
+        name_ = *sentence_->getName();
+    }
+    NG_RETURN_IF_ERROR(getUpdateProps());
+    NG_RETURN_IF_ERROR(getCondition());
+    return getReturnProps();
+}
+
+Status UpdateValidator::getCondition() {
+    auto *clause = sentence_->whenClause();
+    if (clause != nullptr) {
+        auto filter = clause->filter();
+        if (filter != nullptr) {
+            auto encodeStr = filter->encode();
+            auto copyFilterExpr = Expression::decode(encodeStr);
+            NG_LOG_AND_RETURN_IF_ERROR(
+                    checkAndResetSymExpr(copyFilterExpr.get(), name_, encodeStr));
+            condition_ = std::move(encodeStr);
+        }
+    }
+    return Status::OK();
+}
+
+Status UpdateValidator::getReturnProps() {
+    auto *clause = sentence_->yieldClause();
+    if (clause != nullptr) {
+        auto yields = clause->columns();
+        for (auto *col : yields) {
+            if (col->alias() == nullptr) {
+                yieldColNames_.emplace_back(col->expr()->toString());
+            } else {
+                yieldColNames_.emplace_back(*col->alias());
+            }
+            auto encodeStr = col->expr()->encode();
+            auto copyColExpr = Expression::decode(encodeStr);
+
+            NG_LOG_AND_RETURN_IF_ERROR(checkAndResetSymExpr(copyColExpr.get(), name_, encodeStr));
+            returnProps_.emplace_back(std::move(encodeStr));
+        }
+    }
+    return Status::OK();
+}
+
+Status UpdateValidator::getUpdateProps() {
+    auto status = Status::OK();
+    auto items = sentence_->updateList()->items();
+    std::unordered_set<std::string> symNames;
+    std::string fieldName;
+    const std::string *symName = nullptr;
+    for (auto& item : items) {
+        storage::cpp2::UpdatedProp updatedProp;
+        // The syntax has guaranteed it is name or expression
+        if (item->getFieldName() != nullptr) {
+            symName = &name_;
+            fieldName = *item->getFieldName();
+            symNames.emplace(name_);
+        }
+        if (item->getFieldExpr() != nullptr) {
+            DCHECK(item->getFieldExpr()->kind() == Expression::Kind::kSymProperty);
+            auto symExpr = static_cast<const SymbolPropertyExpression*>(item->getFieldExpr());
+            symNames.emplace(*symExpr->sym());
+            symName = symExpr->sym();
+            fieldName = *symExpr->prop();
+        }
+        auto valueExpr = item->value();
+        if (valueExpr == nullptr) {
+            LOG(ERROR) << "valueExpr is nullptr";
+            return Status::SyntaxError("Empty update item field value");
+        }
+        auto encodeStr = valueExpr->encode();
+        auto copyValueExpr = Expression::decode(encodeStr);
+        NG_LOG_AND_RETURN_IF_ERROR(checkAndResetSymExpr(copyValueExpr.get(), *symName, encodeStr));
+        updatedProp.set_value(std::move(encodeStr));
+        updatedProp.set_name(fieldName);
+        updatedProps_.emplace_back(std::move(updatedProp));
+    }
+
+    if (symNames.size() != 1) {
+        auto errorMsg = "Multi schema name: " + folly::join(",", symNames);
+        LOG(ERROR) << errorMsg;
+        return Status::Error(std::move(errorMsg));
+    }
+    if (symName != nullptr) {
+        name_ = *symName;
+    }
+    return status;
+}
+
+
+Status UpdateValidator::checkAndResetSymExpr(Expression* inExpr,
+                                             const std::string& symName,
+                                             std::string &encodeStr) {
+    bool hasWrongType = false;
+    auto symExpr = rewriteSymExpr(inExpr, symName, hasWrongType, isEdge_);
+    if (hasWrongType) {
+        return Status::Error("Has wrong expr in `%s'",
+                             inExpr->toString().c_str());
+    }
+    if (symExpr != nullptr) {
+        encodeStr = symExpr->encode();
+        return Status::OK();
+    }
+    encodeStr = inExpr->encode();
+    return Status::OK();
+}
+
+// rewrite the expr which has kSymProperty expr to toExpr
+std::unique_ptr<Expression> UpdateValidator::rewriteSymExpr(Expression* expr,
+                                                            const std::string &sym,
+                                                            bool &hasWrongType,
+                                                            bool isEdge) {
+    switch (expr->kind()) {
+        case Expression::Kind::kConstant: {
+            break;
+        }
+        case Expression::Kind::kAdd:
+        case Expression::Kind::kMinus:
+        case Expression::Kind::kMultiply:
+        case Expression::Kind::kDivision:
+        case Expression::Kind::kMod:
+        case Expression::Kind::kRelEQ:
+        case Expression::Kind::kRelNE:
+        case Expression::Kind::kRelLT:
+        case Expression::Kind::kRelLE:
+        case Expression::Kind::kRelGT:
+        case Expression::Kind::kRelGE:
+        case Expression::Kind::kRelIn:
+        case Expression::Kind::kLogicalAnd:
+        case Expression::Kind::kLogicalOr:
+        case Expression::Kind::kLogicalXor: {
+            auto biExpr = static_cast<BinaryExpression*>(expr);
+            auto left = rewriteSymExpr(biExpr->left(), sym, hasWrongType, isEdge);
+            if (left != nullptr) {
+                biExpr->setLeft(left.release());
+            }
+            auto right = rewriteSymExpr(biExpr->right(), sym, hasWrongType, isEdge);
+            if (right != nullptr) {
+                biExpr->setRight(right.release());
+            }
+            break;
+        }
+        case Expression::Kind::kUnaryPlus:
+        case Expression::Kind::kUnaryNegate:
+        case Expression::Kind::kUnaryNot: {
+            auto unaryExpr = static_cast<UnaryExpression*>(expr);
+            auto rewrite = rewriteSymExpr(unaryExpr->operand(), sym, hasWrongType, isEdge);
+            if (rewrite != nullptr) {
+                unaryExpr->setOperand(rewrite.release());
+            }
+            break;
+        }
+        case Expression::Kind::kFunctionCall: {
+            auto funcExpr = static_cast<FunctionCallExpression*>(expr);
+            auto* argList = const_cast<ArgumentList*>(funcExpr->args());
+            auto args = argList->moveArgs();
+            for (auto iter = args.begin(); iter < args.end(); ++iter) {
+                auto rewrite = rewriteSymExpr(iter->get(), sym, hasWrongType, isEdge);
+                if (rewrite != nullptr) {
+                    *iter = std::move(rewrite);
+                }
+            }
+            argList->setArgs(std::move(args));
+            break;
+        }
+        case Expression::Kind::kTypeCasting: {
+            auto castExpr = static_cast<TypeCastingExpression*>(expr);
+            auto operand = rewriteSymExpr(castExpr->operand(), sym, hasWrongType, isEdge);
+            if (operand != nullptr) {
+                castExpr->setOperand(operand.release());
+            }
+            break;
+        }
+        case Expression::Kind::kSymProperty: {
+            auto symExpr = static_cast<SymbolPropertyExpression*>(expr);
+            if (isEdge) {
+                return std::make_unique<EdgePropertyExpression>(
+                        new std::string(sym), new std::string(*symExpr->prop()));
+            } else {
+                if (symExpr->sym() == nullptr || !symExpr->sym()->empty()) {
+                    hasWrongType = true;
+                    return nullptr;
+                }
+                return std::make_unique<SourcePropertyExpression>(
+                        new std::string(sym), new std::string(*symExpr->prop()));
+            }
+        }
+        case Expression::Kind::kSrcProperty: {
+            if (isEdge) {
+                hasWrongType = true;
+            }
+            break;
+        }
+        case Expression::Kind::kEdgeProperty: {
+            if (!isEdge) {
+                hasWrongType = true;
+            }
+            break;
+        }
+        case Expression::Kind::kDstProperty:
+        case Expression::Kind::kTagProperty:
+        case Expression::Kind::kEdgeSrc:
+        case Expression::Kind::kEdgeRank:
+        case Expression::Kind::kEdgeDst:
+        case Expression::Kind::kEdgeType:
+        case Expression::Kind::kUUID:
+        case Expression::Kind::kVar:
+        case Expression::Kind::kVersionedVar:
+        case Expression::Kind::kVarProperty:
+        case Expression::Kind::kInputProperty:
+        case Expression::Kind::kUnaryIncr:
+        case Expression::Kind::kUnaryDecr: {
+            hasWrongType = true;
+            break;
+        }
+    }
+    return nullptr;
+}
+
+
+Status UpdateVertexValidator::validateImpl() {
+    auto sentence = static_cast<UpdateVertexSentence*>(sentence_);
+    auto idRet = SchemaUtil::toVertexID(sentence->getVid());
+    if (!idRet.ok()) {
+        LOG(ERROR) << idRet.status();
+        return idRet.status();
+    }
+    vId_ = std::move(idRet).value();
+    NG_RETURN_IF_ERROR(initProps());
+    auto ret = qctx_->schemaMng()->toTagID(spaceId_, name_);
+    if (!ret.ok()) {
+        LOG(ERROR) << "No schema found for " << name_;
+        return Status::Error("No schema found for `%s'", name_.c_str());
+    }
+    tagId_ = ret.value();
+    return Status::OK();
+}
+
+Status UpdateVertexValidator::toPlan() {
+    auto* plan = qctx_->plan();
+    auto *update = UpdateVertex::make(plan,
+                                      nullptr,
+                                      spaceId_,
+                                      std::move(name_),
+                                      vId_,
+                                      tagId_,
+                                      insertable_,
+                                      std::move(updatedProps_),
+                                      std::move(returnProps_),
+                                      std::move(condition_),
+                                      std::move(yieldColNames_));
+    root_ = update;
+    tail_ = root_;
+    return Status::OK();
+}
+
+Status UpdateEdgeValidator::validateImpl() {
+    auto sentence = static_cast<UpdateEdgeSentence*>(sentence_);
+    auto srcIdRet = SchemaUtil::toVertexID(sentence->getSrcId());
+    if (!srcIdRet.ok()) {
+        LOG(ERROR) << srcIdRet.status();
+        return srcIdRet.status();
+    }
+    srcId_ = std::move(srcIdRet).value();
+    auto dstIdRet = SchemaUtil::toVertexID(sentence->getDstId());
+    if (!dstIdRet.ok()) {
+        LOG(ERROR) << dstIdRet.status();
+        return dstIdRet.status();
+    }
+    dstId_ = std::move(dstIdRet).value();
+    rank_ = sentence->getRank();
+    NG_RETURN_IF_ERROR(initProps());
+    auto ret = qctx_->schemaMng()->toEdgeType(spaceId_, name_);
+    if (!ret.ok()) {
+        LOG(ERROR) << "No schema found for " << name_;
+        return Status::Error("No schema found for `%s'", name_.c_str());
+    }
+    edgeType_ = ret.value();
+    return Status::OK();
+}
+
+Status UpdateEdgeValidator::toPlan() {
+    auto* plan = qctx_->plan();
+    auto *outNode = UpdateEdge::make(plan,
+                                     nullptr,
+                                     spaceId_,
+                                     name_,
+                                     srcId_,
+                                     dstId_,
+                                     edgeType_,
+                                     rank_,
+                                     insertable_,
+                                     updatedProps_,
+                                     {},
+                                     condition_,
+                                     {});
+
+    auto *inNode = UpdateEdge::make(plan,
+                                    outNode,
+                                    spaceId_,
+                                    std::move(name_),
+                                    std::move(dstId_),
+                                    std::move(srcId_),
+                                    -edgeType_,
+                                    rank_,
+                                    insertable_,
+                                    std::move(updatedProps_),
+                                    std::move(returnProps_),
+                                    std::move(condition_),
+                                    std::move(yieldColNames_));
+    root_ = inNode;
+    tail_ = outNode;
+    return Status::OK();
+}
+
 }  // namespace graph
 }  // namespace nebula

src/validator/MutateValidator.h

@@ -110,6 +110,84 @@ private:
     std::vector<EdgeKeyRef*>                       edgeKeyRefs_;
     std::string                                    edgeKeyVar_;
 };
+
+class UpdateValidator : public Validator {
+public:
+    explicit UpdateValidator(Sentence* sentence,
+                             QueryContext* context,
+                             bool isEdge = false)
+        : Validator(sentence, context) {
+        sentence_ = static_cast<UpdateBaseSentence*>(sentence);
+        isEdge_ = isEdge;
+    }
+
+    virtual ~UpdateValidator() {}
+
+protected:
+    Status initProps();
+
+    Status getCondition();
+
+    Status getReturnProps();
+
+    Status getUpdateProps();
+
+private:
+    Status checkAndResetSymExpr(Expression* inExpr,
+                                const std::string& symName,
+                                std::string &encodeStr);
+
+    std::unique_ptr<Expression> rewriteSymExpr(Expression* expr,
+                                               const std::string &sym,
+                                               bool &hasWrongType,
+                                               bool isEdge = false);
+
+protected:
+    UpdateBaseSentence                                 *sentence_;
+    bool                                                insertable_{false};
+    GraphSpaceID                                        spaceId_{-1};
+    std::vector<std::string>                            returnProps_;
+    std::vector<std::string>                            yieldColNames_;
+    std::string                                         condition_;
+    std::vector<storage::cpp2::UpdatedProp>             updatedProps_;
+    std::string                                         name_;
+    bool                                                isEdge_{false};
+};
+
+class UpdateVertexValidator final : public UpdateValidator {
+public:
+    UpdateVertexValidator(Sentence* sentence, QueryContext* context)
+        : UpdateValidator(sentence, context) {
+    }
+
+private:
+    Status validateImpl() override;
+
+    Status toPlan() override;
+
+private:
+    std::string               vId_;
+    TagID                     tagId_{-1};
+};
+
+class UpdateEdgeValidator final : public UpdateValidator {
+public:
+    UpdateEdgeValidator(Sentence* sentence, QueryContext* context)
+        : UpdateValidator(sentence, context, true) {
+    }
+
+private:
+    Status validateImpl() override;
+
+    Status toPlan() override;
+
+private:
+    std::string                                       srcId_;
+    std::string                                       dstId_;
+    EdgeRanking                                       rank_{0};
+    EdgeType                                          edgeType_{-1};
+};
 }  // namespace graph
 }  // namespace nebula
 #endif  // VALIDATOR_MUTATEVALIDATOR_H
+

src/validator/Validator.cpp

@@ -114,6 +114,10 @@ std::unique_ptr<Validator> Validator::makeValidator(Sentence* sentence, QueryCon
             return std::make_unique<DeleteVerticesValidator>(sentence, context);
         case Sentence::Kind::kDeleteEdges:
             return std::make_unique<DeleteEdgesValidator>(sentence, context);
+        case Sentence::Kind::kUpdateVertex:
+            return std::make_unique<UpdateVertexValidator>(sentence, context);
+        case Sentence::Kind::kUpdateEdge:
+            return std::make_unique<UpdateEdgeValidator>(sentence, context);
         default:
             return std::make_unique<ReportError>(sentence, context);
     }
@@ -156,7 +160,9 @@ Status Validator::appendPlan(PlanNode* node, PlanNode* appended) {
         case PlanNode::Kind::kDropSnapshot:
         case PlanNode::Kind::kShowSnapshots:
         case PlanNode::Kind::kDeleteVertices:
-        case PlanNode::Kind::kDeleteEdges: {
+        case PlanNode::Kind::kDeleteEdges:
+        case PlanNode::Kind::kUpdateVertex:
+        case PlanNode::Kind::kUpdateEdge: {
             static_cast<SingleDependencyNode*>(node)->dependsOn(appended);
             break;
         }

src/validator/test/MaintainValidatorTest.cpp

@@ -28,7 +28,7 @@ TEST_F(MaintainValidatorTest, TagTest) {
     }
     // the same name schema
     {
-        ASSERT_FALSE(checkResult("CREATE TAG TEST(); CREATE TAG TEST;", {}));
+        ASSERT_FALSE(checkResult("CREATE TAG TEST();CREATE TAG TEST()", {}));
     }
 }
 
@@ -41,7 +41,7 @@ TEST_F(MaintainValidatorTest, EdgeTest) {
     }
     // the same name schema
     {
-        ASSERT_FALSE(checkResult("CREATE EDGE TEST(); CREATE EDGE TEST;", {}));
+        ASSERT_FALSE(checkResult("CREATE EDGE TEST();CREATE EDGE TEST()", {}));
     }
 }
 }  // namespace graph

src/validator/test/MutateValidatorTest.cpp

@@ -19,6 +19,16 @@ TEST_F(MutateValidatorTest, InsertVertexTest) {
         auto cmd = "INSERT VERTEX person(name, age2) VALUES \"A\":(\"a\", 19);";
         ASSERT_FALSE(checkResult(cmd, {}));
     }
+    // wrong vid expression
+    {
+        auto cmd = "INSERT VERTEX person(name, age2) VALUES hash($-,name):(\"a\", 19);";
+        ASSERT_FALSE(checkResult(cmd, {}));
+    }
+    // vid use function call
+    {
+        auto cmd = "INSERT VERTEX person(name, age) VALUES lower(\"TOM\"):(\"a\", 19);";
+        ASSERT_TRUE(checkResult(cmd, { PK::kInsertVertices, PK::kStart }));
+    }
 }
 
 TEST_F(MutateValidatorTest, InsertEdgeTest) {
@@ -27,6 +37,16 @@ TEST_F(MutateValidatorTest, InsertEdgeTest) {
         auto cmd = "INSERT EDGE like(start, end2) VALUES \"A\"->\"B\":(11, 11);";
         ASSERT_FALSE(checkResult(cmd, {}));
     }
+    // wrong vid expression
+    {
+        auto cmd = "INSERT EDGE like(start, end) VALUES hash($-,name)->\"Tom\":(2010, 2020);";
+        ASSERT_FALSE(checkResult(cmd, {}));
+    }
+    // vid use function call
+    {
+        auto cmd = "INSERT EDGE like(start, end) VALUES lower(\"Lily\")->\"Tom\":(2010, 2020);";
+        ASSERT_TRUE(checkResult(cmd, { PK::kInsertEdges, PK::kStart }));
+    }
 }
 
 TEST_F(MutateValidatorTest, DeleteVertexTest) {
@@ -110,5 +130,76 @@ TEST_F(MutateValidatorTest, DeleteEdgeTest) {
         ASSERT_FALSE(checkResult(cmd));
     }
 }
+
+TEST_F(MutateValidatorTest, UpdateVertexTest) {
+    // not exist tag
+    {
+        auto cmd = "UPDATE VERTEX ON student \"Tom\" SET count = 1";
+        ASSERT_FALSE(checkResult(cmd, {}));
+    }
+    // multi tags
+    {
+        auto cmd = "UPDATE VERTEX \"Tom\" SET person.count = 1, student.age = $^.student.age + 1";
+        ASSERT_FALSE(checkResult(cmd, {}));
+    }
+    // wrong expr
+    {
+        auto cmd = "UPDATE VERTEX \"Tom\" SET person.age = person.age + 1";
+        ASSERT_FALSE(checkResult(cmd, {}));
+    }
+    // with function
+    {
+        auto cmd = "UPDATE VERTEX ON person \"Tom\" SET age = abs(age + 1)";
+        ASSERT_TRUE(checkResult(cmd, {}));
+    }
+    // 1.0 syntax succeed
+    {
+        auto cmd = "UPDATE VERTEX \"Tom\""
+                   "SET person.age = $^.person.age + 1 "
+                   "WHEN $^.person.age == 18 "
+                   "YIELD $^.person.name AS name, $^.person.age AS age";
+        ASSERT_TRUE(checkResult(cmd, {PK::kUpdateVertex, PK::kStart}));
+    }
+    // 2.0 syntax succeed
+    {
+        auto cmd = "UPDATE VERTEX ON person \"Tom\""
+                   "SET age = age + 1 "
+                   "WHEN page == 18 "
+                   "YIELD name AS name, age AS age";
+        ASSERT_TRUE(checkResult(cmd, {PK::kUpdateVertex, PK::kStart}));
+    }
+}
+
+TEST_F(MutateValidatorTest, UpdateEdgeTest) {
+    // not exist edge
+    {
+        auto cmd = "UPDATE EDGE ON study \"Tom\"->\"Lily\" SET count = 1";
+        ASSERT_FALSE(checkResult(cmd, {}));
+    }
+    // Wrong expr "$^.peson.age"
+    {
+        auto cmd = "UPDATE EDGE \"Tom\"->\"Lily\" OF like "
+                   "SET end = like.end + 1 "
+                   "WHEN $^.peson.age >= 18 "
+                   "YIELD $^.peson.age AS age, like.end AS end";
+        ASSERT_FALSE(checkResult(cmd, {}));
+    }
+    // 1.0 syntax succeed
+    {
+        auto cmd = "UPDATE EDGE \"Tom\"->\"Lily\" OF like "
+                   "SET end = like.end + 1 "
+                   "WHEN like.start >= 2010 "
+                   "YIELD like.start AS start, like.end AS end";
+        ASSERT_TRUE(checkResult(cmd, {PK::kUpdateEdge, PK::kUpdateEdge, PK::kStart}));
+    }
+    // 2.0 syntax succeed
+    {
+        auto cmd = "UPDATE EDGE ON like \"Tom\"->\"Lily\""
+                   "SET end = end + 1 "
+                   "WHEN start >= 2010 "
+                   "YIELD start AS start, end AS end";
+        ASSERT_TRUE(checkResult(cmd, {PK::kUpdateEdge, PK::kUpdateEdge, PK::kStart}));
+    }
+}
 }  // namespace graph
 }  // namespace nebula

src/validator/test/ValidatorTestBase.cpp

@@ -81,6 +81,8 @@ namespace graph {
         case PlanNode::Kind::kDropSnapshot:
         case PlanNode::Kind::kShowSnapshots:
         case PlanNode::Kind::kDataJoin:
+        case PlanNode::Kind::kUpdateVertex:
+        case PlanNode::Kind::kUpdateEdge:
             LOG(FATAL) << "Unimplemented";
         case PlanNode::Kind::kDataCollect: {
             const auto *lDC = static_cast<const DataCollect*>(l);

src/validator/test/ValidatorTestBase.h

@@ -188,7 +188,9 @@ protected:
                 case PlanNode::Kind::kShowSnapshots:
                 case PlanNode::Kind::kDataJoin:
                 case PlanNode::Kind::kDeleteVertices:
-                case PlanNode::Kind::kDeleteEdges: {
+                case PlanNode::Kind::kDeleteEdges:
+                case PlanNode::Kind::kUpdateVertex:
+                case PlanNode::Kind::kUpdateEdge: {
                     auto* current = static_cast<const SingleInputNode*>(node);
                     queue.emplace(current->dep());
                     break;