Merge branch 'master' into enhancement/pattern-expression

src/common/expression/PredicateExpression.cpp

@@ -19,7 +19,8 @@ std::unordered_map<std::string, PredicateExpression::Type> PredicateExpression::
 const Value& PredicateExpression::evalExists(ExpressionContext& ctx) {
   DCHECK(collection_->kind() == Expression::Kind::kAttribute ||
          collection_->kind() == Expression::Kind::kSubscript ||
-         collection_->kind() == Expression::Kind::kLabelTagProperty);
+         collection_->kind() == Expression::Kind::kLabelTagProperty)
+      << "actual kind: " << collection_->kind() << ", toString: " << toString();
 
   if (collection_->kind() == Expression::Kind::kLabelTagProperty) {
     result_ = !collection_->eval(ctx).isNull();

src/common/function/FunctionManager.cpp

@@ -8,6 +8,7 @@
 #include <folly/json.h>
 
 #include <boost/algorithm/string/replace.hpp>
+#include <cstdint>
 
 #include "common/base/Base.h"
 #include "common/datatypes/DataSet.h"
@@ -41,6 +42,7 @@ std::unordered_map<std::string, Value::Type> FunctionManager::variadicFunReturnT
     {"concat_ws", Value::Type::STRING},
     {"cos_similarity", Value::Type::FLOAT},
     {"coalesce", Value::Type::__EMPTY__},
+    {"_any", Value::Type::__EMPTY__},
 };
 
 std::unordered_map<std::string, std::vector<TypeSignature>> FunctionManager::typeSignature_ = {
@@ -2820,6 +2822,21 @@ FunctionManager::FunctionManager() {
       }
     };
   }
+  // Get any argument which is not empty/null
+  {
+    auto &attr = functions_["_any"];
+    attr.minArity_ = 1;
+    attr.maxArity_ = INT64_MAX;
+    attr.isAlwaysPure_ = true;
+    attr.body_ = [](const auto &args) -> Value {
+      for (const auto &arg : args) {
+        if (!arg.get().isNull() && !arg.get().empty()) {
+          return arg.get();
+        }
+      }
+      return Value::kNullValue;
+    };
+  }
 }  // NOLINT
 
 // static

src/common/function/test/FunctionManagerTest.cpp

@@ -1983,6 +1983,19 @@ TEST_F(FunctionManagerTest, PurityTest) {
   ASSERT_TRUE(result.ok() && result.value() == true);
 }
 
+TEST_F(FunctionManagerTest, Any) {
+  auto dataset = DataSet({"col0", "col1", "col2"});
+  dataset.emplace_back(Row({1, true, "233"}));
+  dataset.emplace_back(Row({4, false, "456"}));
+  Value datasetValue = Value(std::move(dataset));
+  // null all
+  { TEST_FUNCTION(_any, std::vector<Value>({Value(), Value::kNullValue}), Value::kNullBadData); }
+  // ok
+  { TEST_FUNCTION(_any, std::vector<Value>({Value(), Value::kNullValue, Value(1)}), Value(1)); }
+  // only one
+  { TEST_FUNCTION(_any, std::vector<Value>({Value(1)}), Value(1)); }
+}
+
 }  // namespace nebula
 
 int main(int argc, char **argv) {

src/graph/context/Symbols.cpp

@@ -81,14 +81,6 @@ bool SymbolTable::deleteWrittenBy(const std::string& varName, PlanNode* node) {
   if (var == vars_.end()) {
     return false;
   }
-  for (auto& alias : var->second->colNames) {
-    auto found = aliasGeneratedBy_.find(alias);
-    if (found != aliasGeneratedBy_.end()) {
-      if (found->second == varName) {
-        aliasGeneratedBy_.erase(alias);
-      }
-    }
-  }
   var->second->writtenBy.erase(node);
   return true;
 }
@@ -106,6 +98,7 @@ bool SymbolTable::updateWrittenBy(const std::string& oldVar,
 }
 
 Variable* SymbolTable::getVar(const std::string& varName) {
+  DCHECK(!varName.empty()) << "the variable name is empty";
   auto var = vars_.find(varName);
   if (var == vars_.end()) {
     return nullptr;
@@ -114,22 +107,5 @@ Variable* SymbolTable::getVar(const std::string& varName) {
   }
 }
 
-void SymbolTable::setAliasGeneratedBy(const std::vector<std::string>& aliases,
-                                      const std::string& varName) {
-  for (auto& alias : aliases) {
-    if (aliasGeneratedBy_.count(alias) == 0) {
-      aliasGeneratedBy_.emplace(alias, varName);
-    }
-  }
-}
-
-StatusOr<std::string> SymbolTable::getAliasGeneratedBy(const std::string& alias) {
-  auto found = aliasGeneratedBy_.find(alias);
-  if (found == aliasGeneratedBy_.end()) {
-    return Status::Error("Not found a variable that generates the alias: %s", alias.c_str());
-  } else {
-    return found->second;
-  }
-}
 }  // namespace graph
 }  // namespace nebula

src/graph/context/Symbols.h

@@ -72,10 +72,6 @@ class SymbolTable final {
 
   Variable* getVar(const std::string& varName);
 
-  void setAliasGeneratedBy(const std::vector<std::string>& aliases, const std::string& varName);
-
-  StatusOr<std::string> getAliasGeneratedBy(const std::string& alias);
-
   std::string toString() const;
 
  private:
@@ -85,8 +81,6 @@ class SymbolTable final {
   ExecutionContext* ectx_{nullptr};
   // var name -> variable
   std::unordered_map<std::string, Variable*> vars_;
-  // alias -> first variable that generate the alias
-  std::unordered_map<std::string, std::string> aliasGeneratedBy_;
 };
 
 }  // namespace graph

src/graph/executor/logic/ArgumentExecutor.cpp

@@ -24,7 +24,9 @@ folly::Future<Status> ArgumentExecutor::execute() {
   std::unordered_set<Value> unique;
   for (; iter->valid(); iter->next()) {
     auto &val = iter->getColumn(alias);
-    if (!val.isVertex()) {
+    if (val.isNull()) {
+      continue;
+    } else if (!val.isVertex()) {
       return Status::Error("Argument only support vertex, but got %s, which is type %s, ",
                            val.toString().c_str(),
                            val.typeName().c_str());

src/graph/optimizer/CMakeLists.txt

@@ -27,6 +27,7 @@ nebula_add_library(
     rule/PushFilterDownAggregateRule.cpp
     rule/PushFilterDownProjectRule.cpp
     rule/PushFilterDownLeftJoinRule.cpp
+    rule/PushFilterDownHashInnerJoinRule.cpp
     rule/PushFilterDownInnerJoinRule.cpp
     rule/PushFilterDownNodeRule.cpp
     rule/PushFilterDownScanVerticesRule.cpp
@@ -53,6 +54,7 @@ nebula_add_library(
     rule/EliminateAppendVerticesRule.cpp
     rule/PushLimitDownScanEdgesRule.cpp
     rule/RemoveProjectDedupBeforeGetDstBySrcRule.cpp
+    rule/PushFilterDownTraverseRule.cpp
 )
 
 nebula_add_subdirectory(test)