dameng_rust_sdk 0.1.3

//! Data types for Dameng Rust SDK

use chrono::{NaiveDate, NaiveDateTime};

use crate::error::{Error, Result as SdkResult};

/// Dameng database value representation
#[derive(Debug, Clone, PartialEq)]
pub enum DamengValue {
    /// NULL value
    Null,
    /// Integer value
    Int(i32),
    /// Big integer value
    BigInt(i64),
    /// Float value
    Float(f64),
    /// String value
    String(String),
    /// Boolean value
    Bool(bool),
    /// Decimal value (precision, scale, value)
    Decimal(u8, u8, String),
    /// Date value
    Date(NaiveDate),
    /// DateTime value
    DateTime(NaiveDateTime),
    /// Binary data
    Binary(Vec<u8>),
}

impl DamengValue {
    /// Check if the value is NULL
    pub fn is_null(&self) -> bool {
        matches!(self, DamengValue::Null)
    }
    
    /// Get the value as an integer
    pub fn as_int(&self) -> Option<i32> {
        match self {
            DamengValue::Int(v) => Some(*v),
            _ => None,
        }
    }
    
    /// Get the value as a big integer
    pub fn as_big_int(&self) -> Option<i64> {
        match self {
            DamengValue::BigInt(v) => Some(*v),
            DamengValue::Int(v) => Some(*v as i64),
            _ => None,
        }
    }
    
    /// Get the value as a float
    pub fn as_float(&self) -> Option<f64> {
        match self {
            DamengValue::Float(v) => Some(*v),
            DamengValue::Int(v) => Some(*v as f64),
            DamengValue::BigInt(v) => Some(*v as f64),
            _ => None,
        }
    }
    
    /// Get the value as a string
    pub fn as_string(&self) -> Option<&str> {
        match self {
            DamengValue::String(v) => Some(v),
            _ => None,
        }
    }
    
    /// Get the value as a boolean
    pub fn as_bool(&self) -> Option<bool> {
        match self {
            DamengValue::Bool(v) => Some(*v),
            _ => None,
        }
    }
    
    /// Get the value as a date
    pub fn as_date(&self) -> Option<&NaiveDate> {
        match self {
            DamengValue::Date(v) => Some(v),
            _ => None,
        }
    }
    
    /// Get the value as a datetime
    pub fn as_datetime(&self) -> Option<&NaiveDateTime> {
        match self {
            DamengValue::DateTime(v) => Some(v),
            _ => None,
        }
    }
    
    /// Get the value as binary data
    pub fn as_binary(&self) -> Option<&[u8]> {
        match self {
            DamengValue::Binary(v) => Some(v),
            _ => None,
        }
    }
}

/// Trait for converting from DamengValue to Rust types
pub trait FromDamengValue: Sized {
    /// Convert from DamengValue to Self
    fn from_dameng_value(value: DamengValue) -> SdkResult<Self>;
}

/// Trait for converting from Rust types to DamengValue
pub trait ToDamengValue {
    /// Convert from Self to DamengValue
    fn to_dameng_value(&self) -> SdkResult<DamengValue>;
}

impl FromDamengValue for i32 {
    fn from_dameng_value(value: DamengValue) -> SdkResult<Self> {
        value.as_int().ok_or_else(|| Error::type_conversion("Expected integer value").into())
    }
}

impl FromDamengValue for i64 {
    fn from_dameng_value(value: DamengValue) -> SdkResult<Self> {
        value.as_big_int().ok_or_else(|| Error::type_conversion("Expected big integer value").into())
    }
}

impl FromDamengValue for f64 {
    fn from_dameng_value(value: DamengValue) -> SdkResult<Self> {
        value.as_float().ok_or_else(|| Error::type_conversion("Expected float value").into())
    }
}

impl FromDamengValue for String {
    fn from_dameng_value(value: DamengValue) -> SdkResult<Self> {
        match value {
            DamengValue::String(s) => Ok(s),
            DamengValue::Int(i) => Ok(i.to_string()),
            DamengValue::BigInt(i) => Ok(i.to_string()),
            DamengValue::Float(f) => Ok(f.to_string()),
            DamengValue::Bool(b) => Ok(b.to_string()),
            DamengValue::Date(d) => Ok(d.to_string()),
            DamengValue::DateTime(dt) => Ok(dt.to_string()),
            _ => Err(Error::type_conversion("Expected string value").into()),
        }
    }
}

impl FromDamengValue for bool {
    fn from_dameng_value(value: DamengValue) -> SdkResult<Self> {
        value.as_bool().ok_or_else(|| Error::type_conversion("Expected boolean value").into())
    }
}

impl FromDamengValue for NaiveDate {
    fn from_dameng_value(value: DamengValue) -> SdkResult<Self> {
        value.as_date().cloned().ok_or_else(|| Error::type_conversion("Expected date value").into())
    }
}

impl FromDamengValue for NaiveDateTime {
    fn from_dameng_value(value: DamengValue) -> SdkResult<Self> {
        value.as_datetime().cloned().ok_or_else(|| Error::type_conversion("Expected datetime value").into())
    }
}

impl ToDamengValue for i32 {
    fn to_dameng_value(&self) -> SdkResult<DamengValue> {
        Ok(DamengValue::Int(*self))
    }
}

impl ToDamengValue for i64 {
    fn to_dameng_value(&self) -> SdkResult<DamengValue> {
        Ok(DamengValue::BigInt(*self))
    }
}

impl ToDamengValue for f64 {
    fn to_dameng_value(&self) -> SdkResult<DamengValue> {
        Ok(DamengValue::Float(*self))
    }
}

impl ToDamengValue for str {
    fn to_dameng_value(&self) -> SdkResult<DamengValue> {
        Ok(DamengValue::String(self.to_string()))
    }
}

impl ToDamengValue for String {
    fn to_dameng_value(&self) -> SdkResult<DamengValue> {
        Ok(DamengValue::String(self.clone()))
    }
}

impl ToDamengValue for bool {
    fn to_dameng_value(&self) -> SdkResult<DamengValue> {
        Ok(DamengValue::Bool(*self))
    }
}

impl ToDamengValue for NaiveDate {
    fn to_dameng_value(&self) -> SdkResult<DamengValue> {
        Ok(DamengValue::Date(*self))
    }
}

impl ToDamengValue for NaiveDateTime {
    fn to_dameng_value(&self) -> SdkResult<DamengValue> {
        Ok(DamengValue::DateTime(*self))
    }
}

impl ToDamengValue for &[u8] {
    fn to_dameng_value(&self) -> SdkResult<DamengValue> {
        Ok(DamengValue::Binary(self.to_vec()))
    }
}

impl ToDamengValue for Vec<u8> {
    fn to_dameng_value(&self) -> SdkResult<DamengValue> {
        Ok(DamengValue::Binary(self.clone()))
    }
}