数据类型

DolphinDB server 支持的数据类型均有特殊空值，在 Rust 中我们使用 Option<T> 来处理空值情形。需要注意的是，对于原本的特殊值，虽然可以在 Rust 中创建相应的 Some<T> 对象，但上传到 server 后还是空值。

Rust API 支持的 DolphinDB 数据类型与 Rust 原生类型对应关系如下（按照 DolphinDB 类型 ID 排列）：

let variable_viod = Void::new(());

let variable_bool = Bool::new(true);

let variable_char = Char::new('a' as i8);

let variable_short = Short::new(1i16);

let variable_int = Int::new(2i32);

let variable_long = Long::new(3i64);

let variable_date = Date::from_ymd(2025,1,1).unwrap();

let variable_month = Month::from_ym(2025, 2).unwrap();

let variable_time = Time::from_hms_milli(13, 30, 30, 100).unwrap();

let variable_minute = Minute::from_hm(11, 30).unwrap();

let variable_second = Second::from_hms(13, 30, 0).unwrap();

let variable_datetime = DateTime::from_raw(1735660800).unwrap();
// 或 let variable_datetime = DateTime::from_date_second(Date::from_ymd(2025, 1, 1).unwrap(),Second::from_hms(13, 30, 0).unwrap()).unwrap();

let variable_timestamp = Timestamp::from_raw(1735660800_000i64).unwrap();
// 或 let variable_timestamp = Timestamp::from_date_time(Date::from_ymd(2024, 12, 31).unwrap(),Time::from_hms_milli(16, 00, 00, 000).unwrap()).unwrap();

let variable_nanotime = NanoTime::from_hms_nano(17, 30,0,100_000_000u32).unwrap();
// 或 let variable_nanotime = NanoTime::from_raw(63000100000000u64).unwrap();

let variable_datetime = DateTime::from_raw(1735660800).unwrap();
// 或 let variable_nanotimestamp = NanoTimestamp::from_date_nanotime(Date::from_ymd(2025, 1, 1).unwrap(),NanoTime::from_hms_nano(17,30,0,100_000_000u32).unwrap()).unwrap();

let variable_float = Float::new(1.2f32);

let variable_double = Double::new(3.6f64);

let variable_symbol = Symbol::new(String::from("abc"));

let variable_string = DolphinString::new(String::from("abc"));

Decimal32::from_raw(100i32, 2).unwrap();

let variable_decimal64 = Decimal64::from_raw(20i64, 3).unwrap();

let variable_decimal128 = Decimal128::from_raw(1200i128, 3).unwrap();

以下列举了 Rust API 支持的 DolphinDB 数据类型与 Rust 原生类型的转换示例：

use dolphindb::{
    client::ClientBuilder,
    types::*,
};
use std::collections::HashMap;

#[tokio::main]
async fn main() {
    let mut builder = ClientBuilder::new("127.0.0.1:8848");
    builder.with_auth(("admin", "123456"));
    let mut client = builder.connect().await.unwrap();
    let mut variables = HashMap::new();

    // basic examples
    variables.insert("Int".to_string(), ConstantImpl::from(Int::new(1)));
    variables.insert("Double".to_string(), ConstantImpl::from(Double::new(1.0)));
    variables.insert("String".to_string(), ConstantImpl::from(DolphinString::new(String::from("1"))));

    // numeric types
    variables.insert("myVoid".to_string(), ConstantImpl::from(Void::new(())));
    variables.insert("myBool".to_string(), ConstantImpl::from(Bool::new(true)));
    variables.insert("myChar".to_string(), ConstantImpl::from(Char::new('a' as i8)));
    variables.insert("myShort".to_string(), ConstantImpl::from(Short::new(1i16)));
    variables.insert("myInt".to_string(), ConstantImpl::from(Int::new(2i32)));
    variables.insert("myLong".to_string(), ConstantImpl::from(Long::new(3i64)));
    variables.insert("myFloat".to_string(), ConstantImpl::from(Float::new(1.1f32)));
    variables.insert("myDouble".to_string(), ConstantImpl::from(Double::new(1.2f64)));
    variables.insert("myDecimal32".to_string(), ConstantImpl::from(Decimal32::from_raw(100i32, 1).unwrap()));
    variables.insert("myDecimal64".to_string(), ConstantImpl::from(Decimal64::from_raw(10000i64, 2).unwrap()));
    variables.insert("myDecimal128".to_string(), ConstantImpl::from(Decimal128::from_raw(1000000i128, 3).unwrap()));

    // temporal types
    variables.insert("myDate".to_string(), ConstantImpl::from(Date::from_raw(20089).unwrap()));
    variables.insert("myTimestamp".to_string(), ConstantImpl::from(Timestamp::from_raw(1735660800_000i64).unwrap()));
    variables.insert("myNanoTimestamp".to_string(), ConstantImpl::from(NanoTimestamp::from_raw(1735660800_000_000_000i64).unwrap()));
    variables.insert("myMonth".to_string(), ConstantImpl::from(Month::from_ym(2025, 1).unwrap()));
    variables.insert("myMinute".to_string(), ConstantImpl::from(Minute::from_hm(17, 30).unwrap()));
    variables.insert("mySecond".to_string(), ConstantImpl::from(Second::from_hms(17, 30, 0).unwrap()));
    variables.insert("myTime".to_string(), ConstantImpl::from(Time::from_hms_milli(17, 30, 0, 100).unwrap()));
    variables.insert("myDateTime".to_string(), ConstantImpl::from(DateTime::from_raw(1735660800).unwrap()));
    variables.insert("myNanoTime".to_string(), ConstantImpl::from(NanoTime::from_hms_nano(17, 30,0,100_000_000u32).unwrap()));

    client.upload(&variables).await.unwrap();

    // Void is not uploaded
    // println!("myVoid: {}", client.run_script("myVoid").await.unwrap().unwrap());
    println!("myBool: {}", client.run_script("myBool").await.unwrap().unwrap());
    println!("myChar: {}", client.run_script("myChar").await.unwrap().unwrap());
    println!("myShort: {}", client.run_script("myShort").await.unwrap().unwrap());
    println!("myInt: {}", client.run_script("myInt").await.unwrap().unwrap());
    println!("myLong: {}", client.run_script("myLong").await.unwrap().unwrap());
    println!("myFloat: {}", client.run_script("myFloat").await.unwrap().unwrap());
    println!("myDouble: {}", client.run_script("myDouble").await.unwrap().unwrap());
    println!("myDecimal32: {}", client.run_script("myDecimal32").await.unwrap().unwrap());
    println!("myDecimal64: {}", client.run_script("myDecimal64").await.unwrap().unwrap());
    println!("myDecimal128: {}", client.run_script("myDecimal128").await.unwrap().unwrap());
    println!("myDate: {}", client.run_script("myDate").await.unwrap().unwrap());
    println!("myTimestamp: {}", client.run_script("myTimestamp").await.unwrap().unwrap());
    println!("myNanoTimestamp: {}", client.run_script("myNanoTimestamp").await.unwrap().unwrap());
    println!("myMonth: {}", client.run_script("myMonth").await.unwrap().unwrap());
    println!("mySecond: {}", client.run_script("mySecond").await.unwrap().unwrap());
    println!("myTime: {}", client.run_script("myTime").await.unwrap().unwrap());
    println!("myDateTime: {}", client.run_script("myDateTime").await.unwrap().unwrap());
    println!("myNanoTime: {}", client.run_script("myNanoTime").await.unwrap().unwrap());
}