feat: added marco implement_from_tuple to implement ORM function (#73)

* fix: `is-terminal` error

* feat: added marco `implement_from_tuple` to implement ORM function

* doc: marco `implement_from_tuple`

* config: version up

* refactor: remove kip_marco crate and move to marco mod

* fix(marco): unresolved import

* docs: add orm mapping

Author: KKould

Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "kip-sql"
-version = "0.0.1-alpha.0"
+version = "0.0.1-alpha.3"
 edition = "2021"
 authors = ["Kould <kould2333@gmail.com>", "Xwg <loloxwg@gmail.com>"]
 description = "build the SQL layer of KipDB database"
@@ -37,7 +37,7 @@ ahash = "0.8.3"
 lazy_static = "1.4.0"
 comfy-table = "7.0.1"
 bytes = "1.5.0"
-kip_db = "0.1.2-alpha.15"
+kip_db = "0.1.2-alpha.16"
 async-recursion = "1.0.5"
 rust_decimal = "1"
 

README.md

@@ -48,6 +48,33 @@ Storage Support:
 ![demo](./static/images/demo.png)
 
 ### Features
+- ORM Mapping
+```rust
+#[derive(Debug, Clone, Default)]
+pub struct Post {
+    pub post_title: String,
+    pub post_date: NaiveDateTime,
+    pub post_body: String,
+}
+
+implement_from_tuple!(Post, (
+    post_title: String => |post: &mut Post, value: DataValue| {
+        if let Some(title) = value.utf8() {
+            post.post_title = title;
+        }
+    },
+    post_date: NaiveDateTime => |post: &mut Post, value: DataValue| {
+        if let Some(date_time) = value.datetime() {
+            post.post_date = date_time;
+        }
+    },
+    post_body: String => |post: &mut Post, value: DataValue| {
+        if let Some(body) = value.utf8() {
+            post.post_body = body;
+        }
+    }
+));
+```
 - SQL field options
   - not null
   - null

rust-toolchain

@@ -1 +1 @@
-nightly-2023-04-07
+nightly-2023-09-29

src/lib.rs

@@ -6,7 +6,6 @@
 #![feature(slice_pattern)]
 #![feature(bound_map)]
 extern crate core;
-
 pub mod binder;
 pub mod catalog;
 pub mod db;
@@ -17,3 +16,4 @@ pub mod types;
 mod optimizer;
 pub mod execution;
 pub mod storage;
+pub mod marco;

src/marco/mod.rs

@@ -0,0 +1,121 @@
+/// # Examples
+///
+/// ```
+///struct MyStruct {
+///   c1: i32,
+///   c2: String,
+///}
+///
+///implement_from_tuple!(
+///     MyStruct, (
+///         c1: i32 => |inner: &mut MyStruct, value| {
+///             if let DataValue::Int32(Some(val)) = value {
+///                 inner.c1 = val;
+///             }
+///         },
+///         c2: String => |inner: &mut MyStruct, value| {
+///             if let DataValue::Utf8(Some(val)) = value {
+///                 inner.c2 = val;
+///             }
+///         }
+///     )
+/// );
+/// ```
+#[macro_export]
+macro_rules! implement_from_tuple {
+    ($struct_name:ident, ($($field_name:ident : $field_type:ty => $closure:expr),+)) => {
+        impl From<Tuple> for $struct_name {
+            fn from(tuple: Tuple) -> Self {
+                fn try_get<T: 'static>(tuple: &Tuple, field_name: &str) -> Option<DataValue> {
+                    let ty = LogicalType::type_trans::<T>()?;
+                    let (idx, _) = tuple.columns
+                        .iter()
+                        .enumerate()
+                        .find(|(_, col)| &col.name == field_name)?;
+
+                    DataValue::clone(&tuple.values[idx])
+                        .cast(&ty)
+                        .ok()
+                }
+
+                let mut struct_instance = $struct_name::default();
+                $(
+                    if let Some(value) = try_get::<$field_type>(&tuple, stringify!($field_name)) {
+                        $closure(
+                            &mut struct_instance,
+                            value
+                        );
+                    }
+                )+
+                struct_instance
+            }
+        }
+    };
+}
+
+#[cfg(test)]
+mod test {
+    use std::sync::Arc;
+    use crate::catalog::{ColumnCatalog, ColumnDesc};
+    use crate::types::LogicalType;
+    use crate::types::tuple::Tuple;
+    use crate::types::value::DataValue;
+
+    fn build_tuple() -> Tuple {
+        let columns = vec![
+            Arc::new(ColumnCatalog::new(
+                "c1".to_string(),
+                false,
+                ColumnDesc::new(LogicalType::Integer, true, false),
+                None
+            )),
+            Arc::new(ColumnCatalog::new(
+                "c2".to_string(),
+                false,
+                ColumnDesc::new(LogicalType::Varchar(None), false, false),
+                None
+            )),
+        ];
+        let values = vec![
+            Arc::new(DataValue::Int32(Some(9))),
+            Arc::new(DataValue::Utf8(Some("LOL".to_string()))),
+        ];
+
+        Tuple {
+            id: None,
+            columns,
+            values,
+        }
+    }
+
+    #[derive(Default, Debug, PartialEq)]
+    struct MyStruct {
+        c1: i32,
+        c2: String,
+    }
+
+    implement_from_tuple!(
+        MyStruct, (
+            c1: i32 => |inner: &mut MyStruct, value| {
+                if let DataValue::Int32(Some(val)) = value {
+                    inner.c1 = val;
+                }
+            },
+            c2: String => |inner: &mut MyStruct, value| {
+                if let DataValue::Utf8(Some(val)) = value {
+                    inner.c2 = val;
+                }
+            }
+        )
+    );
+
+    #[test]
+    fn test_from_tuple() {
+        let my_struct = MyStruct::from(build_tuple());
+
+        println!("{:?}", my_struct);
+
+        assert_eq!(my_struct.c1, 9);
+        assert_eq!(my_struct.c2, "LOL");
+    }
+}

src/types/mod.rs

@@ -3,6 +3,9 @@ pub mod value;
 pub mod tuple;
 pub mod index;
 
+use std::any::TypeId;
+use chrono::{NaiveDate, NaiveDateTime};
+use rust_decimal::Decimal;
 use serde::{Deserialize, Serialize};
 
 use sqlparser::ast::ExactNumberInfo;
@@ -37,6 +40,42 @@ pub enum LogicalType {
 }
 
 impl LogicalType {
+    pub fn type_trans<T: 'static>() -> Option<LogicalType> {
+        let type_id = TypeId::of::<T>();
+
+        if type_id == TypeId::of::<i8>() {
+            Some(LogicalType::Tinyint)
+        } else if type_id == TypeId::of::<i16>() {
+            Some(LogicalType::Smallint)
+        } else if type_id == TypeId::of::<i32>() {
+            Some(LogicalType::Integer)
+        } else if type_id == TypeId::of::<i64>() {
+            Some(LogicalType::Bigint)
+        } else if type_id == TypeId::of::<u8>() {
+            Some(LogicalType::UTinyint)
+        } else if type_id == TypeId::of::<u16>() {
+            Some(LogicalType::USmallint)
+        } else if type_id == TypeId::of::<u32>() {
+            Some(LogicalType::UInteger)
+        } else if type_id == TypeId::of::<u64>() {
+            Some(LogicalType::UBigint)
+        } else if type_id == TypeId::of::<f32>() {
+            Some(LogicalType::Float)
+        } else if type_id == TypeId::of::<f64>() {
+            Some(LogicalType::Double)
+        } else if type_id == TypeId::of::<NaiveDate>() {
+            Some(LogicalType::Date)
+        } else if type_id == TypeId::of::<NaiveDateTime>() {
+            Some(LogicalType::DateTime)
+        } else if type_id == TypeId::of::<Decimal>() {
+            Some(LogicalType::Decimal(None, None))
+        } else if type_id == TypeId::of::<String>() {
+            Some(LogicalType::Varchar(None))
+        } else {
+            None
+        }
+    }
+
     pub fn raw_len(&self) -> Option<usize> {
         match self {
             LogicalType::Invalid => Some(0),

src/types/value.rs

@@ -53,6 +53,38 @@ pub enum DataValue {
     Decimal(Option<Decimal>),
 }
 
+macro_rules! generate_get_option {
+    ($data_value:ident, $($prefix:ident : $variant:ident($field:ty)),*) => {
+        impl $data_value {
+            $(
+                pub fn $prefix(&self) -> $field {
+                    if let $data_value::$variant(Some(val)) = self {
+                        Some(val.clone())
+                    } else {
+                        None
+                    }
+                }
+            )*
+        }
+    };
+}
+
+generate_get_option!(DataValue,
+    bool : Boolean(Option<bool>),
+    float : Float32(Option<f32>),
+    double : Float64(Option<f64>),
+    i8 : Int8(Option<i8>),
+    i16 : Int16(Option<i16>),
+    i32 : Int32(Option<i32>),
+    i64 : Int64(Option<i64>),
+    u8 : UInt8(Option<u8>),
+    u16 : UInt16(Option<u16>),
+    u32 : UInt32(Option<u32>),
+    u64 : UInt64(Option<u64>),
+    utf8 : Utf8(Option<String>),
+    decimal : Decimal(Option<Decimal>)
+);
+
 impl PartialEq for DataValue {
     fn eq(&self, other: &Self) -> bool {
         use DataValue::*;
@@ -202,6 +234,22 @@ macro_rules! varchar_cast {
 }
 
 impl DataValue {
+    pub fn date(&self) -> Option<NaiveDate> {
+        if let DataValue::Date32(Some(val)) = self {
+            NaiveDate::from_num_days_from_ce_opt(*val)
+        } else {
+            None
+        }
+    }
+
+    pub fn datetime(&self) -> Option<NaiveDateTime> {
+        if let DataValue::Date64(Some(val)) = self {
+            NaiveDateTime::from_timestamp_opt(*val, 0)
+        } else {
+            None
+        }
+    }
+
     pub(crate) fn check_len(&self, logic_type: &LogicalType) -> Result<(), TypeError> {
         let is_over_len = match (logic_type, self) {
             (LogicalType::Varchar(Some(len)), DataValue::Utf8(Some(val))) => {