release v3.2.1 to github

Author: YutongGong

.gitignore

@@ -1,4 +1,4 @@
 /target
 .vscode
 Cargo.lock
-
+src/main.rs

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "dolphindb"
-version = "3.2.0"
+version = "3.2.1"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 description = "A Rust native API for DolphinDB"

examples/data_forms.rs

@@ -0,0 +1,34 @@
+use dolphindb::types::*;
+
+fn main() {
+    // create empty data forms
+    let _v = Vector::<Int>::new();
+    let _v = Vector::<Int>::with_capacity(1);
+    let _s = Set::<Int>::new();
+    let _s = Set::<Int>::with_capacity(1);
+    // Value type of dictionary is ANY
+    let _d = Dictionary::<Int>::new();
+    let _d = Dictionary::<Int>::with_capacity(1);
+
+    let _v = Vector::<Int>::from_raw(&[1]);
+    let _v = IntVector::from_raw(&[1]);
+
+    let _a = IntArrayVector::new();
+
+    // use data forms
+    let mut v = IntVector::new();
+    // Usage of dolphindb's Vector is similar to Vec<T>
+    v.push(1.into());
+    let _t = v[0];
+    let mut s = Set::<Int>::new();
+    // Usage of dolphindb's Set is similar to HashSet<T>
+    s.insert(1.into());
+    s.get(&Int::new(1));
+    let mut d = Dictionary::<Int>::new();
+    // Usage of dolphindb's Dictionary is similar to HashMap<T, Any>
+    d.insert(1.into(), Int::new(2));
+    d.insert(1.into(), Double::new(2.0));
+    d.get(&Int::new(1));
+    let mut a = IntArrayVector::new();
+    a.push(vec![1, 2, 3]);
+}

examples/quick_start.rs

@@ -1,7 +1,6 @@
+use dolphindb::{client::ClientBuilder, types::*};
 use std::collections::HashMap;
 
-use dolphindb::client::ClientBuilder;
-
 #[tokio::main]
 async fn main() {
     // Since the client supports multiple configurations, we provide the ClientBuilder utility class to assist in creating client objects.
@@ -18,19 +17,38 @@ async fn main() {
     // Here, a pair object is created on the server.
     let res = client.run_script("a = pair(`a, `b)").await.unwrap();
     // If the DolphinDB script does not return a value, the returned `res` is None.
-    if let Some(ref c) = res {
-        println!("{}", c);
+    if let None = res {
+        println!("This script has no return value.");
     }
     // If the DolphinDB script has a return value, the returned `res` is a ConstantImpl.
     let res = client.run_script("a").await.unwrap();
     if let Some(ref c) = res {
         println!("{}", c);
     }
 
+    // Another usage of the client is executing a DolphinDB function
+    // To execute a function, you need the function name and it's argument list
+    // A function may have no argument and a return value.
+    let ver = client.run_function("version", &[]).await.unwrap().unwrap();
+    println!("{ver}");
+    // Or one argument
+    let typestr = client
+        .run_function("typestr", &[res.clone().unwrap()])
+        .await
+        .unwrap()
+        .unwrap();
+    println!("{typestr}");
+    // Or more
+    let sum = client
+        .run_function("add", &[Int::new(1).into(), Int::new(2).into()])
+        .await
+        .unwrap()
+        .unwrap();
+    println!("{sum}");
+
     // The client can also upload data from Rust to the server and generate a variable.
     let mut variables = HashMap::new();
     // In this case, the HashMap's key is the variable name, and the value is the variable wrapped in ConstantImpl.
     variables.insert("a".to_string(), res.unwrap().clone());
-    // The client can also upload data from Rust to the server and generate a variable.
     client.upload(&variables).await.unwrap();
 }

examples/table.rs

@@ -0,0 +1,52 @@
+use dolphindb::{
+    client::ClientBuilder,
+    error::Error,
+    types::{ConstantImpl, DoubleArrayVector, Int, IntVector, TableBuilder, VectorImpl},
+};
+
+async fn table_writer() -> Result<(), Error> {
+    let mut builder = ClientBuilder::new("127.0.0.1:8848");
+    builder.with_auth(("admin", "123456"));
+    let mut client = builder.connect().await.unwrap();
+
+    let mut prices = DoubleArrayVector::new();
+    let price1 = vec![1.1, 2.2, 3.3];
+    prices.push(price1);
+    println!("{prices}");
+
+    // write one row
+    let c_int = ConstantImpl::from(Int::new(1));
+    let c_double_array_vector = ConstantImpl::Vector(VectorImpl::from(prices.clone()));
+    let res = client
+        .run_function("tableInsert{testTable}", &[c_int, c_double_array_vector])
+        .await
+        .unwrap()
+        .unwrap();
+    println!("{res}");
+
+    // write a table
+    let price2 = vec![4.4, 5.5];
+    prices.push(price2);
+    let v_int = IntVector::from_raw(&[2, 3]).into();
+    let v_double_array_vector = VectorImpl::from(prices);
+    println!("{v_double_array_vector}");
+    let mut builder = TableBuilder::new();
+    builder.with_name("my_table".to_string());
+    builder.with_contents(
+        vec![v_int, v_double_array_vector],
+        vec!["volume".to_string(), "price".to_string()],
+    );
+    let table = builder.build().unwrap();
+    println!("{table}");
+    let res = client
+        .run_function("tableInsert{testTable}", &[table.into()])
+        .await?
+        .unwrap();
+    println!("{res}");
+    Ok(())
+}
+
+#[tokio::main]
+async fn main() {
+    table_writer().await.unwrap();
+}

examples/table_writer.rs

@@ -1,65 +1,134 @@
-use dolphindb::{
-    client::ClientBuilder,
-    types::*,
-};
+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();
+    let mut variables: HashMap<String, ConstantImpl> = 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"))));
+    variables.insert("Int".to_owned(), Int::new(1).into());
+    variables.insert("Double".to_owned(), Double::new(1.0).into());
+    variables.insert(
+        "String".to_owned(),
+        DolphinString::new("str".to_owned()).into(),
+    );
 
     // 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()));
+    variables.insert("myVoid".to_owned(), Void::new(()).into());
+    variables.insert("myBool".to_owned(), Bool::new(true).into());
+    variables.insert("myChar".to_owned(), Char::new('a' as i8).into());
+    variables.insert("myShort".to_owned(), Short::new(1i16).into());
+    variables.insert("myInt".to_owned(), Int::new(2i32).into());
+    variables.insert("myLong".to_owned(), Long::new(3i64).into());
+    variables.insert("myFloat".to_owned(), Float::new(1.1f32).into());
+    variables.insert("myDouble".to_owned(), Double::new(1.2f64).into());
+    variables.insert(
+        "myDecimal32".to_owned(),
+        Decimal32::from_raw(100i32, 1).unwrap().into(),
+    );
+    variables.insert(
+        "myDecimal64".to_owned(),
+        Decimal64::from_raw(10000i64, 2).unwrap().into(),
+    );
+    variables.insert(
+        "myDecimal128".to_owned(),
+        Decimal128::from_raw(1000000i128, 3).unwrap().into(),
+    );
 
     // 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()));
+    // unix timestamp (milliseconds)
+    let unix_timestamp = 1735660800_000i64;
+    variables.insert(
+        "myDate".to_owned(),
+        Date::from_raw(unix_timestamp / 86400_000).unwrap().into(),
+    );
+    variables.insert(
+        "myDateTime".to_owned(),
+        DateTime::from_raw((unix_timestamp / 1000) as i32)
+            .unwrap()
+            .into(),
+    );
+    variables.insert(
+        "myTimestamp".to_owned(),
+        Timestamp::from_raw(unix_timestamp).unwrap().into(),
+    );
+    variables.insert(
+        "myNanoTimestamp".to_owned(),
+        NanoTimestamp::from_raw(unix_timestamp * 1000_000)
+            .unwrap()
+            .into(),
+    );
+    variables.insert(
+        "myMonth".to_owned(),
+        Month::from_ym(2025, 1).unwrap().into(),
+    );
+    variables.insert(
+        "myMinute".to_owned(),
+        Minute::from_hm(17, 30).unwrap().into(),
+    );
+    variables.insert(
+        "mySecond".to_owned(),
+        Second::from_hms(17, 30, 0).unwrap().into(),
+    );
+    variables.insert(
+        "myTime".to_owned(),
+        Time::from_hms_milli(17, 30, 0, 100).unwrap().into(),
+    );
+    variables.insert(
+        "myNanoTime".to_owned(),
+        NanoTime::from_hms_nano(17, 30, 0, 100_000_000u32)
+            .unwrap()
+            .into(),
+    );
+    variables.insert(
+        "myDateHour".to_owned(),
+        DateHour::from_ymd_h(2025, 1, 1, 17).unwrap().into(),
+    );
+
+    // other types
+    variables.insert(
+        "myString".to_owned(),
+        DolphinString::new("str".to_owned()).into(),
+    );
+    variables.insert("myBlob".to_owned(), Blob::new(vec![b'a']).into());
+    variables.insert("mySymbol".to_owned(), Symbol::new("1".to_owned()).into());
 
     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());
+    let vars = [
+        "myBool",
+        "myChar",
+        "myShort",
+        "myInt",
+        "myLong",
+        "myFloat",
+        "myDouble",
+        "myDecimal32",
+        "myDecimal64",
+        "myDecimal128",
+        "myDate",
+        "myTimestamp",
+        "myNanoTimestamp",
+        "myDateTime",
+        "myMonth",
+        "mySecond",
+        "myTime",
+        "myNanoTime",
+        "myDateHour",
+        "myString",
+        "myBlob",
+        "mySymbol",
+    ];
+    for var in vars {
+        println!(
+            "{}: {}",
+            var,
+            client.run_script(var).await.unwrap().unwrap()
+        );
+    }
 }