Java Client SDK

<dependency>
    <groupId>io.github.oxia-db</groupId>
    <artifactId>oxia-client</artifactId>
    <version>${VERSION}</version>
</dependency>

implementation("io.github.oxia-db:oxia-client:${VERSION}")

SyncOxiaClient client = OxiaClientBuilder.create("localhost:6648")
        .namespace("my-namespace")
        .syncClient();

AsyncOxiaClient client = OxiaClientBuilder.create("localhost:6648")
        .namespace("my-namespace")
        .asyncClient()
        .get();

// Write a record to Oxia with the specified key and value, and with the expectation
// that the record does not already exist.
PutResult res = client.put("my-key", "my-value".getBytes(), Set.of(IfRecordDoesNotExist));
 
// Write a record with the expectation that it has not changed since the previous write.
// If there was any change, the operation will fail
client.put("my-key", "my-value-2".getBytes(),
            Set.of(IfVersionIdEquals(res.version().versionId())));

// Write a record to Oxia with the specified key and value, and with the expectation
// that the record does not already exist.
client.put("my-string", "my-value".getBytes(), Set.of(IfRecordDoesNotExist))
        .thenAccept(res -> {
            log.info("Put result: {}", res);
        }).exceptionally(ex -> {
            log.warn("Put failed", ex);
            return null;
        });
 
// Write a record with the expectation that it has not changed since the previous write.
// If there was any change, the operation will fail
client.put("my-key", "my-value-2".getBytes(),
            Set.of(IfVersionIdEquals(res.version().versionId())))
        .thenAccept(res -> {
            log.info("Put result: {}", res);
        }).exceptionally(ex -> {
            log.warn("Put failed", ex);
            return null;
        });

GetResult res = client.get("my-key");
log.info("Got key: {} - value: {} - version: {}",
            res.getKey(), res.getValue(), res.getVersion());

aclient.get("my-key")
        .thenAccept(res -> {
            log.info("Got key: {} - value: {} - version: {}",
                    res.getKey(), res.getValue(), res.getVersion());
        }).exceptionally(ex -> {
            log.warn("Get failed", ex);
            return null;
        });

// Unconditional delete
client.delete("my-key");
 
// Conditional delete: only succeed if the version matches
client.delete("my-key", Set.of(IfVersionIdEquals(version.versionId())));

client.delete("my-key")
        .thenAccept(v -> {
            log.info("Delete succeeded");
        }).exceptionally(ex -> {
            log.warn("Delete failed", ex);
            return null;
        });

// Delete all keys in the range [minKeyInclusive, maxKeyExclusive)
client.deleteRange("/users/", "/users//");

client.deleteRange("/users/", "/users//")
        .thenAccept(v -> {
            log.info("DeleteRange succeeded");
        }).exceptionally(ex -> {
            log.warn("DeleteRange failed", ex);
            return null;
        });

List<String> keys = client.list("/users/", "/users//");
keys.forEach(key -> log.info("Key: {}", key));

client.list("/users/", "/users//")
        .thenAccept(keys -> {
            keys.forEach(key -> log.info("Key: {}", key));
        }).exceptionally(ex -> {
            log.warn("List failed", ex);
            return null;
        });

List<GetResult> results = client.rangeScan("/users/", "/users//");
results.forEach(r -> log.info("Key: {} - Value: {} - Version: {}",
        r.getKey(), new String(r.getValue()), r.getVersion()));

client.rangeScan("/users/", "/users//")
        .thenAccept(results -> {
            results.forEach(r -> log.info("Key: {} - Value: {}",
                    r.getKey(), new String(r.getValue())));
        }).exceptionally(ex -> {
            log.warn("RangeScan failed", ex);
            return null;
        });