Supported builtin functions in query language (vesoft-inc#264)

src/parser/CMakeLists.txt

@@ -14,6 +14,7 @@ add_library(
         ${FLEX_Scanner_OUTPUTS}
         ${BISON_Parser_OUTPUTS}
         Expressions.cpp
+        FunctionManager.cpp
         Clauses.cpp
         SequentialSentences.cpp
         MaintainSentences.cpp

src/parser/Expressions.cpp

@@ -7,6 +7,7 @@
 #include "base/Base.h"
 #include "base/Cord.h"
 #include "parser/Expressions.h"
+#include "parser/FunctionManager.h"
 
 
 #define THROW_IF_NO_SPACE(POS, END, REQUIRE)                                        \
@@ -71,6 +72,8 @@ std::unique_ptr<Expression> Expression::makeExpr(uint8_t kind) {
     switch (intToKind(kind)) {
         case kPrimary:
             return std::make_unique<PrimaryExpression>();
+        case kFunctionCall:
+            return std::make_unique<FunctionCallExpression>();
         case kUnary:
             return std::make_unique<UnaryExpression>();
         case kTypeCasting:
@@ -643,6 +646,88 @@ const char* PrimaryExpression::decode(const char *pos, const char *end) {
 }
 
 
+std::string FunctionCallExpression::toString() const {
+    std::string buf;
+    buf.reserve(256);
+    buf += *name_;
+    buf += "(";
+    for (auto &arg : args_) {
+        buf += arg->toString();
+        buf += ",";
+    }
+    if (!args_.empty()) {
+        buf.resize(buf.size() - 1);
+    }
+    return buf;
+}
+
+
+VariantType FunctionCallExpression::eval() const {
+    std::vector<VariantType> args;
+    args.resize(args_.size());
+    auto eval = [] (auto &expr) {
+        return expr->eval();
+    };
+    std::transform(args_.begin(), args_.end(), args.begin(), eval);
+    return function_(args);
+}
+
+
+Status FunctionCallExpression::prepare() {
+    auto result = FunctionManager::get(*name_, args_.size());
+    if (!result.ok()) {
+        return std::move(result).status();
+    }
+
+    function_ = std::move(result).value();
+
+    auto status = Status::OK();
+    for (auto &arg : args_) {
+        status = arg->prepare();
+        if (!status.ok()) {
+            break;
+        }
+    }
+    return status;
+}
+
+
+void FunctionCallExpression::encode(Cord &cord) const {
+    cord << kindToInt(kind());
+
+    cord << static_cast<uint16_t>(name_->size());
+    cord << *name_;
+
+    cord << static_cast<uint16_t>(args_.size());
+    for (auto &arg : args_) {
+        arg->encode(cord);
+    }
+}
+
+
+const char* FunctionCallExpression::decode(const char *pos, const char *end) {
+    THROW_IF_NO_SPACE(pos, end, 2UL);
+    auto size = *reinterpret_cast<const uint16_t*>(pos);
+    pos += 2;
+
+    THROW_IF_NO_SPACE(pos, end, size);
+    name_ = std::make_unique<std::string>(pos, size);
+    pos += size;
+
+    auto count = *reinterpret_cast<const uint16_t*>(pos);
+    pos += 2;
+
+    args_.reserve(count);
+    for (auto i = 0u; i < count; i++) {
+        THROW_IF_NO_SPACE(pos, end, 1UL);
+        auto arg = makeExpr(*reinterpret_cast<const uint8_t*>(pos++));
+        pos = arg->decode(pos, end);
+        args_.emplace_back(std::move(arg));
+    }
+    return pos;
+}
+
+
 std::string UnaryExpression::toString() const {
     std::string buf;
     buf.reserve(256);

src/parser/Expressions.h

@@ -212,6 +212,7 @@ class Expression {
         kUnknown = 0,
 
         kPrimary,
+        kFunctionCall,
         kUnary,
         kTypeCasting,
         kArithmetic,
@@ -251,6 +252,7 @@ class Expression {
     // to allow them to call private encode/decode on each other.
     friend class PrimaryExpression;
     friend class UnaryExpression;
+    friend class FunctionCallExpression;
     friend class TypeCastingExpression;
     friend class ArithmeticExpression;
     friend class RelationalExpression;
@@ -603,6 +605,61 @@ class PrimaryExpression final : public Expression {
 };
 
 
+class ArgumentList final {
+public:
+    void addArgument(Expression *arg) {
+        args_.emplace_back(arg);
+    }
+
+    auto args() {
+        return std::move(args_);
+    }
+
+private:
+    std::vector<std::unique_ptr<Expression>>    args_;
+};
+
+
+class FunctionCallExpression final : public Expression {
+public:
+    FunctionCallExpression() {
+        kind_ = kFunctionCall;
+    }
+
+    FunctionCallExpression(std::string *name, ArgumentList *args) {
+        kind_ = kFunctionCall;
+        name_.reset(name);
+        if (args != nullptr) {
+            args_ = args->args();
+            delete args;
+        }
+    }
+
+    std::string toString() const override;
+
+    VariantType eval() const override;
+
+    Status MUST_USE_RESULT prepare() override;
+
+    void setContext(ExpressionContext *ctx) {
+        context_ = ctx;
+        for (auto &arg : args_) {
+            arg->setContext(ctx);
+        }
+    }
+
+private:
+    void encode(Cord &cord) const override;
+
+    const char* decode(const char *pos, const char *end) override;
+
+private:
+    std::unique_ptr<std::string>                name_;
+    std::vector<std::unique_ptr<Expression>>    args_;
+    std::function<VariantType(const std::vector<VariantType>&)> function_;
+};
+
+
 // +expr, -expr, !expr
 class UnaryExpression final : public Expression {
 public: