Math func pushdown (#2217)

dbms/src/Flash/Coprocessor/DAGUtils.cpp

@@ -641,26 +641,26 @@ std::unordered_map<tipb::ScalarFuncSig, String> scalar_func_map({
     //{tipb::ScalarFuncSig::RoundWithFracDec, "cast"},
 
     {tipb::ScalarFuncSig::Log1Arg, "log"},
-    //{tipb::ScalarFuncSig::Log2Args, "cast"},
+    {tipb::ScalarFuncSig::Log2Args, "log2args"},
     {tipb::ScalarFuncSig::Log2, "log2"}, {tipb::ScalarFuncSig::Log10, "log10"},
 
     {tipb::ScalarFuncSig::Rand, "rand"},
     //{tipb::ScalarFuncSig::RandWithSeedFirstGen, "cast"},
 
     {tipb::ScalarFuncSig::Pow, "pow"},
-    //{tipb::ScalarFuncSig::Conv, "cast"},
-    //{tipb::ScalarFuncSig::CRC32, "cast"},
-    //{tipb::ScalarFuncSig::Sign, "cast"},
+    {tipb::ScalarFuncSig::Conv, "conv"},
+    {tipb::ScalarFuncSig::CRC32, "crc32"},
+    {tipb::ScalarFuncSig::Sign, "sign"},
 
     {tipb::ScalarFuncSig::Sqrt, "sqrt"}, {tipb::ScalarFuncSig::Acos, "acos"}, {tipb::ScalarFuncSig::Asin, "asin"},
     {tipb::ScalarFuncSig::Atan1Arg, "atan"},
     //{tipb::ScalarFuncSig::Atan2Args, "cast"},
     {tipb::ScalarFuncSig::Cos, "cos"},
     //{tipb::ScalarFuncSig::Cot, "cast"},
-    //{tipb::ScalarFuncSig::Degrees, "cast"},
+    {tipb::ScalarFuncSig::Degrees, "degrees"},
     {tipb::ScalarFuncSig::Exp, "exp"},
     //{tipb::ScalarFuncSig::PI, "cast"},
-    //{tipb::ScalarFuncSig::Radians, "cast"},
+    {tipb::ScalarFuncSig::Radians, "radians"},
     {tipb::ScalarFuncSig::Sin, "sin"}, {tipb::ScalarFuncSig::Tan, "tan"}, {tipb::ScalarFuncSig::TruncateInt, "trunc"},
     {tipb::ScalarFuncSig::TruncateReal, "trunc"},
     //{tipb::ScalarFuncSig::TruncateDecimal, "cast"},

dbms/src/Functions/FunctionHelpers.cpp

@@ -108,4 +108,6 @@ bool functionIsInOrGlobalInOperator(const String & name)
     return name == "in" || name == "notIn" || name == "globalIn" || name == "globalNotIn" || name == "tidbIn" || name == "tidbNotIn";
 }
 
+
+
 } // namespace DB

dbms/src/Functions/FunctionHelpers.h

@@ -1,13 +1,16 @@
 #pragma once
 
 #include <Columns/ColumnConst.h>
+#include <Columns/ColumnVector.h>
 #include <Columns/ColumnNullable.h>
 #include <Columns/IColumn.h>
 #include <Common/typeid_cast.h>
 #include <Core/Block.h>
 #include <Core/ColumnNumbers.h>
 #include <DataTypes/IDataType.h>
 
+#include <memory>
+
 
 namespace DB
 {
@@ -107,4 +110,52 @@ bool functionIsInOperator(const String & name);
 
 bool functionIsInOrGlobalInOperator(const String & name);
 
+
+template <typename T>
+struct IGetVecHelper
+{
+    static_assert(std::is_arithmetic_v<T>);
+    virtual T get(size_t) const = 0;
+    virtual ~IGetVecHelper() {}
+    static std::unique_ptr<IGetVecHelper> getHelper(const ColumnVector<T>* p);
+    static std::unique_ptr<IGetVecHelper> getHelper(const ColumnConst* p); 
+};
+
+template <typename T>
+struct GetVecHelper : public IGetVecHelper<T>
+{
+    GetVecHelper(const ColumnVector<T>* p_) : p(p_) {}
+    T get(size_t i) const override
+    {
+        return p->getElement(i);
+    }
+private:
+    const ColumnVector<T>* p;
+};
+
+template <typename T>
+struct GetConstVecHelper : public IGetVecHelper<T>
+{
+    GetConstVecHelper(const ColumnConst* p_) : value(p_->getValue<T>()) {}
+    T get(size_t) const override
+    {
+        return value;
+    }
+private:
+    T value;
+};
+
+template <typename T>
+std::unique_ptr<IGetVecHelper<T>> IGetVecHelper<T>::getHelper(const ColumnVector<T>* p)
+{
+    return std::unique_ptr<IGetVecHelper<T>>{new GetVecHelper<T>{p}};
+}
+
+template <typename T>
+std::unique_ptr<IGetVecHelper<T>> IGetVecHelper<T>::getHelper(const ColumnConst* p)
+{
+    return std::unique_ptr<IGetVecHelper<T>>{new GetConstVecHelper<T>{p}};
+}
+
+
 }

dbms/src/Functions/FunctionsMath.cpp

@@ -12,8 +12,12 @@ void registerFunctionsMath(FunctionFactory & factory)
 {
     factory.registerFunction<FunctionE>();
     factory.registerFunction<FunctionPi>();
+    factory.registerFunction<FunctionSign>();
+    factory.registerFunction<FunctionRadians>();
+    factory.registerFunction<FunctionDegrees>();
     factory.registerFunction<FunctionExp>();
     factory.registerFunction<FunctionLog>();
+    factory.registerFunction<FunctionLog2Args>();
     factory.registerFunction<FunctionExp2>();
     factory.registerFunction<FunctionLog2>();
     factory.registerFunction<FunctionExp10>();