Handle path build expr. (#392)

* Handle path build expr.

* Test fold constant.

* Address comment.

src/visitor/DeduceTypeVisitor.cpp

@@ -426,6 +426,9 @@ void DeduceTypeVisitor::visitVertexPropertyExpr(PropertyExpression *expr) {
     type_ = SchemaUtil::propTypeToValueType(field->type());
 }
 
+void DeduceTypeVisitor::visit(PathBuildExpression *) {
+    type_ = Value::Type::PATH;
+}
 #undef DETECT_UNARYEXPR_TYPE
 #undef DETECT_BIEXPR_TYPE
 

src/visitor/DeduceTypeVisitor.h

@@ -75,6 +75,8 @@ private:
     void visit(EdgeExpression *expr) override;
     // case expression
     void visit(CaseExpression *expr) override;
+    // path build expression
+    void visit(PathBuildExpression *expr) override;
 
     void visitVertexPropertyExpr(PropertyExpression *expr);
 

src/visitor/ExprVisitorImpl.cpp

@@ -125,5 +125,14 @@ void ExprVisitorImpl::visitBinaryExpr(BinaryExpression *expr) {
     }
 }
 
+void ExprVisitorImpl::visit(PathBuildExpression *expr) {
+    DCHECK(ok());
+    for (auto &item : expr->items()) {
+        item->accept(this);
+        if (!ok()) {
+            break;
+        }
+    }
+}
 }   // namespace graph
 }   // namespace nebula

src/visitor/ExprVisitorImpl.h

@@ -31,6 +31,8 @@ public:
     void visit(MapExpression *expr) override;
     // case expression
     void visit(CaseExpression *expr) override;
+    // path build expression
+    void visit(PathBuildExpression *expr) override;
 
 protected:
     using ExprVisitor::visit;

src/visitor/FoldConstantExprVisitor.cpp

@@ -296,5 +296,22 @@ Expression *FoldConstantExprVisitor::fold(Expression *expr) const {
     return new ConstantExpression(std::move(value));
 }
 
+void FoldConstantExprVisitor::visit(PathBuildExpression *expr) {
+    auto &items = expr->items();
+    bool canBeFolded = true;
+    for (size_t i = 0; i < items.size(); ++i) {
+        auto item = items[i].get();
+        if (isConstant(item)) {
+            continue;
+        }
+        item->accept(this);
+        if (!canBeFolded_) {
+            canBeFolded = false;
+            continue;
+        }
+        expr->setItem(i, std::unique_ptr<Expression>{fold(item)});
+    }
+    canBeFolded_ = canBeFolded;
+}
 }   // namespace graph
 }   // namespace nebula

src/visitor/FoldConstantExprVisitor.h

@@ -59,6 +59,8 @@ public:
     void visit(EdgeExpression *expr) override;
     // case expression
     void visit(CaseExpression *expr) override;
+    // path build expression
+    void visit(PathBuildExpression *expr) override;
 
     void visitBinaryExpr(BinaryExpression *expr);
     Expression *fold(Expression *expr) const;

src/visitor/RewriteInputPropVisitor.cpp

@@ -225,5 +225,14 @@ void RewriteInputPropVisitor::reportError(const Expression* expr) {
     status_ = Status::SemanticError(ss.str());
 }
 
+void RewriteInputPropVisitor::visit(PathBuildExpression* expr) {
+    const auto& items = expr->items();
+    for (size_t i = 0; i < items.size(); ++i) {
+        items[i]->accept(this);
+        if (ok()) {
+            expr->setItem(i, std::move(result_));
+        }
+    }
+}
 }   // namespace graph
 }   // namespace nebula

src/visitor/RewriteInputPropVisitor.h

@@ -70,6 +70,8 @@ private:
     void visit(EdgeExpression *) override;
     // case expression
     void visit(CaseExpression *) override;
+    // path build expression
+    void visit(PathBuildExpression *expr) override;
 
     void visitBinaryExpr(BinaryExpression *expr);
     void visitUnaryExpr(UnaryExpression *expr);

src/visitor/RewriteSymExprVisitor.cpp

@@ -238,5 +238,14 @@ void RewriteSymExprVisitor::visitBinaryExpr(BinaryExpression *expr) {
     }
 }
 
+void RewriteSymExprVisitor::visit(PathBuildExpression *expr) {
+    const auto &items = expr->items();
+    for (size_t i = 0; i < items.size(); ++i) {
+        items[i]->accept(this);
+        if (expr_) {
+            expr->setItem(i, std::move(expr_));
+        }
+    }
+}
 }   // namespace graph
 }   // namespace nebula

src/visitor/RewriteSymExprVisitor.h

@@ -66,6 +66,8 @@ public:
     void visit(EdgeExpression *expr) override;
     // case expression
     void visit(CaseExpression *expr) override;
+    // path build expression
+    void visit(PathBuildExpression *expr) override;
 
 private:
     void visitBinaryExpr(BinaryExpression *expr);

src/visitor/test/FoldConstantExprVisitorTest.cpp

@@ -296,5 +296,15 @@ TEST_F(FoldConstantExprVisitorTest, TestFoldFailed) {
     }
 }
 
+TEST_F(FoldConstantExprVisitorTest, TestPathBuild) {
+    auto expr = pool.makeAndAdd<PathBuildExpression>();
+    expr->add(std::unique_ptr<FunctionCallExpression>(fnExpr("upper", {constantExpr("tom")})));
+    FoldConstantExprVisitor fold;
+    expr->accept(&fold);
+
+    auto expected = pool.makeAndAdd<PathBuildExpression>();
+    expected->add(std::unique_ptr<ConstantExpression>(constantExpr("TOM")));
+    ASSERT_EQ(*expr, *expected);
+}
 }   // namespace graph
 }   // namespace nebula