Fix aggregate expression type deduce

src/graph/validator/test/YieldValidatorTest.cpp

@@ -162,15 +162,11 @@ TEST_F(YieldValidatorTest, TypeCastTest) {
   }
   {
     std::string query = "YIELD (int)\"123abc\"";
-    auto result = checkResult(query);
-    EXPECT_EQ(std::string(result.message()),
-              "SemanticError: `(INT)\"123abc\"' is not a valid expression ");
+    EXPECT_TRUE(checkResult(query));
   }
   {
     std::string query = "YIELD (int)\"abc123\"";
-    auto result = checkResult(query);
-    EXPECT_EQ(std::string(result.message()),
-              "SemanticError: `(INT)\"abc123\"' is not a valid expression ");
+    EXPECT_TRUE(checkResult(query));
   }
   {
     std::string query = "YIELD (doublE)\"123\"";
@@ -182,9 +178,7 @@ TEST_F(YieldValidatorTest, TypeCastTest) {
   }
   {
     std::string query = "YIELD (doublE)\".a123\"";
-    auto result = checkResult(query);
-    EXPECT_EQ(std::string(result.message()),
-              "SemanticError: `(FLOAT)\".a123\"' is not a valid expression ");
+    EXPECT_TRUE(checkResult(query));
   }
   {
     std::string query = "YIELD (STRING)1.23";
@@ -200,15 +194,15 @@ TEST_F(YieldValidatorTest, TypeCastTest) {
   }
   {
     std::string query = "YIELD (BOOL)123";
-    EXPECT_FALSE(checkResult(query, expected_));
+    EXPECT_TRUE(checkResult(query, expected_));
   }
   {
     std::string query = "YIELD (BOOL)0";
-    EXPECT_FALSE(checkResult(query, expected_));
+    EXPECT_TRUE(checkResult(query, expected_));
   }
   {
     std::string query = "YIELD (BOOL)\"12\"";
-    EXPECT_FALSE(checkResult(query, expected_));
+    EXPECT_TRUE(checkResult(query, expected_));
   }
   {
     std::string query = "YIELD (MAP)(\"12\")";

src/graph/visitor/DeduceTypeVisitor.cpp

@@ -249,13 +249,7 @@ void DeduceTypeVisitor::visit(TypeCastingExpression *expr) {
     status_ = Status::SemanticError(out.str());
     return;
   }
-  QueryExpressionContext ctx(nullptr);
-  auto val = expr->eval(ctx(nullptr));
-  if (val.isNull()) {
-    status_ = Status::SemanticError("`%s' is not a valid expression ", expr->toString().c_str());
-    return;
-  }
-  type_ = val.type();
+  type_ = expr->type();
   status_ = Status::OK();
 }
 
@@ -486,7 +480,21 @@ void DeduceTypeVisitor::visit(FunctionCallExpression *expr) {
 void DeduceTypeVisitor::visit(AggregateExpression *expr) {
   expr->arg()->accept(this);
   if (!ok()) return;
-  type_ = Value::Type::__EMPTY__;
+  auto func = expr->name();
+  std::transform(func.begin(), func.end(), func.begin(), ::toupper);
+  if ("COUNT" == func) {
+    type_ = Value::Type::INT;
+  } else if ("COLLECT" == func) {
+    type_ = Value::Type::LIST;
+  } else if ("COLLECT_SET" == func) {
+    type_ = Value::Type::SET;
+  } else if ("AVG" == func || "SUM" == func) {
+    type_ = Value::Type::FLOAT;
+  } else if ("MAX" == func || "MIN" == func) {
+    // Keep same with arg's type
+  } else {
+    type_ = Value::Type::__EMPTY__;
+  }
 }
 
 void DeduceTypeVisitor::visit(UUIDExpression *) {

tests/tck/features/go/GO.feature

@@ -149,6 +149,16 @@ Feature: Go Sentence
       | "Spurs"         |
       | "Hornets"       |
       | "Trail Blazers" |
+    When executing query:
+      """
+      GO FROM "Tim Duncan" OVER like WHERE like._rank<10 YIELD like._src AS src, like._dst AS dst, like._rank AS rank
+      | YIELD $-.src AS src, $-.dst AS dst, max($-.rank) AS maxRank
+      | FETCH PROP ON like $-.src -> $-.dst@$-.maxRank YIELD edge AS e
+      """
+    Then the result should be, in any order, with relax comparison:
+      | e                                                       |
+      | [:like "Tim Duncan"->"Tony Parker" @0 {likeness: 95}]   |
+      | [:like "Tim Duncan"->"Manu Ginobili" @0 {likeness: 95}] |
 
   Scenario: In expression
     When executing query: