fix error

src/graph/context/ast/QueryAstContext.h

@@ -146,7 +146,7 @@ struct FetchEdgesContext final : public AstContext {
 
   ExpressionProps exprProps;
   YieldColumns* yieldExpr{nullptr};
-
+  std::string edgeName;
   bool distinct{false};
   // store the result of the previous sentence
   std::string inputVarName;

src/graph/planner/ngql/FetchEdgesPlanner.cpp

@@ -5,18 +5,12 @@
  */
 
 #include "graph/planner/ngql/FetchEdgesPlanner.h"
-
-#include "graph/util/ExpressionUtils.h"
-#include "graph/util/QueryUtil.h"
-#include "graph/util/SchemaUtil.h"
-#include "graph/validator/Validator.h"
-
 namespace nebula {
 namespace graph {
 
 std::unique_ptr<FetchEdgesPlanner::EdgeProps> FetchEdgesPlanner::buildEdgeProps() {
   auto eProps = std::make_unique<EdgeProps>();
-  auto edgePropsMap = fetchCtx_->exprProps.edgeProps();
+  const auto &edgePropsMap = fetchCtx_->exprProps.edgeProps();
   for (const auto &edgeProp : edgePropsMap) {
     EdgeProp ep;
     ep.set_type(edgeProp.first);
@@ -26,6 +20,22 @@ std::unique_ptr<FetchEdgesPlanner::EdgeProps> FetchEdgesPlanner::buildEdgeProps(
   return eProps;
 }
 
+Expression *FetchEdgesPlanner::emptyEdgeFilter() {
+  auto *pool = fetchCtx_->qctx->objPool();
+  const auto &edgeName = fetchCtx_->edgeName;
+  auto notEmpty = [&pool](Expression *expr) {
+    return RelationalExpression::makeNE(pool, ConstantExpression::make(pool, Value::kEmpty), expr);
+  };
+  auto exprAnd = [&pool](Expression *left, Expression *right) {
+    return LogicalExpression::makeAnd(pool, left, right);
+  };
+
+  auto *srcNotEmpty = notEmpty(EdgeSrcIdExpression::make(pool, edgeName));
+  auto *dstNotEmpty = notEmpty(EdgeDstIdExpression::make(pool, edgeName));
+  auto *rankNotEmpty = notEmpty(EdgeRankExpression::make(pool, edgeName));
+  return exprAnd(srcNotEmpty, exprAnd(dstNotEmpty, rankNotEmpty));
+}
+
 StatusOr<SubPlan> FetchEdgesPlanner::transform(AstContext *astCtx) {
   fetchCtx_ = static_cast<FetchEdgesContext *>(astCtx);
   auto qctx = fetchCtx_->qctx;
@@ -44,7 +54,9 @@ StatusOr<SubPlan> FetchEdgesPlanner::transform(AstContext *astCtx) {
                                   fetchCtx_->distinct);
   getEdges->setInputVar(fetchCtx_->inputVarName);
 
-  subPlan.root = Project::make(qctx, getEdges, fetchCtx_->yieldExpr);
+  subPlan.root = Filter::make(qctx, getEdges, emptyEdgeFilter());
+
+  subPlan.root = Project::make(qctx, subPlan.root, fetchCtx_->yieldExpr);
   if (fetchCtx_->distinct) {
     subPlan.root = Dedup::make(qctx, subPlan.root);
   }

src/graph/planner/ngql/FetchEdgesPlanner.h

@@ -32,6 +32,8 @@ class FetchEdgesPlanner final : public Planner {
 
   std::unique_ptr<EdgeProps> buildEdgeProps();
 
+  Expression* emptyEdgeFilter();
+
  private:
   FetchEdgesPlanner() = default;
 

src/graph/validator/FetchEdgesValidator.cpp

@@ -15,12 +15,16 @@ namespace nebula {
 namespace graph {
 
 Status FetchEdgesValidator::validateImpl() {
-  auto *fsentence = static_cast<FetchEdgesSentence *>(sentence_);
-  edgeName_ = fsentence->edgeName();
+  auto *sentence = static_cast<FetchEdgesSentence *>(sentence_);
+  if (sentence->edgeSize() != 1) {
+    return Status::SemanticError("only allow fetch on one edge");
+  }
+  edgeName_ = sentence->edgeName();
+  fetchCtx_->edgeName = edgeName_;
   fetchCtx_ = getContext<FetchEdgesContext>();
   NG_RETURN_IF_ERROR(validateEdgeName());
   NG_RETURN_IF_ERROR(validateEdgeKey());
-  NG_RETURN_IF_ERROR(validateYield(fsentence->yieldClause()));
+  NG_RETURN_IF_ERROR(validateYield(sentence->yieldClause()));
   return Status::OK();
 }
 
@@ -40,7 +44,7 @@ StatusOr<std::string> FetchEdgesValidator::validateEdgeRef(const Expression *exp
                                                            Value::Type type) {
   const auto &kind = expr->kind();
   if (kind != Expression::Kind::kInputProperty && kind != EdgeExpression::Kind::kVarProperty) {
-    return Status::SemanticError("`%s', Only input and variable expression is acceptable",
+    return Status::SemanticError("`%s', only input and variable expression is acceptable",
                                  expr->toString().c_str());
   }
   auto exprType = deduceExprType(expr);
@@ -74,15 +78,19 @@ Status FetchEdgesValidator::validateEdgeKey() {
       result = validateEdgeRef(rankExpr, Value::Type::INT);
       NG_RETURN_IF_ERROR(result);
       if (inputVarName != result.value()) {
-        return Status::SemanticError("Can't refer to different variable as key at same time.");
+        return Status::SemanticError(
+            "`%s' the src dst and rank of the edge must use the same reference.",
+            rankExpr->toString().c_str());
       }
     }
 
     auto *dstExpr = sentence->ref()->dstid();
     result = validateEdgeRef(dstExpr, vidType_);
     NG_RETURN_IF_ERROR(result);
     if (inputVarName != result.value()) {
-      return Status::SemanticError("Can't refer to different variable as key at same time.");
+      return Status::SemanticError(
+          "`%s' the src dst and rank of the edge must use the same reference.",
+          dstExpr->toString().c_str());
     }
     fetchCtx_->src = srcExpr;
     fetchCtx_->dst = dstExpr;
@@ -107,6 +115,7 @@ Status FetchEdgesValidator::validateEdgeKey() {
       return Status::SemanticError(ss.str());
     }
     auto ranking = key->rank();
+
     if (!evaluableExpr(key->dstid())) {
       return Status::SemanticError("`%s' is not evaluable.", key->dstid()->toString().c_str());
     }
@@ -142,29 +151,20 @@ void FetchEdgesValidator::extractEdgeProp(ExpressionProps &exprProps) {
 
 Status FetchEdgesValidator::validateYield(const YieldClause *yield) {
   auto pool = qctx_->objPool();
-  fetchCtx_->distinct = yield->isDistinct();
-  bool existEdge = false;
+  bool noYield = false;
   if (yield == nullptr) {
     // TODO: compatible with previous version, this will be deprecated in version 3.0.
     auto *yieldColumns = new YieldColumns();
-    auto *edge = new YieldColumn(EdgeExpression::make(pool));
+    auto *edge = new YieldColumn(EdgeExpression::make(pool), "edges_");
     yieldColumns->addColumn(edge);
     yield = pool->add(new YieldClause(yieldColumns));
-    existEdge = true;
-  }
-  for (const auto &col : yield->columns()) {
-    if (col->expr()->kind() == Expression::Kind::kEdge) {
-      existEdge = true;
-      break;
-    }
-    // TODO return error when yield vertex
+    noYield = true;
   }
-  auto size = yield->columns().size();
-  outputs_.reserve(size + 3);
+  fetchCtx_->distinct = yield->isDistinct();
 
-  ExpressionProps exprProps;
+  auto &exprProps = fetchCtx_->exprProps;
   auto *newCols = pool->add(new YieldColumns());
-  if (!existEdge) {
+  if (!noYield) {
     auto *src = new YieldColumn(EdgeSrcIdExpression::make(pool, edgeName_));
     auto *dst = new YieldColumn(EdgeDstIdExpression::make(pool, edgeName_));
     auto *rank = new YieldColumn(EdgeRankExpression::make(pool, edgeName_));
@@ -177,18 +177,30 @@ Status FetchEdgesValidator::validateYield(const YieldClause *yield) {
     exprProps.insertEdgeProp(edgeType_, kSrc);
     exprProps.insertEdgeProp(edgeType_, kDst);
     exprProps.insertEdgeProp(edgeType_, kRank);
-  } else {
-    extractEdgeProp(exprProps);
   }
 
+  for (const auto &col : yield->columns()) {
+    if (ExpressionUtils::hasAny(col->expr(), {Expression::Kind::kEdge})) {
+      extractEdgeProp(exprProps);
+      break;
+    }
+  }
+  auto size = yield->columns().size();
+  outputs_.reserve(size + 3);
+
   for (auto col : yield->columns()) {
+    if (ExpressionUtils::hasAny(col->expr(),
+                                {Expression::Kind::kVertex, Expression::Kind::kPathBuild})) {
+      return Status::SemanticError("illegal yield clauses `%s'", col->toString().c_str());
+    }
     col->setExpr(ExpressionUtils::rewriteLabelAttr2EdgeProp(col->expr()));
     NG_RETURN_IF_ERROR(ValidateUtil::invalidLabelIdentifiers(col->expr()));
 
     auto colExpr = col->expr();
     auto typeStatus = deduceExprType(colExpr);
     NG_RETURN_IF_ERROR(typeStatus);
     outputs_.emplace_back(col->name(), typeStatus.value());
+    newCols->addColumn(col->clone().release());
 
     NG_RETURN_IF_ERROR(deduceProps(colExpr, exprProps));
   }
@@ -203,10 +215,10 @@ Status FetchEdgesValidator::validateYield(const YieldClause *yield) {
 
   for (const auto &edge : exprProps.edgeProps()) {
     if (edge.first != edgeType_) {
-      return Status::SemanticError("MisMatch edge name");
+      return Status::SemanticError("should use edge name `%s'", edgeName_.c_str());
     }
   }
-
+  fetchCtx_->yieldExpr = newCols;
   return Status::OK();
 }
 

src/graph/validator/FetchEdgesValidator.h

@@ -31,6 +31,8 @@ class FetchEdgesValidator final : public Validator {
 
   Status validateYield(const YieldClause* yieldClause);
 
+  AstContext* getAstContext() override { return fetchCtx_.get(); }
+
  private:
   std::string edgeName_;
 

src/parser/TraverseSentences.h

@@ -261,16 +261,16 @@ class FetchVerticesSentence final : public Sentence {
 
 class FetchEdgesSentence final : public Sentence {
  public:
-  FetchEdgesSentence(const std::string& edgeName, EdgeKeys* keys, YieldClause* clause) {
+  FetchEdgesSentence(NameLabelList* edge, EdgeKeys* keys, YieldClause* clause) {
     kind_ = Kind::kFetchEdges;
-    edgeName_ = edgeName;
+    edge_.reset(edge);
     edgeKeys_.reset(keys);
     yieldClause_.reset(clause);
   }
 
-  FetchEdgesSentence(const std::string& edgeName, EdgeKeyRef* ref, YieldClause* clause) {
+  FetchEdgesSentence(NameLabelList* edge, EdgeKeyRef* ref, YieldClause* clause) {
     kind_ = Kind::kFetchEdges;
-    edgeName_ = edgeName;
+    edge_.reset(edge);
     keyRef_.reset(ref);
     yieldClause_.reset(clause);
   }
@@ -289,12 +289,14 @@ class FetchEdgesSentence final : public Sentence {
 
   YieldClause* yieldClause() const { return yieldClause_.get(); }
 
-  std::string edgeName() const { return edgeName_; }
+  std::string edgeName() const { return *edge_->front(); }
+
+  std::size_t edgeSize() const { return edge_->size(); }
 
   std::string toString() const override;
 
  private:
-  std::string edgeName_;
+  std::unique_ptr<NameLabelList> edge_;
   std::unique_ptr<EdgeKeys> edgeKeys_;
   std::unique_ptr<EdgeKeyRef> keyRef_;
   std::unique_ptr<YieldClause> yieldClause_;

src/parser/parser.yy

@@ -1985,14 +1985,12 @@ edge_key_ref
     ;
 
 fetch_edges_sentence
-    : KW_FETCH KW_PROP KW_ON name_label edge_keys yield_clause {
-        auto fetch = new FetchEdgesSentence(*$4, $5, $6);
-        delete $4;
+    : KW_FETCH KW_PROP KW_ON name_label_list edge_keys yield_clause {
+        auto fetch = new FetchEdgesSentence($4, $5, $6);
         $$ = fetch;
     }
-    | KW_FETCH KW_PROP KW_ON name_label edge_key_ref yield_clause {
-        auto fetch = new FetchEdgesSentence(*$4, $5, $6);
-        delete $4;
+    | KW_FETCH KW_PROP KW_ON name_label_list edge_key_ref yield_clause {
+        auto fetch = new FetchEdgesSentence($4, $5, $6);
         $$ = fetch;
     }
     ;

tests/tck/features/delete/DeleteEdge.IntVid.feature

@@ -2,6 +2,7 @@
 #
 # This source code is licensed under Apache 2.0 License,
 # attached with Common Clause Condition 1.0, found in the LICENSES directory.
+@jmq
 Feature: Delete int vid of edge
 
   Scenario: delete edges

tests/tck/features/delete/DeleteTag.IntVid.feature

@@ -2,7 +2,6 @@
 #
 # This source code is licensed under Apache 2.0 License,
 # attached with Common Clause Condition 1.0, found in the LICENSES directory.
-@jmq
 Feature: Delete int vid of tag
 
   Scenario: delete int vid one vertex one tag

tests/tck/features/fetch/FetchEdges.strVid.feature

@@ -1,3 +1,4 @@
+@jmq
 Feature: Fetch String Vid Edges
 
   Background: