Struct AmateRSClient 

pub struct AmateRSClient { /* private fields */ }

AmateRS client for interacting with the database

The client manages connections, handles retries, and provides high-level operations for working with encrypted data.

Implementations

impl AmateRSClient

pub async fn connect(addr: impl Into<String>) -> Result<Self>

Connect to an AmateRS server

Example

use amaters_sdk_rust::AmateRSClient;

let client = AmateRSClient::connect("http://localhost:50051").await?;

pub async fn connect_with_config(config: ClientConfig) -> Result<Self>

Connect with a custom configuration

Example

use amaters_sdk_rust::{AmateRSClient, ClientConfig};
use std::time::Duration;

let config = ClientConfig::new("http://localhost:50051")
    .with_connect_timeout(Duration::from_secs(5))
    .with_max_connections(20);

let client = AmateRSClient::connect_with_config(config).await?;

pub fn with_encryptor(self, encryptor: FheEncryptor) -> Self

Set the FHE encryptor for client-side encryption

pub fn encryptor(&self) -> Option<&Arc<FheEncryptor>>

Get the encryptor (if set)

pub async fn set( &self, collection: &str, key: &Key, value: &CipherBlob, ) -> Result<()>

Set a key-value pair

Example

use amaters_sdk_rust::AmateRSClient;
use amaters_core::{Key, CipherBlob};

let key = Key::from_str("user:123");
let value = CipherBlob::new(vec![1, 2, 3, 4]);

client.set("users", &key, &value).await?;

pub async fn get( &self, collection: &str, key: &Key, ) -> Result<Option<CipherBlob>>

Get a value by key

Returns None if the key doesn’t exist.

Example

use amaters_sdk_rust::AmateRSClient;
use amaters_core::Key;

let key = Key::from_str("user:123");

if let Some(value) = client.get("users", &key).await? {
    println!("Found value: {} bytes", value.len());
}

pub async fn delete(&self, collection: &str, key: &Key) -> Result<()>

Delete a key

Example

use amaters_sdk_rust::AmateRSClient;
use amaters_core::Key;

let key = Key::from_str("user:123");
client.delete("users", &key).await?;

pub async fn contains(&self, collection: &str, key: &Key) -> Result<bool>

Check if a key exists

Example

use amaters_sdk_rust::AmateRSClient;
use amaters_core::Key;

let key = Key::from_str("user:123");

if client.contains("users", &key).await? {
    println!("Key exists");
}

pub async fn execute_query(&self, query: &Query) -> Result<QueryResult>

Execute a query

This is a lower-level method that executes arbitrary queries.

Example

use amaters_sdk_rust::AmateRSClient;
use amaters_core::{Query, Key};

let query = Query::Get {
    collection: "users".to_string(),
    key: Key::from_str("user:123"),
};

client.execute_query(&query).await?;

pub async fn execute_batch( &self, queries: Vec<Query>, ) -> Result<Vec<QueryResult>>

Execute a batch of queries

All queries are executed atomically (all succeed or all fail).

pub fn pool_stats(&self) -> PoolStats

Get connection pool statistics

pub fn close(&self)

Close all connections

pub async fn health_check(&self) -> Result<()>

Health check

Returns Ok(()) if the server is healthy.

pub async fn server_info(&self) -> Result<ServerInfo>

Get server information

Returns information about the server including version, capabilities, and uptime.

pub async fn range( &self, collection: &str, start: &Key, end: &Key, ) -> Result<Vec<(Key, CipherBlob)>>

Range query - retrieve keys in a range

Example

use amaters_sdk_rust::AmateRSClient;
use amaters_core::Key;

let start = Key::from_str("user:000");
let end = Key::from_str("user:999");

let results = client.range("users", &start, &end).await?;
println!("Found {} keys in range", results.len());

Trait Implementations

impl Clone for AmateRSClient

fn clone(&self) -> AmateRSClient

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.