feat: add Int8 data type support (#9)

Author: CadyLinn

src/common/mod.rs

@@ -32,6 +32,7 @@ pub mod value_generator;
 /// inside `GeneartedValue` type.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum FuzzerDataType {
+    Int8,
     Int32,
     Int64,
     UInt32,
@@ -57,6 +58,7 @@ impl FuzzerDataType {
     /// Convert fuzzer data type to DataFusion data type
     pub fn to_datafusion_type(&self) -> DataType {
         match self {
+            FuzzerDataType::Int8 => DataType::Int8,
             FuzzerDataType::Int32 => DataType::Int32,
             FuzzerDataType::Int64 => DataType::Int64,
             FuzzerDataType::UInt32 => DataType::UInt32,
@@ -90,6 +92,7 @@ impl FuzzerDataType {
     /// Convert DataFusion data type to fuzzer data type (if supported)
     pub fn from_datafusion_type(data_type: &DataType) -> Option<Self> {
         match data_type {
+            DataType::Int8 => Some(FuzzerDataType::Int8),
             DataType::Int32 => Some(FuzzerDataType::Int32),
             DataType::Int64 => Some(FuzzerDataType::Int64),
             DataType::UInt32 => Some(FuzzerDataType::UInt32),
@@ -119,6 +122,7 @@ impl FuzzerDataType {
     /// Get the display name for column naming
     pub fn display_name(&self) -> &'static str {
         match self {
+            FuzzerDataType::Int8 => "int8",
             FuzzerDataType::Int32 => "int32",
             FuzzerDataType::Int64 => "int64",
             FuzzerDataType::UInt32 => "uint32",
@@ -137,7 +141,8 @@ impl FuzzerDataType {
 
     pub fn is_numeric(&self) -> bool {
         match self {
-            FuzzerDataType::Int32
+            FuzzerDataType::Int8
+            | FuzzerDataType::Int32
             | FuzzerDataType::Int64
             | FuzzerDataType::UInt32
             | FuzzerDataType::UInt64
@@ -159,7 +164,8 @@ impl FuzzerDataType {
             | FuzzerDataType::Time64Nanosecond
             | FuzzerDataType::Timestamp
             | FuzzerDataType::IntervalMonthDayNano => true,
-            FuzzerDataType::Int32
+            FuzzerDataType::Int8
+            | FuzzerDataType::Int32
             | FuzzerDataType::Int64
             | FuzzerDataType::UInt32
             | FuzzerDataType::UInt64
@@ -180,6 +186,7 @@ impl FuzzerDataType {
     /// Convert to SQL type string for CREATE TABLE statements
     pub fn to_sql_type(&self) -> &'static str {
         match self {
+            FuzzerDataType::Int8 => "TINYINT",
             FuzzerDataType::Int32 => "INT",
             FuzzerDataType::Int64 => "BIGINT",
             FuzzerDataType::UInt32 => "INT UNSIGNED",
@@ -215,6 +222,7 @@ static AVAILABLE_DATA_TYPES: OnceLock<Vec<FuzzerDataType>> = OnceLock::new();
 pub fn init_available_data_types() {
     AVAILABLE_DATA_TYPES.get_or_init(|| {
         vec![
+            FuzzerDataType::Int8,
             FuzzerDataType::Int32,
             FuzzerDataType::Int64,
             FuzzerDataType::UInt32,
@@ -377,6 +385,21 @@ mod tests {
     use super::*;
     use crate::common::rng::rng_from_seed;
 
+    #[test]
+    fn test_int8_type_properties() {
+        let int8_type = FuzzerDataType::Int8;
+
+        assert_eq!(int8_type.to_datafusion_type(), DataType::Int8);
+        assert_eq!(
+            FuzzerDataType::from_datafusion_type(&DataType::Int8),
+            Some(FuzzerDataType::Int8)
+        );
+        assert_eq!(int8_type.display_name(), "int8");
+        assert_eq!(int8_type.to_sql_type(), "TINYINT");
+        assert!(int8_type.is_numeric());
+        assert!(!int8_type.is_time());
+    }
+
     #[test]
     fn test_simplified_decimal_type() {
         // Test that the simplified Decimal type works correctly

src/common/value_generator.rs

@@ -6,6 +6,7 @@ use std::sync::Arc;
 /// Raw value representation for generated data
 #[derive(Debug, Clone)]
 pub enum GeneratedValue {
+    Int8(i8),
     Int32(i32),
     Int64(i64),
     UInt32(u32),
@@ -60,6 +61,11 @@ pub fn generate_value(
     }
 
     match fuzzer_type {
+        FuzzerDataType::Int8 => {
+            let value = rng.random_range(config.int_range.0 as i8..=config.int_range.1 as i8);
+            GeneratedValue::Int8(value)
+        }
+
         FuzzerDataType::Int32 => {
             let value = rng.random_range(config.int_range.0..=config.int_range.1);
             GeneratedValue::Int32(value)
@@ -190,6 +196,7 @@ impl GeneratedValue {
     /// Convert to SQL string representation
     pub fn to_sql_string(&self) -> String {
         match self {
+            GeneratedValue::Int8(v) => v.to_string(),
             GeneratedValue::Int32(v) => v.to_string(),
             GeneratedValue::Int64(v) => v.to_string(),
             GeneratedValue::UInt32(v) => v.to_string(),
@@ -341,6 +348,7 @@ impl GeneratedValue {
         use datafusion::scalar::ScalarValue;
 
         match self {
+            GeneratedValue::Int8(v) => ScalarValue::Int8(Some(*v)),
             GeneratedValue::Int32(v) => ScalarValue::Int32(Some(*v)),
             GeneratedValue::Int64(v) => ScalarValue::Int64(Some(*v)),
             GeneratedValue::UInt32(v) => ScalarValue::UInt32(Some(*v)),
@@ -509,6 +517,32 @@ mod tests {
     use super::*;
     use crate::common::rng::rng_from_seed;
 
+    #[test]
+    fn test_int8_value_generation_and_conversions() {
+        let mut rng = rng_from_seed(42);
+        let config = ValueGenerationConfig {
+            nullable: false,
+            int_range: (-128, 127),
+            ..ValueGenerationConfig::default()
+        };
+
+        for _ in 0..100 {
+            let value = generate_value(&mut rng, &FuzzerDataType::Int8, &config);
+
+            match &value {
+                GeneratedValue::Int8(v) => {
+                    assert!((-128..=127).contains(v));
+                    assert_eq!(value.to_sql_string(), v.to_string());
+                    assert_eq!(
+                        value.to_scalar_value(),
+                        datafusion::scalar::ScalarValue::Int8(Some(*v))
+                    );
+                }
+                other => panic!("Expected Int8 value, got: {other:?}"),
+            }
+        }
+    }
+
     #[test]
     fn test_cached_config_in_runtime_context() {
         // Test that RuntimeContext has the expected cached config