oxia-client 0.1.0

Native Rust client SDK for Oxia, a distributed key-value store. Provides an idiomatic, asynchronous API built on Tokio.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

use oxia::{ComparisonType, OxiaClient};
use tracing::info;
use tracing::level_filters::LevelFilter;

#[tokio::main]
async fn main() {
    tracing_subscriber::fmt()
        .with_env_filter(
            tracing_subscriber::EnvFilter::builder()
                .with_default_directive(LevelFilter::INFO.into())
                .from_env_lossy(),
        )
        .with_target(false)
        .init();

    let client = OxiaClient::connect("localhost:6648").await.unwrap();

    // Put some records with keys we can query
    for key in ["key/a", "key/c", "key/e", "key/g", "key/i"] {
        client.put(key, format!("value-{key}")).await.unwrap();
        info!("Put {:?}", key);
    }

    // EQUAL comparison (default) - exact match
    let result = client.get("key/c").await.unwrap();
    info!(
        "EQUAL  get('key/c') => key={:?} value={:?}",
        result.key,
        result.value.as_ref().map(|v| String::from_utf8_lossy(v))
    );

    // FLOOR - highest key <= requested key
    let result = client
        .get("key/d")
        .comparison(ComparisonType::Floor)
        .await
        .unwrap();
    info!(
        "FLOOR  get('key/d') => key={:?} (highest key <= 'key/d')",
        result.key
    );

    // CEILING - lowest key >= requested key
    let result = client
        .get("key/d")
        .comparison(ComparisonType::Ceiling)
        .await
        .unwrap();
    info!(
        "CEILING get('key/d') => key={:?} (lowest key >= 'key/d')",
        result.key
    );

    // LOWER - highest key strictly < requested key
    let result = client
        .get("key/e")
        .comparison(ComparisonType::Lower)
        .await
        .unwrap();
    info!(
        "LOWER  get('key/e') => key={:?} (highest key < 'key/e')",
        result.key
    );

    // HIGHER - lowest key strictly > requested key
    let result = client
        .get("key/e")
        .comparison(ComparisonType::Higher)
        .await
        .unwrap();
    info!(
        "HIGHER get('key/e') => key={:?} (lowest key > 'key/e')",
        result.key
    );

    // Conditional put: only create if record does NOT exist
    let result = client
        .put("key/new", "new-value")
        .expected_record_not_exists()
        .await;
    info!(
        "Create-only put for 'key/new' (should succeed): {:?}",
        result.is_ok()
    );

    // Try again - should fail because it already exists
    let result = client
        .put("key/new", "new-value-2")
        .expected_record_not_exists()
        .await;
    info!(
        "Create-only put for 'key/new' (should fail): {:?}",
        result.unwrap_err()
    );

    // Cleanup
    client.delete_range("key/", "key/~").await.unwrap();
    info!("Cleaned up all key/* records.");

    client.close().await.unwrap();
}