ArikeDB Rust Library

Welcome to the ArikeDB Rust library! This library provides an interface to interact with the Arike Database, an advanced real-time database solution. This documentation will guide you through the process of setting up and using the library effectively.

Getting Started

Installation

To use the ArikeDB Rust library, add it to your Cargo.toml:

[dependencies]
arikedb = "*"
tokio = {version = "*", features = ["full"]}

Connecting to ArikeDB

To connect to an ArikeDB server instance, bring ArikedbClient into scope and instantiate it by calling the connect function.

Basic Connection

use arikedb::ArikedbClient;
use arikedb::{Variable, VariableType, Epoch, VarEvent, Event};

#[tokio::main]
async fn main() {
    let mut client = ArikedbClient::connect(
        "127.0.0.1", // host
        6923,        // port
        false,       // use_ssl
        None,        // ca_cert
        None,        // client_cert
        None         // client_key
    ).await.unwrap();
}

Connection with Authentication

If the server requires authentication, you need to authenticate after connecting.

use arikedb::ArikedbClient;
use arikedb::{Variable, VariableType, Epoch, VarEvent, Event};

#[tokio::main]
async fn main() {
    let mut client = ArikedbClient::connect(
        "127.0.0.1", // host
        6923,        // port
        false        // use_ssl
        None,        // ca_cert
        None,        // client_cert
        None         // client_key
    ).await.unwrap();

    client.authenticate("username", "password").await.unwrap();
}

Creating Collections

ArikeDB organizes data into collections. Each collection has a name and a set of variables. To create multiple collections in a single call:

client.create_collections(&vec!["collection1", "collection2", "collection3"]).await.unwrap();

Deleting Collections

client.delete_collections(&vec!["collection2", "collection3"]).await.unwrap();

Listing Collections

let collections = client.list_collections().await.unwrap();

for collection in collections {
    println!("{:?}", collection);
}

Output:

Collection { name: "collection1" }
Collection { name: "collection2" }

Creating Variables

let variables = vec![
    Variable { name: String::from("var1"), vtype: VariableType::I32, buffer_size: 10 },
    Variable { name: String::from("var2"), vtype: VariableType::I32, buffer_size: 5 },
    Variable { name: String::from("var3"), vtype: VariableType::I32, buffer_size: 4 },
    Variable { name: String::from("var4"), vtype: VariableType::I32, buffer_size: 4 },
];

client.create_variables("collection1", variables).await.unwrap();

Deleting Variables

client.delete_variables("collection1", &vec!["var3", "var4"]).await.unwrap();

Listing Variables

let variables = client.list_variables("collection1").await.unwrap();

for variable in variables {
    println!("{:?}", variable);
}

Output:

Variable { name: "var1", vtype: I32, buffer_size: 10 }
Variable { name: "var2", vtype: I32, buffer_size: 5 }

Setting Variables Values

client.set_variables(
    "collection1",
    vec!["var1", "var2"],
    SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_micros(),
    vec!["-235", "48"],
    Epoch::Microsecond
).await.unwrap();

Getting Variables Values

let derived_order = 0;
let data = client.get_variables("collection1", vec!["var1", "var2"], derived_order, Epoch::Nanosecond).await.unwrap();

for point in data {
    println!("{:?}", point);
}

Output:

DataPoint { name: "var1", vtype: I32, timestamp: "1720927547279880000", epoch: Nanosecond, value: "-235" }
DataPoint { name: "var2", vtype: I32, timestamp: "1720927547279880000", epoch: Nanosecond, value: "48" }

Subscribe to Variables Events

Events are generated over variables when they ar set and event condition happens.

tokio::spawn(
    client.subscribe_variables(
        "collection1",
        vec!["var1", "var2"],
        vec![
            VarEvent { event: Event::OnRise, ..Default::default() },
            VarEvent { event: Event::OnValueEqVal, value: String::from("56"), ..Default::default() },
        ],
        |point| {
            println!("{:?}", point);
        }
    ).await.unwrap()
);

for i in 0..10 {
    client.set_variables(
        "collection1",
        vec!["var1", "var2"],
        SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_micros(),
        vec![(50 + i).to_string().as_str(), (60 - i).to_string().as_str()],
        Epoch::Microsecond
    ).await.unwrap();
    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
}

Output:

DataPoint { name: "var1", vtype: I32, timestamp: "1720927881619292000", epoch: Nanosecond, value: "50" }
DataPoint { name: "var2", vtype: I32, timestamp: "1720927881619292000", epoch: Nanosecond, value: "60" }
DataPoint { name: "var1", vtype: I32, timestamp: "1720927882629171000", epoch: Nanosecond, value: "51" }
DataPoint { name: "var1", vtype: I32, timestamp: "1720927883638571000", epoch: Nanosecond, value: "52" }
DataPoint { name: "var1", vtype: I32, timestamp: "1720927884652619000", epoch: Nanosecond, value: "53" }
DataPoint { name: "var1", vtype: I32, timestamp: "1720927885664589000", epoch: Nanosecond, value: "54" }
DataPoint { name: "var2", vtype: I32, timestamp: "1720927885664589000", epoch: Nanosecond, value: "56" }
DataPoint { name: "var1", vtype: I32, timestamp: "1720927886673866000", epoch: Nanosecond, value: "55" }
DataPoint { name: "var1", vtype: I32, timestamp: "1720927887693254000", epoch: Nanosecond, value: "56" }
DataPoint { name: "var1", vtype: I32, timestamp: "1720927888703026000", epoch: Nanosecond, value: "57" }
DataPoint { name: "var1", vtype: I32, timestamp: "1720927889717038000", epoch: Nanosecond, value: "58" }
DataPoint { name: "var1", vtype: I32, timestamp: "1720927890728150000", epoch: Nanosecond, value: "59" }