Support all DAG operator types in mock SQL -> DAG parser (#176)

* Enhance dbg invoke and add dag as schemaful function

* Add basic sql parse to dag

* Column id starts from 1

* Fix value to ref

* Add basic dag test

* Fix dag bugs and pass 1st mock test

* Make dag go normal routine and add mock dag

* Add todo

* Add comment

* Fix gcc compile error

* Enhance dag test

* Address comments

* Enhance mock sql -> dag compiler and add project test

* Mock sql dag compiler support more expression types and add filter test

* Add topn and limit test

* Add agg for sql -> dag parser and agg test

* Add dag specific codec

* type

* Update codec accordingly

* Remove cop-test

dbms/src/Flash/Coprocessor/DAGCodec.cpp

@@ -0,0 +1,65 @@
+#include <Flash/Coprocessor/DAGCodec.h>
+
+#include <Storages/Transaction/Codec.h>
+#include <Storages/Transaction/TiKVRecordFormat.h>
+
+namespace DB
+{
+
+void encodeDAGInt64(Int64 i, std::stringstream & ss)
+{
+    auto u = RecordKVFormat::encodeInt64(i);
+    ss.write(reinterpret_cast<const char *>(&u), sizeof(u));
+}
+
+void encodeDAGUInt64(UInt64 i, std::stringstream & ss)
+{
+    auto u = RecordKVFormat::encodeUInt64(i);
+    ss.write(reinterpret_cast<const char *>(&u), sizeof(u));
+}
+
+void encodeDAGFloat32(Float32 f, std::stringstream & ss) { EncodeFloat64(f, ss); }
+
+void encodeDAGFloat64(Float64 f, std::stringstream & ss) { EncodeFloat64(f, ss); }
+
+void encodeDAGString(const String & s, std::stringstream & ss) { ss << s; }
+
+void encodeDAGBytes(const String & bytes, std::stringstream & ss) { ss << bytes; }
+
+void encodeDAGDecimal(const Decimal & d, std::stringstream & ss) { EncodeDecimal(d, ss); }
+
+Int64 decodeDAGInt64(const String & s)
+{
+    auto u = *(reinterpret_cast<const UInt64 *>(s.data()));
+    return RecordKVFormat::decodeInt64(u);
+}
+
+UInt64 decodeDAGUInt64(const String & s)
+{
+    auto u = *(reinterpret_cast<const UInt64 *>(s.data()));
+    return RecordKVFormat::decodeUInt64(u);
+}
+
+Float32 decodeDAGFloat32(const String & s)
+{
+    size_t cursor = 0;
+    return DecodeFloat64(cursor, s);
+}
+
+Float64 decodeDAGFloat64(const String & s)
+{
+    size_t cursor = 0;
+    return DecodeFloat64(cursor, s);
+}
+
+String decodeDAGString(const String & s) { return s; }
+
+String decodeDAGBytes(const String & s) { return s; }
+
+Decimal decodeDAGDecimal(const String & s)
+{
+    size_t cursor = 0;
+    return DecodeDecimal(cursor, s);
+}
+
+} // namespace DB

dbms/src/Flash/Coprocessor/DAGCodec.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <Common/Decimal.h>
+#include <Core/Field.h>
+
+namespace DB
+{
+
+void encodeDAGInt64(Int64, std::stringstream &);
+void encodeDAGUInt64(UInt64, std::stringstream &);
+void encodeDAGFloat32(Float32, std::stringstream &);
+void encodeDAGFloat64(Float64, std::stringstream &);
+void encodeDAGString(const String &, std::stringstream &);
+void encodeDAGBytes(const String &, std::stringstream &);
+void encodeDAGDecimal(const Decimal &, std::stringstream &);
+
+Int64 decodeDAGInt64(const String &);
+UInt64 decodeDAGUInt64(const String &);
+Float32 decodeDAGFloat32(const String &);
+Float64 decodeDAGFloat64(const String &);
+String decodeDAGString(const String &);
+String decodeDAGBytes(const String &);
+Decimal decodeDAGDecimal(const String &);
+
+} // namespace DB

dbms/src/Flash/Coprocessor/DAGUtils.cpp

@@ -1,9 +1,8 @@
 #include <Flash/Coprocessor/DAGUtils.h>
 
 #include <Core/Types.h>
+#include <Flash/Coprocessor/DAGCodec.h>
 #include <Interpreters/Context.h>
-#include <Storages/Transaction/Codec.h>
-#include <Storages/Transaction/TiKVRecordFormat.h>
 
 #include <unordered_map>
 
@@ -51,7 +50,6 @@ const String & getFunctionName(const tipb::Expr & expr)
 String exprToString(const tipb::Expr & expr, const NamesAndTypesList & input_col, bool for_parser)
 {
     std::stringstream ss;
-    size_t cursor = 0;
     Int64 column_id = 0;
     String func_name;
     Field f;
@@ -60,19 +58,21 @@ String exprToString(const tipb::Expr & expr, const NamesAndTypesList & input_col
         case tipb::ExprType::Null:
             return "NULL";
         case tipb::ExprType::Int64:
-            return std::to_string(RecordKVFormat::decodeInt64(RecordKVFormat::read<UInt64>(expr.val().data())));
+            return std::to_string(decodeDAGInt64(expr.val()));
         case tipb::ExprType::Uint64:
-            return std::to_string(DecodeInt<UInt64>(cursor, expr.val()));
+            return std::to_string(decodeDAGUInt64(expr.val()));
         case tipb::ExprType::Float32:
+            return std::to_string(decodeDAGFloat32(expr.val()));
         case tipb::ExprType::Float64:
-            return std::to_string(DecodeFloat64(cursor, expr.val()));
+            return std::to_string(decodeDAGFloat64(expr.val()));
         case tipb::ExprType::String:
+            return decodeDAGString(expr.val());
         case tipb::ExprType::Bytes:
-            return expr.val();
+            return decodeDAGBytes(expr.val());
         case tipb::ExprType::MysqlDecimal:
-            return DecodeDecimal(cursor, expr.val()).toString();
+            return decodeDAGDecimal(expr.val()).toString();
         case tipb::ExprType::ColumnRef:
-            column_id = RecordKVFormat::decodeInt64(RecordKVFormat::read<UInt64>(expr.val().data()));
+            column_id = decodeDAGInt64(expr.val());
             if (column_id < 0 || column_id >= (ColumnID)input_col.size())
             {
                 throw Exception("Column id out of bound", ErrorCodes::COP_BAD_DAG_REQUEST);
@@ -191,23 +191,24 @@ bool isColumnExpr(const tipb::Expr & expr) { return expr.tp() == tipb::ExprType:
 
 Field decodeLiteral(const tipb::Expr & expr)
 {
-    size_t cursor = 0;
     switch (expr.tp())
     {
         case tipb::ExprType::Null:
             return Field();
         case tipb::ExprType::Int64:
-            return RecordKVFormat::decodeInt64(RecordKVFormat::read<UInt64>(expr.val().data()));
+            return decodeDAGInt64(expr.val());
         case tipb::ExprType::Uint64:
-            return DecodeInt<UInt64>(cursor, expr.val());
+            return decodeDAGUInt64(expr.val());
         case tipb::ExprType::Float32:
+            return Float64(decodeDAGFloat32(expr.val()));
         case tipb::ExprType::Float64:
-            return DecodeFloat64(cursor, expr.val());
+            return decodeDAGFloat64(expr.val());
         case tipb::ExprType::String:
+            return decodeDAGString(expr.val());
         case tipb::ExprType::Bytes:
-            return expr.val();
+            return decodeDAGBytes(expr.val());
         case tipb::ExprType::MysqlDecimal:
-            return DecodeDecimal(cursor, expr.val());
+            return decodeDAGDecimal(expr.val());
         case tipb::ExprType::MysqlBit:
         case tipb::ExprType::MysqlDuration:
         case tipb::ExprType::MysqlEnum:
@@ -224,7 +225,7 @@ Field decodeLiteral(const tipb::Expr & expr)
 
 ColumnID getColumnID(const tipb::Expr & expr)
 {
-    auto column_id = RecordKVFormat::decodeInt64(RecordKVFormat::read<UInt64>(expr.val().data()));
+    auto column_id = decodeDAGInt64(expr.val());
     return column_id;
 }
 

dbms/src/Flash/Coprocessor/tests/CMakeLists.txt

@@ -1,4 +1 @@
 include_directories (${CMAKE_CURRENT_BINARY_DIR})
-
-add_executable (cop_test cop_test.cpp)
-target_link_libraries (cop_test dbms)