Struct Client 

pub struct Client { /* private fields */ }

KeystoneDB remote client

Implementations

impl Client

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

Connect to a KeystoneDB server

Arguments

• addr - Server address (e.g., “http://127.0.0.1:50051”)

Example

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

pub async fn put(&mut self, pk: &[u8], item: Item) -> Result<()>

Put an item with a simple partition key

Arguments

• pk - Partition key
• item - Item to store

Example

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

let mut item = HashMap::new();
item.insert("name".to_string(), Value::S("Alice".to_string()));
item.insert("age".to_string(), Value::N("30".to_string()));

client.put(b"user#123", item).await?;

pub async fn put_with_sk( &mut self, pk: &[u8], sk: &[u8], item: Item, ) -> Result<()>

Put an item with partition key and sort key

Arguments

• pk - Partition key
• sk - Sort key
• item - Item to store

pub async fn put_conditional( &mut self, pk: &[u8], item: Item, condition: impl Into<String>, values: HashMap<String, Value>, ) -> Result<()>

Put an item with a condition expression

Arguments

• pk - Partition key
• item - Item to store
• condition - Condition expression (e.g., “attribute_not_exists(pk)”)
• values - Expression attribute values

pub async fn get(&mut self, pk: &[u8]) -> Result<Option<Item>>

Get an item with a simple partition key

Arguments

• pk - Partition key

Returns

The item if found, None otherwise

pub async fn get_with_sk( &mut self, pk: &[u8], sk: &[u8], ) -> Result<Option<Item>>

Get an item with partition key and sort key

Arguments

• pk - Partition key
• sk - Sort key

Returns

The item if found, None otherwise

pub async fn delete(&mut self, pk: &[u8]) -> Result<()>

Delete an item with a simple partition key

Arguments

• pk - Partition key

pub async fn delete_with_sk(&mut self, pk: &[u8], sk: &[u8]) -> Result<()>

Delete an item with partition key and sort key

Arguments

• pk - Partition key
• sk - Sort key

pub async fn delete_conditional( &mut self, pk: &[u8], condition: impl Into<String>, values: HashMap<String, Value>, ) -> Result<()>

Delete an item with a condition expression

Arguments

• pk - Partition key
• condition - Condition expression (e.g., “attribute_exists(pk)”)
• values - Expression attribute values

pub async fn query(&mut self, query: RemoteQuery) -> Result<RemoteQueryResponse>

Execute a query operation

Arguments

• query - Query builder with conditions

Example

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

let query = RemoteQuery::new(b"user#org1")
    .sk_begins_with(b"USER#")
    .limit(10);

let response = client.query(query).await?;
println!("Found {} items", response.count);

pub async fn scan(&mut self, scan: RemoteScan) -> Result<RemoteScanResponse>

Execute a scan operation

Arguments

• scan - Scan builder with options

Example

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

let scan = RemoteScan::new()
    .limit(100);

let response = client.scan(scan).await?;
println!("Scanned {} items", response.count);

pub async fn batch_get( &mut self, request: RemoteBatchGetRequest, ) -> Result<RemoteBatchGetResponse>

Execute a batch get operation

Arguments

• request - Batch get request with keys

Example

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

let batch = RemoteBatchGetRequest::new()
    .add_key(b"user#1")
    .add_key(b"user#2");

let response = client.batch_get(batch).await?;
println!("Retrieved {} items", response.count);

pub async fn batch_write( &mut self, request: RemoteBatchWriteRequest, ) -> Result<RemoteBatchWriteResponse>

Execute a batch write operation

Arguments

• request - Batch write request with puts/deletes

Example

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

let mut item = HashMap::new();
item.insert("name".to_string(), Value::S("Alice".to_string()));

let batch = RemoteBatchWriteRequest::new()
    .put(b"user#1", item.clone())
    .delete(b"user#old");

let response = client.batch_write(batch).await?;
println!("Batch write success: {}", response.success);

pub async fn transact_get( &mut self, request: RemoteTransactGetRequest, ) -> Result<RemoteTransactGetResponse>

Execute a transactional get operation

Arguments

• request - TransactGet request with keys to retrieve

Example

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

let request = RemoteTransactGetRequest::new()
    .get(b"user#1")
    .get(b"user#2");

let response = client.transact_get(request).await?;
println!("Retrieved {} items", response.items.len());

pub async fn transact_write( &mut self, request: RemoteTransactWriteRequest, ) -> Result<()>

Execute a transactional write operation

Arguments

• request - TransactWrite request with operations

Example

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

let mut item = HashMap::new();
item.insert("name".to_string(), Value::S("Alice".to_string()));

let request = RemoteTransactWriteRequest::new()
    .put(b"user#1", item);

client.transact_write(request).await?;

pub async fn update( &mut self, request: RemoteUpdate, ) -> Result<RemoteUpdateResponse>

Update an item using update expression

Arguments

• request - Update request with expression

Example

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

let update = RemoteUpdate::new(b"user#1")
    .expression("SET age = age + :inc")
    .value(":inc", Value::N("1".to_string()));

let response = client.update(update).await?;
println!("Updated item: {:?}", response.item);

pub async fn execute_statement( &mut self, statement: impl Into<String>, ) -> Result<RemoteExecuteStatementResponse>

Execute a PartiQL statement

Arguments

• statement - PartiQL SQL statement

Example

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

let response = client.execute_statement(
    "SELECT * FROM users WHERE pk = 'user#123'"
).await?;

println!("Query result: {:?}", response);