Types for Batch Execution

Cargo.toml

@@ -78,9 +78,12 @@ crossbeam-channel = "0.2"
 crossbeam = "0.2"
 fxhash = "0.2"
 derive_more = "0.11.0"
-num = "0.2.0"
+num = "0.2"
+num-traits = "0.2"
 hex = "0.3"
 rust-crypto = "^0.2"
+cop_datatype = { path = "components/cop_datatype" }
+smallvec = { version = "0.6", features = ["union"] }
 
 [replace]
 "raft:0.3.1" = { git = "https://github.com/pingcap/raft-rs.git" }
@@ -130,6 +133,7 @@ members = [
   "components/test_coprocessor",
   "components/test_util",
   "components/codec",
+  "components/cop_datatype",
 ]
 
 [profile.dev]

benches/benches.rs

@@ -19,6 +19,7 @@ extern crate crossbeam_channel;
 extern crate kvproto;
 extern crate log;
 extern crate mio;
+extern crate num_traits;
 extern crate protobuf;
 extern crate raft;
 extern crate rand;
@@ -27,6 +28,7 @@ extern crate tempdir;
 extern crate test;
 extern crate tipb;
 
+extern crate cop_datatype;
 extern crate test_storage;
 extern crate test_util;
 extern crate tikv;

benches/coprocessor/codec/chunk/arrow.rs

@@ -11,11 +11,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use std::sync::Arc;
+
 use arrow::array;
 use arrow::datatypes::{self, DataType, Field};
 use arrow::record_batch::RecordBatch;
-use std::sync::Arc;
-use tikv::coprocessor::codec::mysql::types;
+
+use cop_datatype::prelude::*;
+use cop_datatype::{FieldTypeFlag, FieldTypeTp};
 use tikv::coprocessor::codec::Datum;
 use tipb::expression::FieldType;
 
@@ -24,21 +27,21 @@ pub struct Chunk {
 }
 
 impl Chunk {
-    pub fn get_datum(&self, col_id: usize, row_id: usize, tp: &FieldType) -> Datum {
+    pub fn get_datum(&self, col_id: usize, row_id: usize, field_type: &FieldType) -> Datum {
         if let Some(bitmap) = self.data.column(col_id).validity_bitmap() {
             if !bitmap.is_set(row_id) {
                 return Datum::Null;
             }
         }
 
-        match tp.get_tp() as u8 {
-            types::TINY
-            | types::SHORT
-            | types::INT24
-            | types::LONG
-            | types::LONG_LONG
-            | types::YEAR => {
-                if types::has_unsigned_flag(tp.get_flag()) {
+        match field_type.tp() {
+            FieldTypeTp::Tiny
+            | FieldTypeTp::Short
+            | FieldTypeTp::Int24
+            | FieldTypeTp::Long
+            | FieldTypeTp::LongLong
+            | FieldTypeTp::Year => {
+                if field_type.flag().contains(FieldTypeFlag::UNSIGNED) {
                     let data = self
                         .data
                         .column(col_id)
@@ -58,7 +61,7 @@ impl Chunk {
                     Datum::I64(*data.get(row_id))
                 }
             }
-            types::FLOAT | types::DOUBLE => {
+            FieldTypeTp::Float | FieldTypeTp::Double => {
                 let data = self
                     .data
                     .column(col_id)
@@ -86,21 +89,21 @@ impl ChunkBuilder {
     pub fn build(self, tps: &[FieldType]) -> Chunk {
         let mut fields = Vec::with_capacity(tps.len());
         let mut arrays: Vec<Arc<array::Array>> = Vec::with_capacity(tps.len());
-        for (tp, column) in tps.iter().zip(self.columns.into_iter()) {
-            let (field, data) = match tp.get_tp() as u8 {
-                types::TINY
-                | types::SHORT
-                | types::INT24
-                | types::LONG
-                | types::LONG_LONG
-                | types::YEAR => {
-                    if types::has_unsigned_flag(tp.get_flag()) {
+        for (field_type, column) in tps.iter().zip(self.columns.into_iter()) {
+            let (field, data) = match field_type.tp() {
+                FieldTypeTp::Tiny
+                | FieldTypeTp::Short
+                | FieldTypeTp::Int24
+                | FieldTypeTp::Long
+                | FieldTypeTp::LongLong
+                | FieldTypeTp::Year => {
+                    if field_type.flag().contains(FieldTypeFlag::UNSIGNED) {
                         column.into_u64_array()
                     } else {
                         column.into_i64_array()
                     }
                 }
-                types::FLOAT | types::DOUBLE => column.into_f64_array(),
+                FieldTypeTp::Float | FieldTypeTp::Double => column.into_f64_array(),
                 _ => unreachable!(),
             };
             fields.push(field);

benches/coprocessor/codec/chunk/mod.rs

@@ -15,28 +15,29 @@ mod arrow;
 
 use test::Bencher;
 
+use cop_datatype::{FieldTypeAccessor, FieldTypeTp};
 use tipb::expression::FieldType;
 
 use tikv::coprocessor::codec::chunk::{Chunk, ChunkEncoder};
 use tikv::coprocessor::codec::datum::Datum;
 use tikv::coprocessor::codec::mysql::*;
 
-fn field_type(tp: u8) -> FieldType {
+fn field_type(tp: FieldTypeTp) -> FieldType {
     let mut fp = FieldType::new();
-    fp.set_tp(i32::from(tp));
+    fp.as_mut_accessor().set_tp(tp);
     fp
 }
 
 #[bench]
 fn bench_encode_chunk(b: &mut Bencher) {
     let rows = 1024;
     let fields = vec![
-        field_type(types::LONG_LONG),
-        field_type(types::LONG_LONG),
-        field_type(types::VARCHAR),
-        field_type(types::VARCHAR),
-        field_type(types::NEW_DECIMAL),
-        field_type(types::JSON),
+        field_type(FieldTypeTp::LongLong),
+        field_type(FieldTypeTp::LongLong),
+        field_type(FieldTypeTp::VarChar),
+        field_type(FieldTypeTp::VarChar),
+        field_type(FieldTypeTp::NewDecimal),
+        field_type(FieldTypeTp::JSON),
     ];
     let mut chunk = Chunk::new(&fields, rows);
     for row_id in 0..rows {
@@ -61,7 +62,10 @@ fn bench_encode_chunk(b: &mut Bencher) {
 #[bench]
 fn bench_chunk_build_tidb(b: &mut Bencher) {
     let rows = 1024;
-    let fields = vec![field_type(types::LONG_LONG), field_type(types::LONG_LONG)];
+    let fields = vec![
+        field_type(FieldTypeTp::LongLong),
+        field_type(FieldTypeTp::LongLong),
+    ];
 
     b.iter(|| {
         let mut chunk = Chunk::new(&fields, rows);
@@ -75,7 +79,10 @@ fn bench_chunk_build_tidb(b: &mut Bencher) {
 #[bench]
 fn bench_chunk_build_offical(b: &mut Bencher) {
     let rows = 1024;
-    let fields = vec![field_type(types::LONG_LONG), field_type(types::LONG_LONG)];
+    let fields = vec![
+        field_type(FieldTypeTp::LongLong),
+        field_type(FieldTypeTp::LongLong),
+    ];
 
     b.iter(|| {
         let mut chunk = arrow::ChunkBuilder::new(fields.len(), rows);
@@ -90,7 +97,10 @@ fn bench_chunk_build_offical(b: &mut Bencher) {
 #[bench]
 fn bench_chunk_iter_tidb(b: &mut Bencher) {
     let rows = 1024;
-    let fields = vec![field_type(types::LONG_LONG), field_type(types::DOUBLE)];
+    let fields = vec![
+        field_type(FieldTypeTp::LongLong),
+        field_type(FieldTypeTp::Double),
+    ];
     let mut chunk = Chunk::new(&fields, rows);
     for row_id in 0..rows {
         if row_id & 1 == 0 {
@@ -123,7 +133,10 @@ fn bench_chunk_iter_tidb(b: &mut Bencher) {
 #[bench]
 fn bench_chunk_iter_offical(b: &mut Bencher) {
     let rows = 1024;
-    let fields = vec![field_type(types::LONG_LONG), field_type(types::DOUBLE)];
+    let fields = vec![
+        field_type(FieldTypeTp::LongLong),
+        field_type(FieldTypeTp::Double),
+    ];
     let mut chunk = arrow::ChunkBuilder::new(fields.len(), rows);
     for row_id in 0..rows {
         if row_id & 1 == 0 {

components/cop_datatype/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "cop_datatype"
+version = "0.0.1"
+publish = false
+description = "TiKV Coprocessor data types"
+
+[lib]
+path = "lib.rs"
+
+[dependencies]
+tipb = { git = "https://github.com/pingcap/tipb.git" }
+bitflags = "1.0"
+enum-primitive-derive = "0.1"
+num-traits = "0.2"
+quick-error = "1.2"