delete labeltagpropertyexpression file

vesoft-inc · Dec 6, 2021 · 0f5d679 · 0f5d679
1 parent 6e6ffc0
commit 0f5d679
Show file tree

Hide file tree

Showing 13 changed files with 90 additions and 211 deletions.
diff --git a/src/common/expression/ExprVisitor.h b/src/common/expression/ExprVisitor.h
@@ -18,7 +18,6 @@
 #include "common/expression/FunctionCallExpression.h"
 #include "common/expression/LabelAttributeExpression.h"
 #include "common/expression/LabelExpression.h"
-#include "common/expression/LabelTagPropertyExpression.h"
 #include "common/expression/ListComprehensionExpression.h"
 #include "common/expression/LogicalExpression.h"
 #include "common/expression/PathBuildExpression.h"

diff --git a/src/common/expression/Expression.cpp b/src/common/expression/Expression.cpp
@@ -19,7 +19,6 @@
 #include "common/expression/FunctionCallExpression.h"
 #include "common/expression/LabelAttributeExpression.h"
 #include "common/expression/LabelExpression.h"
-#include "common/expression/LabelTagPropertyExpression.h"
 #include "common/expression/ListComprehensionExpression.h"
 #include "common/expression/LogicalExpression.h"
 #include "common/expression/PathBuildExpression.h"
@@ -390,7 +389,6 @@ Expression* Expression::decode(ObjectPool* pool, Expression::Decoder& decoder) {
       return exp;
     }
     case Expression::Kind::kVarProperty: {
-      // LOG(FATAL) << "Should not decode variable property expression";
       exp = VariablePropertyExpression::make(pool);
       exp->resetFrom(decoder);
       return exp;

diff --git a/src/common/expression/LabelTagPropertyExpression.cpp b/src/common/expression/LabelTagPropertyExpression.cpp
diff --git a/src/common/expression/LabelTagPropertyExpression.h b/src/common/expression/LabelTagPropertyExpression.h
diff --git a/src/common/expression/PropertyExpression.h b/src/common/expression/PropertyExpression.h
@@ -139,6 +139,8 @@ class LabelTagPropertyExpression final : public PropertyExpression {
 
   const Expression* label() const { return label_; }
 
+  Expression* label() { return label_; }
+
  private:
   LabelTagPropertyExpression(ObjectPool* pool,
                              Expression* label = nullptr,

diff --git a/src/graph/planner/match/LabelIndexSeek.cpp b/src/graph/planner/match/LabelIndexSeek.cpp
@@ -91,11 +91,11 @@ StatusOr<SubPlan> LabelIndexSeek::transformNode(NodeContext* nodeCtx) {
     const auto& nodeAlias = nodeCtx->info->alias;
 
     if (filter->kind() == Expression::Kind::kLogicalOr) {
-      auto labelExprs = ExpressionUtils::collectAll(filter, {Expression::Kind::kLabel});
+      auto exprs = ExpressionUtils::collectAll(filter, {Expression::Kind::kLabelTagProperty});
       bool labelMatched = true;
-      for (auto* labelExpr : labelExprs) {
-        DCHECK_EQ(labelExpr->kind(), Expression::Kind::kLabel);
-        if (static_cast<const LabelExpression*>(labelExpr)->name() != nodeAlias) {
+      for (auto* expr : exprs) {
+        auto tagPropExpr = static_cast<const LabelTagPropertyExpression*>(expr);
+        if (static_cast<const PropertyExpression*>(tagPropExpr->label())->prop() != nodeAlias) {
           labelMatched = false;
           break;
         }
@@ -117,9 +117,8 @@ StatusOr<SubPlan> LabelIndexSeek::transformNode(NodeContext* nodeCtx) {
           }
         }
         if (canBeEmbedded2IndexScan) {
-          auto* srcFilter = ExpressionUtils::rewriteAttr2LabelTagProp(flattenFilter);
           storage::cpp2::IndexQueryContext ctx;
-          ctx.set_filter(Expression::encode(*srcFilter));
+          ctx.set_filter(Expression::encode(*flattenFilter));
           scan->setIndexQueryContext({ctx});
           whereCtx.reset();
         }

diff --git a/src/graph/planner/match/MatchSolver.cpp b/src/graph/planner/match/MatchSolver.cpp
@@ -78,8 +78,7 @@ Expression* MatchSolver::doRewrite(QueryContext* qctx,
     auto alias = aliases.find(labelExpr->name());
     DCHECK(alias != aliases.end());
   }
-  auto res = ExpressionUtils::rewriteAttr2LabelTagProp(expr);
-  return rewriteLabel2VarProp(qctx, res);
+  return rewriteLabel2VarProp(qctx, expr);
 }
 
 Expression* MatchSolver::makeIndexFilter(const std::string& label,
@@ -162,27 +161,23 @@ Expression* MatchSolver::makeIndexFilter(const std::string& label,
       }
       propName = la->right()->value().getStr();
     } else {
-      const AttributeExpression* la = nullptr;
-      if (left->kind() == Expression::Kind::kAttribute &&
+      const LabelTagPropertyExpression* la = nullptr;
+      if (left->kind() == Expression::Kind::kLabelTagProperty &&
           right->kind() == Expression::Kind::kConstant) {
-        la = static_cast<const AttributeExpression*>(left);
+        la = static_cast<const LabelTagPropertyExpression*>(left);
         constant = static_cast<const ConstantExpression*>(right);
-      } else if (right->kind() == Expression::Kind::kAttribute &&
+      } else if (right->kind() == Expression::Kind::kLabelTagProperty &&
                  left->kind() == Expression::Kind::kConstant) {
-        la = static_cast<const AttributeExpression*>(right);
+        la = static_cast<const LabelTagPropertyExpression*>(right);
         constant = static_cast<const ConstantExpression*>(left);
       } else {
         continue;
       }
-      if (la->left()->kind() != Expression::Kind::kLabelAttribute) {
+      if (static_cast<const PropertyExpression*>(la->label())->prop() != alias ||
+          la->sym() != label) {
         continue;
       }
-      auto labelAttExpr = static_cast<const LabelAttributeExpression*>(la->left());
-      if (labelAttExpr->left()->name() != alias ||
-          labelAttExpr->right()->value().getStr() != label) {
-        continue;
-      }
-      propName = static_cast<const ConstantExpression*>(la->right())->value().getStr();
+      propName = la->prop();
     }
 
     auto* tpExpr =

diff --git a/src/graph/validator/MatchValidator.cpp b/src/graph/validator/MatchValidator.cpp
@@ -270,7 +270,7 @@ Status MatchValidator::validateFilter(const Expression *filter,
   auto transformRes = ExpressionUtils::filterTransform(filter);
   NG_RETURN_IF_ERROR(transformRes);
   // rewrite Attribute to LabelTagProperty
-  whereClauseCtx.filter = transformRes.value();
+  whereClauseCtx.filter = ExpressionUtils::rewriteAttr2LabelTagProp(transformRes.value());
 
   auto typeStatus = deduceExprType(whereClauseCtx.filter);
   NG_RETURN_IF_ERROR(typeStatus);
@@ -364,7 +364,7 @@ Status MatchValidator::validateReturn(MatchReturn *ret,
           ExpressionUtils::hasAny(column->expr(), {Expression::Kind::kAggregate})) {
         retClauseCtx.yield->hasAgg_ = true;
       }
-      // column->setExpr(ExpressionUtils::rewriteAttr2LabelTagProp(column->expr()));
+      column->setExpr(ExpressionUtils::rewriteAttr2LabelTagProp(column->expr()));
       exprs.push_back(column->expr());
       columns->addColumn(column->clone().release());
     }
@@ -397,7 +397,6 @@ Status MatchValidator::validateAliases(
   static const std::unordered_set<Expression::Kind> kinds = {Expression::Kind::kLabel,
                                                              Expression::Kind::kLabelAttribute,
                                                              Expression::Kind::kLabelTagProperty,
-                                                             Expression::Kind::kAttribute,
                                                              // primitive props
                                                              Expression::Kind::kEdgeSrc,
                                                              Expression::Kind::kEdgeDst,
@@ -452,11 +451,13 @@ Status MatchValidator::validateWith(const WithClause *with,
   exprs.reserve(withClauseCtx.yield->yieldColumns->size());
   for (auto *col : withClauseCtx.yield->yieldColumns->columns()) {
     auto labelExprs = ExpressionUtils::collectAll(col->expr(), {Expression::Kind::kLabel});
+    auto aliasType = AliasType::kDefault;
     for (auto *labelExpr : labelExprs) {
       auto label = static_cast<const LabelExpression *>(labelExpr)->name();
       if (!withClauseCtx.yield->aliasesUsed || !withClauseCtx.yield->aliasesUsed->count(label)) {
         return Status::SemanticError("Variable `%s` not defined", label.c_str());
       }
+      aliasType = withClauseCtx.yield->aliasesUsed->at(label);
     }
     if (col->alias().empty()) {
       if (col->expr()->kind() == Expression::Kind::kLabel) {
@@ -465,7 +466,7 @@ Status MatchValidator::validateWith(const WithClause *with,
         return Status::SemanticError("Expression in WITH must be aliased (use AS)");
       }
     }
-    if (!withClauseCtx.aliasesGenerated.emplace(col->alias(), AliasType::kDefault).second) {
+    if (!withClauseCtx.aliasesGenerated.emplace(col->alias(), aliasType).second) {
       return Status::SemanticError("`%s': Redefined alias", col->alias().c_str());
     }
     if (!withClauseCtx.yield->hasAgg_ &&
@@ -795,25 +796,13 @@ Status MatchValidator::checkAlias(
       NG_RETURN_IF_ERROR(res);
       return Status::OK();
     }
-      //    case Expression::Kind::kLabelTagProperty: {
-      //  auto labelExpr = static_cast<const LabelTagPropertyExpression *>(refExpr)->label();
-      //  auto name = static_cast<const VariablePropertyExpression *>(labelExpr)->prop();
-      //  auto res = getAliasType(aliasesUsed, name);
-      //  NG_RETURN_IF_ERROR(res);
-      //  if (res.value() != AliasType::kNode) {
-      //  return Status::SemanticError("The type of `%s' must be tag", name.c_str());
-      //  }
-      //  return Status::OK();
-    //  }
-    case Expression::Kind::kAttribute: {
-      auto leftExpr = static_cast<const AttributeExpression *>(refExpr)->left();
-      if (leftExpr->kind() == Expression::Kind::kLabelAttribute) {
-        auto name = static_cast<const LabelAttributeExpression *>(leftExpr)->left()->name();
-        auto res = getAliasType(aliasesUsed, name);
-        NG_RETURN_IF_ERROR(res);
-        if (res.value() != AliasType::kNode) {
-          return Status::SemanticError("The type of `%s' should be tag", name.c_str());
-        }
+    case Expression::Kind::kLabelTagProperty: {
+      auto labelExpr = static_cast<const LabelTagPropertyExpression *>(refExpr)->label();
+      auto name = static_cast<const VariablePropertyExpression *>(labelExpr)->prop();
+      auto res = getAliasType(aliasesUsed, name);
+      NG_RETURN_IF_ERROR(res);
+      if (res.value() != AliasType::kNode) {
+        return Status::SemanticError("The type of `%s' should be tag", name.c_str());
       }
       return Status::OK();
     }

diff --git a/src/graph/visitor/FindVisitor.cpp b/src/graph/visitor/FindVisitor.cpp
@@ -135,8 +135,6 @@ void FindVisitor::visit(EdgePropertyExpression* expr) { findInCurrentExpr(expr);
 
 void FindVisitor::visit(TagPropertyExpression* expr) { findInCurrentExpr(expr); }
 
-void FindVisitor::visit(LabelTagPropertyExpression* expr) { findInCurrentExpr(expr); }
-
 void FindVisitor::visit(InputPropertyExpression* expr) { findInCurrentExpr(expr); }
 
 void FindVisitor::visit(VariablePropertyExpression* expr) { findInCurrentExpr(expr); }
@@ -169,6 +167,12 @@ void FindVisitor::visit(LabelAttributeExpression* expr) {
   expr->right()->accept(this);
 }
 
+void FindVisitor::visit(LabelTagPropertyExpression* expr) {
+  findInCurrentExpr(expr);
+  if (!needFindAll_ && !foundExprs_.empty()) return;
+  expr->label()->accept(this);
+}
+
 void FindVisitor::visit(VertexExpression* expr) { findInCurrentExpr(expr); }
 
 void FindVisitor::visit(EdgeExpression* expr) { findInCurrentExpr(expr); }

diff --git a/tests/tck/features/expression/Attribute.feature b/tests/tck/features/expression/Attribute.feature
@@ -149,9 +149,13 @@ Feature: Attribute
       """
       MATCH (v) WHERE id(v) == 'Tim Duncan' RETURN v.name.not_exists_attr
       """
-    Then a ExecutionError should be raised at runtime: TagName `name'  is nonexistent
+    Then the result should be, in any order:
+      | v.name.not_exists_attr |
+      | NULL                   |
     When executing query:
       """
       MATCH (v) WHERE id(v) == 'Tim Duncan' RETURN v.player.name.test
       """
-    Then a SemanticError should be raised at runtime: `v.player.name.ab', expected type with attribute like Date, Time, DateTime, Map, Vertex or Edge but was STRING: v.player.name
+    Then the result should be, in any order:
+      | v.player.name.test |
+      | BAD_TYPE           |
diff --git a/tests/tck/features/match/SameTagPropname.feature b/tests/tck/features/match/SameTagPropname.feature
@@ -203,10 +203,12 @@ Feature: Same Tag Propname
       """
       match (v:player) where v.student.height > 190 return v
       """
-    Then a SemanticError should be raised at runtime: `v.student.height', not found the property `height'
+    Then the result should be, in any order:
+      | v |
     When executing query:
       """
       match (v:player) where v.abc.height > 190 return v.player.name
       """
-    Then a ExecutionError should be raised at runtime: TagName `abc'  is nonexistent
+    Then the result should be, in any order:
+      | v.player.name |
     Then drop the used space