Add Inet, Mac data type

Author: wyhaya

Cargo.toml

@@ -12,6 +12,7 @@ repository = "https://github.com/crossdb-org/crossdb-rust.git"
 lru = "0.12"
 serde = "1.0"
 thiserror = "1.0"
+strum = { version = "0.26", features = ["derive"] }
 
 [build-dependencies]
 bindgen = "0.70"

crossdb

@@ -1,79 +1,60 @@
 use crate::*;
 use std::rc::Rc;
 use std::slice::Iter;
+use strum::{Display, FromRepr, IntoStaticStr};
 
 // https://github.com/crossdb-org/crossdb/blob/main/include/crossdb.h
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Display, IntoStaticStr, FromRepr)]
+#[repr(u32)]
 pub enum DataType {
-    Null,
-    TinyInt,
-    SmallInt,
-    Int,
-    BigInt,
-    UTinyInt,
-    USmallInt,
-    UInt,
-    UBigInt,
-    Float,
-    Double,
-    Timestamp,
-    Char,
-    Binary,
-    VChar,
-    VBinary,
-    Bool,
-    Max,
-}
-
-impl Display for DataType {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            DataType::Null => write!(f, "NULL"),
-            DataType::TinyInt => write!(f, "TINYINT"),
-            DataType::SmallInt => write!(f, "SMALLINT"),
-            DataType::Int => write!(f, "INT"),
-            DataType::BigInt => write!(f, "BIGINT"),
-            DataType::UTinyInt => write!(f, "UTINYINT"),
-            DataType::USmallInt => write!(f, "USMALLINT"),
-            DataType::UInt => write!(f, "UINT"),
-            DataType::UBigInt => write!(f, "UBIGINT"),
-            DataType::Float => write!(f, "FLOAT"),
-            DataType::Double => write!(f, "DOUBLE"),
-            DataType::Timestamp => write!(f, "TIMESTAMP"),
-            DataType::Char => write!(f, "CHAR"),
-            DataType::Binary => write!(f, "BINARY"),
-            DataType::VChar => write!(f, "VCHAR"),
-            DataType::VBinary => write!(f, "VBINARY"),
-            DataType::Bool => write!(f, "BOOL"),
-            DataType::Max => write!(f, "MAX"),
-        }
-    }
+    #[strum(serialize = "NULL")]
+    Null = xdb_type_t_XDB_TYPE_NULL,
+    #[strum(serialize = "TINYINT")]
+    TinyInt = xdb_type_t_XDB_TYPE_TINYINT,
+    #[strum(serialize = "SMALLINT")]
+    SmallInt = xdb_type_t_XDB_TYPE_SMALLINT,
+    #[strum(serialize = "INT")]
+    Int = xdb_type_t_XDB_TYPE_INT,
+    #[strum(serialize = "BIGINT")]
+    BigInt = xdb_type_t_XDB_TYPE_BIGINT,
+    #[strum(serialize = "UTINYINT")]
+    UTinyInt = xdb_type_t_XDB_TYPE_UTINYINT,
+    #[strum(serialize = "USMALLINT")]
+    USmallInt = xdb_type_t_XDB_TYPE_USMALLINT,
+    #[strum(serialize = "UINT")]
+    UInt = xdb_type_t_XDB_TYPE_UINT,
+    #[strum(serialize = "UBIGINT")]
+    UBigInt = xdb_type_t_XDB_TYPE_UBIGINT,
+    #[strum(serialize = "FLOAT")]
+    Float = xdb_type_t_XDB_TYPE_FLOAT,
+    #[strum(serialize = "DOUBLE")]
+    Double = xdb_type_t_XDB_TYPE_DOUBLE,
+    #[strum(serialize = "TIMESTAMP")]
+    Timestamp = xdb_type_t_XDB_TYPE_TIMESTAMP,
+    #[strum(serialize = "CHAR")]
+    Char = xdb_type_t_XDB_TYPE_CHAR,
+    #[strum(serialize = "BINARY")]
+    Binary = xdb_type_t_XDB_TYPE_BINARY,
+    #[strum(serialize = "VCHAR")]
+    VChar = xdb_type_t_XDB_TYPE_VCHAR,
+    #[strum(serialize = "VBINARY")]
+    VBinary = xdb_type_t_XDB_TYPE_VBINARY,
+    #[strum(serialize = "BOOL")]
+    Bool = xdb_type_t_XDB_TYPE_BOOL,
+    #[strum(serialize = "INET")]
+    Inet = xdb_type_t_XDB_TYPE_INET,
+    #[strum(serialize = "MAC")]
+    Mac = xdb_type_t_XDB_TYPE_MAC,
+    #[strum(serialize = "MAX")]
+    Max = xdb_type_t_XDB_TYPE_MAX,
 }
 
 impl DataType {
-    #[allow(non_upper_case_globals)]
     unsafe fn from_meta(meta: u64, col: u16) -> Self {
         let t = xdb_column_type(meta, col);
-        match t {
-            xdb_type_t_XDB_TYPE_NULL => Self::Null,
-            xdb_type_t_XDB_TYPE_TINYINT => Self::TinyInt,
-            xdb_type_t_XDB_TYPE_SMALLINT => Self::SmallInt,
-            xdb_type_t_XDB_TYPE_INT => Self::Int,
-            xdb_type_t_XDB_TYPE_BIGINT => Self::BigInt,
-            xdb_type_t_XDB_TYPE_UTINYINT => Self::UTinyInt,
-            xdb_type_t_XDB_TYPE_USMALLINT => Self::USmallInt,
-            xdb_type_t_XDB_TYPE_UINT => Self::UInt,
-            xdb_type_t_XDB_TYPE_UBIGINT => Self::UBigInt,
-            xdb_type_t_XDB_TYPE_FLOAT => Self::Float,
-            xdb_type_t_XDB_TYPE_DOUBLE => Self::Double,
-            xdb_type_t_XDB_TYPE_TIMESTAMP => Self::Timestamp,
-            xdb_type_t_XDB_TYPE_CHAR => Self::Char,
-            xdb_type_t_XDB_TYPE_BINARY => Self::Binary,
-            xdb_type_t_XDB_TYPE_VCHAR => Self::VChar,
-            xdb_type_t_XDB_TYPE_VBINARY => Self::VBinary,
-            xdb_type_t_XDB_TYPE_BOOL => Self::Bool,
-            xdb_type_t_XDB_TYPE_MAX => Self::Max,
-            _ => unreachable!(),
+        match Self::from_repr(t) {
+            Some(t) => t,
+            None => unreachable!(),
         }
     }
 }

src/column.rs

@@ -93,8 +93,10 @@ impl<'de> Deserializer<'de> for ValueDeserializer<'de> {
             Value::Timestamp(v) => visitor.visit_i64(v),
             Value::String(v) => visitor.visit_str(v),
             // TODO: Deserialize Binary to Vec<u8>
-            Value::Binary(_) => unimplemented!(),
+            Value::Binary(_) => todo!(),
             Value::Bool(v) => visitor.visit_bool(v),
+            Value::Inet(_) => todo!(),
+            Value::Mac(_) => todo!(),
         }
     }
 

src/de.rs

@@ -13,6 +13,8 @@ pub enum Value<'a> {
     String(&'a str),
     Binary(&'a [u8]),
     Bool(bool),
+    Inet([u8; 18]),
+    Mac([u8; 6]),
 }
 
 impl Display for Value<'_> {
@@ -29,6 +31,8 @@ impl Display for Value<'_> {
             Value::String(v) => write!(f, "{}", v),
             Value::Binary(v) => write!(f, "{:?}", v),
             Value::Bool(v) => write!(f, "{}", v),
+            Value::Inet(v) => write!(f, "{:?}", v),
+            Value::Mac(v) => write!(f, "{:?}", v),
         }
     }
 }
@@ -43,13 +47,18 @@ impl<'a> Value<'a> {
         t: DataType,
     ) -> Value<'a> {
         match t {
-            DataType::TinyInt => Value::I8(xdb_column_int(meta, row, col) as _),
-            DataType::SmallInt => Value::I16(xdb_column_int(meta, row, col) as _),
-            DataType::Int => Value::I32(xdb_column_int(meta, row, col) as _),
-            DataType::BigInt => Value::I64(xdb_column_int64(meta, row, col)),
-            DataType::Float => Value::F32(xdb_column_float(meta, row, col)),
-            DataType::Double => Value::F64(xdb_column_double(meta, row, col)),
-            DataType::Timestamp => Value::Timestamp(xdb_column_int64(meta, row, col)),
+            DataType::Null => Self::Null,
+            DataType::TinyInt => Self::I8(xdb_column_int(meta, row, col) as _),
+            DataType::UTinyInt => todo!(),
+            DataType::SmallInt => Self::I16(xdb_column_int(meta, row, col) as _),
+            DataType::USmallInt => todo!(),
+            DataType::Int => Self::I32(xdb_column_int(meta, row, col) as _),
+            DataType::UInt => todo!(),
+            DataType::BigInt => Self::I64(xdb_column_int64(meta, row, col)),
+            DataType::UBigInt => todo!(),
+            DataType::Float => Self::F32(xdb_column_float(meta, row, col)),
+            DataType::Double => Self::F64(xdb_column_double(meta, row, col)),
+            DataType::Timestamp => Self::Timestamp(xdb_column_int64(meta, row, col)),
             DataType::Char | DataType::VChar => {
                 let ptr = xdb_column_str(meta, row, col);
                 if ptr.is_null() {
@@ -61,8 +70,10 @@ impl<'a> Value<'a> {
                 // xdb_column_blob(meta, row, col, pLen);
                 todo!()
             }
-            DataType::Bool => Value::Bool(xdb_column_int(meta, row, col) == 1),
-            _ => unimplemented!(),
+            DataType::Bool => Self::Bool(xdb_column_int(meta, row, col) == 1),
+            DataType::Inet => todo!(),
+            DataType::Mac => todo!(),
+            DataType::Max => todo!(),
         }
     }
 }