add sentences of DELETE and FIND (vesoft-inc#220)

src/parser/MutateSentences.cpp

@@ -3,7 +3,6 @@
  * This source code is licensed under Apache 2.0 License
  *  (found in the LICENSE.Apache file in the root directory)
  */
-
 #include "base/Base.h"
 #include "parser/MutateSentences.h"
 
@@ -139,4 +138,41 @@ std::string UpdateEdgeSentence::toString() const {
     return buf;
 }
 
+std::string DeleteVertexSentence::toString() const {
+    std::string buf;
+    buf.reserve(256);
+    buf += "DELETE VERTEX ";
+    buf += srcNodeList_->toString();
+    if (whereClause_ != nullptr) {
+        buf += " ";
+        buf += whereClause_->toString();
+    }
+    return buf;
+}
+
+std::string EdgeList::toString() const {
+    std::string buf;
+    buf.reserve(256);
+    for (auto edge : edges_) {
+        buf += std::to_string(edge.first);
+        buf += "->";
+        buf += std::to_string(edge.second);
+        buf += ",";
+    }
+    buf.resize(buf.size() - 1);
+    return buf;
+}
+
+std::string DeleteEdgeSentence::toString() const {
+    std::string buf;
+    buf.reserve(256);
+    buf += "DELETE EDGE ";
+    buf += edgeList_->toString();
+    if (whereClause_ != nullptr) {
+        buf += " ";
+        buf += whereClause_->toString();
+    }
+    return buf;
+}
+
 }   // namespace nebula

src/parser/MutateSentences.h

@@ -267,6 +267,74 @@ class UpdateEdgeSentence final : public Sentence {
     std::unique_ptr<YieldClause>                yieldClause_;
 };
 
-}   // namespace nebula
+class DeleteVertexSentence final : public Sentence {
+public:
+    explicit DeleteVertexSentence(SourceNodeList *srcNodeList) {
+        srcNodeList_.reset(srcNodeList);
+        kind_ = Kind::kDeleteVertex;
+    }
+
+    SourceNodeList* srcNodeLists() const {
+        return srcNodeList_.get();
+    }
+
+    void setWhereClause(WhereClause *clause) {
+        whereClause_.reset(clause);
+    }
+
+    WhereClause* whereClause() const {
+        return whereClause_.get();
+    }
+
+    std::string toString() const override;
+
+private:
+    std::unique_ptr<SourceNodeList>            srcNodeList_;
+    std::unique_ptr<WhereClause>               whereClause_;
+};
+
+class EdgeList final {
+public:
+    void addEdge(int64_t srcid, int64_t dstid) {
+        edges_.emplace_back(std::make_pair(srcid, dstid));
+    }
+
+    const std::vector<std::pair<int64_t, int64_t>>& edges() const {
+        return edges_;
+    }
+
+    std::string toString() const;
+
+private:
+    std::vector<std::pair<int64_t, int64_t>>    edges_;
+};
+
+class DeleteEdgeSentence final : public Sentence {
+public:
+    explicit DeleteEdgeSentence(EdgeList *edgeList) {
+        edgeList_.reset(edgeList);
+        kind_ = Kind::kDeleteEdge;
+    }
+
+    EdgeList* edgeList() const {
+        return edgeList_.get();
+    }
+
+    void setWhereClause(WhereClause *clause) {
+        whereClause_.reset(clause);
+    }
+
+    WhereClause* whereClause() const {
+        return whereClause_.get();
+    }
+
+    std::string toString() const override;
+
+private:
+    std::unique_ptr<EdgeList>                   edgeList_;
+    std::unique_ptr<WhereClause>                whereClause_;
+};
+
+}  // namespace nebula
 
 #endif  // PARSER_MUTATESENTENCES_H_

src/parser/Sentence.h

@@ -33,6 +33,9 @@ class Sentence {
         kInsertVertex,
         kInsertEdge,
         kShow,
+        kDeleteVertex,
+        kDeleteEdge,
+        kFind,
     };
 
     Kind kind() const {

src/parser/TraverseSentences.cpp

@@ -40,6 +40,20 @@ std::string MatchSentence::toString() const {
     return "MATCH sentence";
 }
 
+std::string FindSentence::toString() const {
+    std::string buf;
+    buf.reserve(256);
+    buf += "FIND ";
+    buf += properties_->toString();
+    buf += " FROM ";
+    buf += *type_;
+    if (whereClause_ != nullptr) {
+        buf += " WHERE ";
+        buf += whereClause_->toString();
+    }
+    return buf;
+}
+
 std::string UseSentence::toString() const {
     return "USE SPACE " + *space_;
 }

src/parser/TraverseSentences.h

@@ -9,6 +9,7 @@
 #include "base/Base.h"
 #include "parser/Sentence.h"
 #include "parser/Clauses.h"
+#include "parser/MutateSentences.h"
 
 namespace nebula {
 
@@ -79,6 +80,39 @@ class MatchSentence final : public Sentence {
 };
 
 
+class FindSentence final : public Sentence {
+public:
+    FindSentence(std::string *type, PropertyList *props) {
+        type_.reset(type);
+        properties_.reset(props);
+        kind_ = Kind::kFind;
+    }
+
+    std::string* type() const {
+        return type_.get();
+    }
+
+    std::vector<std::string*> properties() const {
+        return properties_->properties();
+    }
+
+    void setWhereClause(WhereClause *whereClause) {
+        whereClause_.reset(whereClause);
+    }
+
+    WhereClause* whereClause() const {
+        return whereClause_.get();
+    }
+
+    std::string toString() const override;
+
+private:
+    std::unique_ptr<std::string>                type_;
+    std::unique_ptr<PropertyList>               properties_;
+    std::unique_ptr<WhereClause>                whereClause_;
+};
+
+
 class UseSentence final : public Sentence {
 public:
     explicit UseSentence(std::string *space) {

src/parser/parser.yy

@@ -52,11 +52,12 @@ class GraphScanner;
     nebula::ValueList                      *value_list;
     nebula::UpdateList                     *update_list;
     nebula::UpdateItem                     *update_item;
+    nebula::EdgeList                       *edge_list;
 }
 /* keywords */
 %token KW_GO KW_AS KW_TO KW_OR KW_USE KW_SET KW_FROM KW_WHERE KW_ALTER
 %token KW_MATCH KW_INSERT KW_VALUES KW_YIELD KW_RETURN KW_DEFINE KW_VERTEX KW_TTL
-%token KW_EDGE KW_UPDATE KW_STEPS KW_OVER KW_UPTO KW_REVERSELY KW_SPACE
+%token KW_EDGE KW_UPDATE KW_STEPS KW_OVER KW_UPTO KW_REVERSELY KW_SPACE KW_DELETE KW_FIND
 %token KW_INT KW_BIGINT KW_DOUBLE KW_STRING KW_BOOL KW_TAG KW_UNION KW_INTERSECT KW_MINUS
 %token KW_NO KW_OVERWRITE KW_IN KW_DESCRIBE KW_SHOW KW_HOSTS KW_TIMESTAMP
 /* symbols */
@@ -89,19 +90,20 @@ class GraphScanner;
 %type <value_list> value_list
 %type <update_list> update_list
 %type <update_item> update_item
+%type <edge_list> edge_list
 
 %type <intval> ttl_spec
 
 %type <colspec> column_spec
 %type <colspeclist> column_spec_list
 
-%type <sentence> go_sentence match_sentence use_sentence
+%type <sentence> go_sentence match_sentence use_sentence find_sentence
 %type <sentence> define_tag_sentence define_edge_sentence
 %type <sentence> alter_tag_sentence alter_edge_sentence
 %type <sentence> describe_tag_sentence describe_edge_sentence
 %type <sentence> traverse_sentence set_sentence piped_sentence assignment_sentence
 %type <sentence> maintainance_sentence insert_vertex_sentence insert_edge_sentence
-%type <sentence> mutate_sentence update_vertex_sentence update_edge_sentence
+%type <sentence> mutate_sentence update_vertex_sentence update_edge_sentence delete_vertex_sentence delete_edge_sentence
 %type <sentence> show_sentence
 %type <sentence> sentence
 %type <sentences> sentences
@@ -389,6 +391,14 @@ match_sentence
     : KW_MATCH { $$ = new MatchSentence; }
     ;
 
+find_sentence
+    : KW_FIND prop_list KW_FROM LABEL where_clause {
+        auto sentence = new FindSentence($4, $2);
+        sentence->setWhereClause($5);
+        $$ = sentence;
+    }
+    ;
+
 use_sentence
     : KW_USE KW_SPACE LABEL { $$ = new UseSentence($3); }
     ;
@@ -476,6 +486,7 @@ describe_edge_sentence
 traverse_sentence
     : go_sentence {}
     | match_sentence {}
+    | find_sentence {}
     ;
 
 set_sentence
@@ -672,11 +683,40 @@ show_sentence
     }
     ;
 
+delete_vertex_sentence
+    : KW_DELETE KW_VERTEX id_list where_clause {
+        auto sentence = new DeleteVertexSentence($3);
+        sentence->setWhereClause($4);
+        $$ = sentence;
+    }
+    ;
+
+edge_list
+    : INTEGER R_ARROW INTEGER {
+        $$ = new EdgeList();
+        $$->addEdge($1, $3);
+    }
+    | edge_list COMMA INTEGER R_ARROW INTEGER {
+        $$ = $1;
+        $$->addEdge($3, $5);
+    }
+    ;
+
+delete_edge_sentence
+    : KW_DELETE KW_EDGE edge_list where_clause {
+        auto sentence = new DeleteEdgeSentence($3);
+        sentence->setWhereClause($4);
+        $$ = sentence;
+    }
+    ;
+
 mutate_sentence
     : insert_vertex_sentence {}
     | insert_edge_sentence {}
     | update_vertex_sentence {}
     | update_edge_sentence {}
+    | delete_vertex_sentence {}
+    | delete_edge_sentence {}
     ;
 
 maintainance_sentence

src/parser/scanner.lex

@@ -38,6 +38,8 @@ DESCRIBE                    ([Dd][Ee][Ss][Cc][Rr][Ii][Bb][Ee])
 VERTEX                      ([Vv][Ee][Rr][Tt][Ee][Xx])
 EDGE                        ([Ee][Dd][Gg][Ee])
 UPDATE                      ([Uu][Pp][Dd][Aa][Tt][Ee])
+DELETE                      ([Dd][Ee][Ll][Ee][Tt][Ee])
+FIND                        ([Ff][Ii][Nn][Dd])
 ALTER                       ([Aa][Ll][Tt][Ee][Rr])
 STEPS                       ([Ss][Tt][Ee][Pp][Ss])
 OVER                        ([Oo][Vv][Ee][Rr])
@@ -92,6 +94,8 @@ OCT                         ([0-7])
 {VERTEX}                    { return TokenType::KW_VERTEX; }
 {EDGE}                      { return TokenType::KW_EDGE; }
 {UPDATE}                    { return TokenType::KW_UPDATE; }
+{DELETE}                    { return TokenType::KW_DELETE; }
+{FIND}                      { return TokenType::KW_FIND; }
 {ALTER}                     { return TokenType::KW_ALTER; }
 {STEPS}                     { return TokenType::KW_STEPS; }
 {OVER}                      { return TokenType::KW_OVER; }