implement exist

deps/geax-front-end/include/geax-front-end/ast/AstDumper.h

@@ -1109,9 +1109,7 @@ class AstDumper : public AstNodeVisitor {
     std::any visit(Exists* node) override {
         INDET_GUARD();
         VARIABLE_GUARD_WITH_TYPE_NAME(Exists);
-        auto expr = node->expr();
         auto& path_chains = node->pathChains();
-        VISIT_PARAM_AND_CHECK_WITH_MSG(expr);
         VISIT_PARAM_AND_CHECK_WITH_MSG(path_chains);
         return GEAXErrorCode::GEAX_SUCCEED;
     }

deps/geax-front-end/include/geax-front-end/ast/expr/Exists.h

@@ -19,14 +19,14 @@
 #define GEAXFRONTEND_AST_EXPR_EXISTS_H_
 
 #include "geax-front-end/ast/clause/PathChain.h"
-#include "geax-front-end/ast/expr/UnaryOp.h"
+#include "geax-front-end/ast/expr/Expr.h"
 
 namespace geax {
 namespace frontend {
 
-class Exists : public UnaryOp {
+class Exists : public Expr {
 public:
-    Exists() : UnaryOp(AstNodeType::kExists) {}
+    Exists() : Expr(AstNodeType::kExists) {}
     ~Exists() = default;
 
     void appendPathChain(PathChain* pathChain) { pathChains_.emplace_back(pathChain); }
@@ -46,7 +46,7 @@ class Exists : public UnaryOp {
 inline bool Exists::equals(const Expr& other) const {
     const auto& expr = static_cast<const Exists&>(other);
     // TODO(ljr): PathChain equals
-    bool ret = UnaryOp::equals(other) && pathChains_.size() == expr.pathChains_.size();
+    bool ret = pathChains_.size() == expr.pathChains_.size();
     return ret;
 }
 

src/core/vertex_index.cpp

@@ -38,14 +38,11 @@ inline Value ReturnKeyEvenIfLong(Value&& v) { return std::move(v); }
 
 //  begin of VertexIndexValue
 
-VertexIndexValue::VertexIndexValue()
-    : v_(1) { *(uint8_t*)v_.Data() = 0; }
+VertexIndexValue::VertexIndexValue() : v_(1) { *(uint8_t*)v_.Data() = 0; }
 
-VertexIndexValue::VertexIndexValue(const Value& v)
-    : v_(v) {}
+VertexIndexValue::VertexIndexValue(const Value& v) : v_(v) {}
 
-VertexIndexValue::VertexIndexValue(Value&& v)
-    : v_(std::move(v)) {}
+VertexIndexValue::VertexIndexValue(Value&& v) : v_(std::move(v)) {}
 
 int VertexIndexValue::SearchVid(int64_t vid, bool& found) const {
     if (GetVidCount() == 0) {
@@ -138,15 +135,15 @@ Value VertexIndexValue::CreateKey(const Value& key) const {
 //  begin of VertexIndexIterator
 
 VertexIndexIterator::VertexIndexIterator(VertexIndex* idx, Transaction* txn, KvTable& table,
-                                         const Value& key_start,
-                                         const Value& key_end, VertexId vid, IndexType type)
+                                         const Value& key_start, const Value& key_end, VertexId vid,
+                                         IndexType type)
     : IteratorBase(txn),
       index_(idx),
-      it_(table.GetClosestIterator(txn->GetTxn(),
-                                   type == IndexType::GlobalUniqueIndex ? key_start
-                                   : _detail::PatchKeyWithVid(key_start, vid))),
+      it_(table.GetClosestIterator(txn->GetTxn(), type == IndexType::GlobalUniqueIndex
+                                                      ? key_start
+                                                      : _detail::PatchKeyWithVid(key_start, vid))),
       key_end_(type == IndexType::GlobalUniqueIndex ? Value::MakeCopy(key_end)
-               : _detail::PatchKeyWithVid(key_end, -1)),
+                                                    : _detail::PatchKeyWithVid(key_end, -1)),
       iv_(),
       valid_(false),
       pos_(0),
@@ -161,15 +158,15 @@ VertexIndexIterator::VertexIndexIterator(VertexIndex* idx, Transaction* txn, KvT
 }
 
 VertexIndexIterator::VertexIndexIterator(VertexIndex* idx, KvTransaction* txn, KvTable& table,
-                                         const Value& key_start,
-                                         const Value& key_end, VertexId vid, IndexType type)
+                                         const Value& key_start, const Value& key_end, VertexId vid,
+                                         IndexType type)
     : IteratorBase(nullptr),
       index_(idx),
-      it_(table.GetClosestIterator(
-          *txn, type ==  IndexType::GlobalUniqueIndex ? key_start :
-                                                     _detail::PatchKeyWithVid(key_start, vid))),
-      key_end_(type == IndexType::GlobalUniqueIndex ?
-                  Value::MakeCopy(key_end) : _detail::PatchKeyWithVid(key_end, -1)),
+      it_(table.GetClosestIterator(*txn, type == IndexType::GlobalUniqueIndex
+                                             ? key_start
+                                             : _detail::PatchKeyWithVid(key_start, vid))),
+      key_end_(type == IndexType::GlobalUniqueIndex ? Value::MakeCopy(key_end)
+                                                    : _detail::PatchKeyWithVid(key_end, -1)),
       iv_(),
       valid_(false),
       pos_(0),
@@ -199,8 +196,9 @@ VertexIndexIterator::VertexIndexIterator(VertexIndexIterator&& rhs)
 }
 
 bool VertexIndexIterator::KeyOutOfRange() {
-    if (key_end_.Empty() || (type_ != IndexType::GlobalUniqueIndex
-                             && key_end_.Size() == _detail::VID_SIZE)) return false;
+    if (key_end_.Empty() ||
+        (type_ != IndexType::GlobalUniqueIndex && key_end_.Size() == _detail::VID_SIZE))
+        return false;
     return it_->GetTable().CompareKey(it_->GetTxn(), it_->GetKey(), key_end_) > 0;
 }
 
@@ -272,6 +270,13 @@ bool VertexIndexIterator::Next() {
     return true;
 }
 
+bool VertexIndexIterator::Goto(lgraph::VertexId vid) {
+    if (!it_->GotoClosestKey(curr_key_)) return false;
+    if (KeyOutOfRange()) return false;
+    LoadContentFromIt();
+    return it_->IsValid() && vid == vid_;
+}
+
 Value VertexIndexIterator::GetKey() const {
     switch (type_) {
     case IndexType::GlobalUniqueIndex:
@@ -307,8 +312,7 @@ void VertexIndexIterator::RefreshContentIfKvIteratorModified() {
             }
         case IndexType::NonuniqueIndex:
             {
-                if (!it_->GotoClosestKey(_detail::PatchKeyWithVid(curr_key_, vid_)))
-                    return;
+                if (!it_->GotoClosestKey(_detail::PatchKeyWithVid(curr_key_, vid_))) return;
                 if (KeyOutOfRange()) return;
                 // non-unique, need to find correct pos_
                 iv_ = VertexIndexValue(it_->GetValue());
@@ -329,8 +333,7 @@ void VertexIndexIterator::RefreshContentIfKvIteratorModified() {
 //  begin of VertexIndex
 
 VertexIndex::VertexIndex(std::shared_ptr<KvTable> table, FieldType key_type, IndexType type)
-    : table_(std::move(table)), key_type_(key_type),
-      ready_(false), disabled_(false), type_(type) {}
+    : table_(std::move(table)), key_type_(key_type), ready_(false), disabled_(false), type_(type) {}
 
 VertexIndex::VertexIndex(const VertexIndex& rhs)
     : table_(rhs.table_),
@@ -340,7 +343,8 @@ VertexIndex::VertexIndex(const VertexIndex& rhs)
       type_(rhs.type_) {}
 
 std::unique_ptr<KvTable> VertexIndex::OpenTable(KvTransaction& txn, KvStore& store,
-                                          const std::string& name, FieldType dt, IndexType type) {
+                                                const std::string& name, FieldType dt,
+                                                IndexType type) {
     ComparatorDesc desc;
     switch (type) {
     case IndexType::GlobalUniqueIndex:
@@ -370,7 +374,7 @@ void VertexIndex::_AppendVertexIndexEntry(KvTransaction& txn, const Value& k, Ve
 }
 
 void VertexIndex::_AppendNonUniqueVertexIndexEntry(KvTransaction& txn, const Value& k,
-                                      const std::vector<VertexId>& vids) {
+                                                   const std::vector<VertexId>& vids) {
     FMA_DBG_ASSERT(type_ == IndexType::NonuniqueIndex);
     FMA_DBG_ASSERT(!vids.empty());
     Value key = CutKeyIfLongOnlyForNonUniqueIndex(k);
@@ -385,7 +389,7 @@ void VertexIndex::_AppendNonUniqueVertexIndexEntry(KvTransaction& txn, const Val
 }
 
 void VertexIndex::Dump(KvTransaction& txn,
-          const std::function<std::string(const char* p, size_t s)>& key_to_string) {
+                       const std::function<std::string(const char* p, size_t s)>& key_to_string) {
     auto it = table_->GetIterator(txn);
     for (it->GotoFirstKey(); it->IsValid(); it->Next()) {
         const Value& k = it->GetKey();
@@ -455,8 +459,8 @@ bool VertexIndex::Delete(KvTransaction& txn, const Value& k, int64_t vid) {
     return false;
 }
 
-bool VertexIndex::Update(KvTransaction& txn, const Value& old_key,
-                         const Value& new_key, int64_t vid) {
+bool VertexIndex::Update(KvTransaction& txn, const Value& old_key, const Value& new_key,
+                         int64_t vid) {
     if (!Delete(txn, old_key, vid)) {
         return false;
     }
@@ -556,8 +560,7 @@ size_t VertexIndex::GetMaxVertexIndexKeySize() {
 }
 
 Value VertexIndex::CutKeyIfLongOnlyForNonUniqueIndex(const lgraph::Value& k) {
-    if (type_ != IndexType::NonuniqueIndex)
-        return Value::ConstRef(k);
+    if (type_ != IndexType::NonuniqueIndex) return Value::ConstRef(k);
     size_t key_size = GetMaxVertexIndexKeySize();
     if (k.Size() < key_size) return Value::ConstRef(k);
     return Value(k.Data(), key_size);

src/core/vertex_index.h

@@ -218,6 +218,8 @@ class VertexIndexIterator : public ::lgraph::IteratorBase {
      */
     bool Next();
 
+    bool Goto(VertexId vid);
+
 
     /**
      * Gets the current key.

src/cypher/arithmetic/ast_expr_evaluator.cpp

@@ -55,6 +55,20 @@ cypher::FieldData doCallBuiltinFunc(const std::string& name, cypher::RTContext*
     return data;
 }
 
+const std::string& getNodeOrEdgeName(geax::frontend::AstNode* ast_node) {
+    if (ast_node->type() == geax::frontend::AstNodeType::kNode) {
+        geax::frontend::Node* node = (geax::frontend::Node*)ast_node;
+        if (!node->filler()->v().has_value()) NOT_SUPPORT_AND_THROW();
+        return node->filler()->v().value();
+    } else if (ast_node->type() == geax::frontend::AstNodeType::kEdge) {
+        geax::frontend::Edge* edge = (geax::frontend::Edge*)ast_node;
+        if (!edge->filler()->v().has_value()) NOT_SUPPORT_AND_THROW();
+        return edge->filler()->v().value();
+    } else {
+        NOT_SUPPORT_AND_THROW();
+    }
+}
+
 namespace cypher {
 
 static cypher::FieldData And(const cypher::FieldData& x, const cypher::FieldData& y) {
@@ -534,7 +548,32 @@ std::any cypher::AstExprEvaluator::visit(geax::frontend::IsNull* node) {
 std::any cypher::AstExprEvaluator::visit(geax::frontend::Exists* node) {
     auto path_chains = node->pathChains();
     if (path_chains.size() > 1) NOT_SUPPORT_AND_THROW();
-    NOT_SUPPORT_AND_THROW();
+    auto head = path_chains[0]->head();
+    const std::string head_name = getNodeOrEdgeName(head);
+    auto it_head = sym_tab_->symbols.find(head_name);
+    if (it_head == sym_tab_->symbols.end() || it_head->second.type != SymbolNode::NODE)
+        NOT_SUPPORT_AND_THROW();
+    if (!record_->values[it_head->second.id].CheckEntityEfficient(ctx_))
+        return Entry(cypher::FieldData(lgraph::FieldData(false)));
+
+    auto& tails = path_chains[0]->tails();
+    for (auto& tail : tails) {
+        auto relationship = std::get<0>(tail);
+        const std::string rel_name = getNodeOrEdgeName(relationship);
+        auto it_rel = sym_tab_->symbols.find(rel_name);
+        if (it_rel == sym_tab_->symbols.end() || it_rel->second.type != SymbolNode::RELATIONSHIP)
+            NOT_SUPPORT_AND_THROW();
+        if (!record_->values[it_rel->second.id].CheckEntityEfficient(ctx_))
+            return Entry(cypher::FieldData(lgraph::FieldData(false)));
+        auto neighbor = std::get<1>(tail);
+        const std::string ne_name = getNodeOrEdgeName(neighbor);
+        auto it_ne = sym_tab_->symbols.find(ne_name);
+        if (it_ne == sym_tab_->symbols.end() || it_ne->second.type != SymbolNode::NODE)
+            NOT_SUPPORT_AND_THROW();
+        if (!record_->values[it_ne->second.id].CheckEntityEfficient(ctx_))
+            return Entry(cypher::FieldData(lgraph::FieldData(false)));
+    }
+    return Entry(cypher::FieldData(lgraph::FieldData(true)));
 }
 
 std::any cypher::AstExprEvaluator::reportError() { return error_msg_; }