refactor(expr): Extract number types

Author: andylokandy

Cargo.lock

@@ -20,3 +20,5 @@ common-expression = { path = "../expression" }
 
 serde = { version = "1.0.137", features = ["derive"] }
 serde_json = "1.0.81"
+ordered-float = { git = "https://github.com/andylokandy/rust-ordered-float.git", branch = "as", features = ["serde"] }
+

src/query/codegen/Cargo.toml

@@ -25,7 +25,7 @@ pub fn codegen_arithmetic_type() {
     use DataValueBinaryOperator::*;
     use DataValueUnaryOperator::*;
 
-    let dest = Path::new("src/common/datavalues/src/types");
+    let dest = Path::new("src/query/datavalues/src/types");
     let path = dest.join("arithmetics_type.rs");
 
     let mut file = File::create(&path).expect("open");

src/query/codegen/src/writes/arithmetics_type.rs

@@ -16,8 +16,7 @@ use std::fs::File;
 use std::io::Write;
 use std::path::Path;
 
-use common_expression::types::DataType;
-use common_expression::types::NumberTypeInfo;
+use common_expression::types::NumberDataType;
 
 pub enum OP {
     Plus,
@@ -35,6 +34,7 @@ pub fn codegen_arithmetic_type_v2() {
     let path = dest.join("arithmetics_type.rs");
 
     let mut file = File::create(&path).expect("open");
+    let codegen_src_path = file!();
     // Write the head.
     writeln!(
         file,
@@ -52,7 +52,10 @@ pub fn codegen_arithmetic_type_v2() {
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// This code is generated by common/codegen. DO NOT EDIT.
+// This code is generated by {codegen_src_path}. DO NOT EDIT.
+
+use ordered_float::OrderedFloat;
+
 use super::number::Number;
 
 pub trait ResultTypeOfBinary: Sized {{
@@ -79,30 +82,26 @@ pub trait ResultTypeOfUnary: Sized {{
     )
     .unwrap();
 
-    let lhs = vec![
-        DataType::UInt8,
-        DataType::UInt16,
-        DataType::UInt32,
-        DataType::UInt64,
-        DataType::Int8,
-        DataType::Int16,
-        DataType::Int32,
-        DataType::Int64,
-        DataType::Float32,
-        DataType::Float64,
+    let number_types = vec![
+        NumberDataType::UInt8,
+        NumberDataType::UInt16,
+        NumberDataType::UInt32,
+        NumberDataType::UInt64,
+        NumberDataType::Int8,
+        NumberDataType::Int16,
+        NumberDataType::Int32,
+        NumberDataType::Int64,
+        NumberDataType::Float32,
+        NumberDataType::Float64,
     ];
-    let rhs = lhs.clone();
 
-    for a in &lhs {
-        for b in &rhs {
-            let left = a.number_type_info().unwrap();
-            let right = b.number_type_info().unwrap();
-
-            let add_mul = arithmetic_coercion(left, right, OP::Plus);
-            let minus = arithmetic_coercion(left, right, OP::Minus);
-            let intdiv = arithmetic_coercion(left, right, OP::IntDiv);
-            let modulo = arithmetic_coercion(left, right, OP::Modulo);
-            let least_super = arithmetic_coercion(left, right, OP::Super);
+    for lhs in &number_types {
+        for rhs in &number_types {
+            let add_mul = arithmetic_coercion(*lhs, *rhs, OP::Plus);
+            let minus = arithmetic_coercion(*lhs, *rhs, OP::Minus);
+            let intdiv = arithmetic_coercion(*lhs, *rhs, OP::IntDiv);
+            let modulo = arithmetic_coercion(*lhs, *rhs, OP::Modulo);
+            let least_super = arithmetic_coercion(*lhs, *rhs, OP::Super);
 
             writeln!(
                 file,
@@ -114,8 +113,8 @@ impl ResultTypeOfBinary for ({}, {}) {{
     type Modulo = {};
     type LeastSuper = {};
 }}",
-                to_primitive_str(a.clone()),
-                to_primitive_str(b.clone()),
+                to_primitive_str(lhs.clone()),
+                to_primitive_str(rhs.clone()),
                 to_primitive_str(add_mul),
                 to_primitive_str(minus),
                 to_primitive_str(intdiv),
@@ -126,11 +125,11 @@ impl ResultTypeOfBinary for ({}, {}) {{
         }
     }
 
-    for arg in &lhs {
-        let negate = neg_coercion(arg.number_type_info().unwrap());
+    for arg in &number_types {
+        let negate = neg_coercion(*arg);
 
         match negate {
-            DataType::Float32 | DataType::Float64 => {
+            NumberDataType::Float32 | NumberDataType::Float64 => {
                 writeln!(
                     file,
                     "
@@ -200,97 +199,57 @@ impl ResultTypeOfUnary for {} {{
     file.flush().unwrap();
 }
 
-fn to_primitive_str(dt: DataType) -> &'static str {
+fn to_primitive_str(dt: NumberDataType) -> &'static str {
     match dt {
-        DataType::UInt8 => "u8",
-        DataType::UInt16 => "u16",
-        DataType::UInt32 => "u32",
-        DataType::UInt64 => "u64",
-        DataType::Int8 => "i8",
-        DataType::Int16 => "i16",
-        DataType::Int32 => "i32",
-        DataType::Int64 => "i64",
-        DataType::Float32 => "f32",
-        DataType::Float64 => "f64",
-        _ => panic!("unsupported data type"),
+        NumberDataType::UInt8 => "u8",
+        NumberDataType::UInt16 => "u16",
+        NumberDataType::UInt32 => "u32",
+        NumberDataType::UInt64 => "u64",
+        NumberDataType::Int8 => "i8",
+        NumberDataType::Int16 => "i16",
+        NumberDataType::Int32 => "i32",
+        NumberDataType::Int64 => "i64",
+        NumberDataType::Float32 => "OrderedFloat<f32>",
+        NumberDataType::Float64 => "OrderedFloat<f64>",
     }
 }
 
-fn arithmetic_coercion(a: NumberTypeInfo, b: NumberTypeInfo, op: OP) -> DataType {
-    let is_signed = a.is_signed || b.is_signed;
-    let is_float = a.is_float || b.is_float;
-    let bit_width = a.bit_width.max(b.bit_width);
+fn arithmetic_coercion(a: NumberDataType, b: NumberDataType, op: OP) -> NumberDataType {
+    let is_signed = a.is_signed() || b.is_signed();
+    let is_float = a.is_float() || b.is_float();
+    let bit_width = a.bit_width().max(b.bit_width());
 
     match op {
-        OP::Plus | OP::Mul => {
-            let info = NumberTypeInfo {
-                is_signed,
-                is_float,
-                bit_width: next_bit_width(bit_width),
-            };
-
-            DataType::new_number(info)
-        }
+        OP::Plus | OP::Mul => NumberDataType::new(next_bit_width(bit_width), is_signed, is_float),
         OP::Modulo => {
             if is_float {
-                return DataType::Float64;
+                return NumberDataType::Float64;
             }
-            let result_is_signed = a.is_signed;
-            let right_size = b.bit_width;
+            let result_is_signed = a.is_signed();
+            let right_size = b.bit_width();
             let size_of_result = if result_is_signed {
                 next_bit_width(right_size)
             } else {
                 right_size
             };
 
-            let info = NumberTypeInfo {
-                is_signed: result_is_signed,
-                is_float: false,
-                bit_width: size_of_result,
-            };
-            DataType::new_number(info)
-        }
-        OP::Minus => {
-            let info = NumberTypeInfo {
-                is_signed: true,
-                is_float,
-                bit_width: next_bit_width(bit_width),
-            };
-            DataType::new_number(info)
-        }
-        OP::Div => DataType::Float64,
-        OP::IntDiv => {
-            let info = NumberTypeInfo {
-                is_signed,
-                is_float: false,
-                bit_width,
-            };
-            DataType::new_number(info)
-        }
-        OP::Super => {
-            let info = NumberTypeInfo {
-                is_signed,
-                is_float,
-                bit_width,
-            };
-            DataType::new_number(info)
+            NumberDataType::new(size_of_result, result_is_signed, false)
         }
+        OP::Minus => NumberDataType::new(next_bit_width(bit_width), true, is_float),
+        OP::Div => NumberDataType::Float64,
+        OP::IntDiv => NumberDataType::new(bit_width, is_signed, false),
+        OP::Super => NumberDataType::new(bit_width, is_signed, is_float),
     }
 }
 
-fn neg_coercion(a: NumberTypeInfo) -> DataType {
-    let bit_width = if a.is_signed {
-        a.bit_width
+fn neg_coercion(a: NumberDataType) -> NumberDataType {
+    let bit_width = if a.is_signed() {
+        a.bit_width()
     } else {
-        next_bit_width(a.bit_width)
+        next_bit_width(a.bit_width())
     };
 
-    let info = NumberTypeInfo {
-        is_float: a.is_float,
-        is_signed: true,
-        bit_width,
-    };
-    DataType::new_number(info)
+    NumberDataType::new(bit_width, true, a.is_float())
 }
 
 const fn next_bit_width(width: u8) -> u8 {

src/query/codegen/src/writes/arithmetics_type_v2.rs

@@ -25,7 +25,7 @@ enum-as-inner = "0.4"
 itertools = "0.10"
 match-template = "0.0.1"
 num-traits = "0.2.15"
-ordered-float = { version = "3.0", features = ["serde"] }
+ordered-float = { git = "https://github.com/andylokandy/rust-ordered-float.git", branch = "as", features = ["serde"] }
 serde = "1.0"
 
 [dev-dependencies]