Crate aerospike

source ·
Expand description

A pure-rust client for the Aerospike NoSQL database.

Aerospike is an enterprise-class, NoSQL database solution for real-time operational applications, delivering predictable performance at scale, superior uptime, and high availability at the lowest TCO compared to first-generation NoSQL and relational databases. For more information please refer to https://www.aerospike.com/.

Installation

Add this to your Cargo.toml:

[dependencies]
aerospike = "1.0.0"

Examples

The following is a very simple example of CRUD operations in an Aerospike database.

#[macro_use]
extern crate aerospike;

use std::env;
use std::sync::Arc;
use std::time::Instant;
use std::thread;

use aerospike::{Bins, Client, ClientPolicy, ReadPolicy, WritePolicy};
use aerospike::operations;

fn main() {
    let cpolicy = ClientPolicy::default();
    let hosts = env::var("AEROSPIKE_HOSTS")
        .unwrap_or(String::from("127.0.0.1:3000"));
    let client = Client::new(&cpolicy, &hosts)
        .expect("Failed to connect to cluster");
    let client = Arc::new(client);

    let mut threads = vec![];
    let now = Instant::now();
    for i in 0..2 {
        let client = client.clone();
        let t = thread::spawn(move || {
            let rpolicy = ReadPolicy::default();
            let wpolicy = WritePolicy::default();
            let key = as_key!("test", "test", i);
            let bins = [
                as_bin!("int", 123),
                as_bin!("str", "Hello, World!"),
            ];

            client.put(&wpolicy, &key, &bins).unwrap();
            let rec = client.get(&rpolicy, &key, Bins::All);
            println!("Record: {}", rec.unwrap());

            client.touch(&wpolicy, &key).unwrap();
            let rec = client.get(&rpolicy, &key, Bins::All);
            println!("Record: {}", rec.unwrap());

            let rec = client.get(&rpolicy, &key, Bins::None);
            println!("Record Header: {}", rec.unwrap());

            let exists = client.exists(&wpolicy, &key).unwrap();
            println!("exists: {}", exists);

            let bin = as_bin!("int", 999);
            let ops = &vec![operations::put(&bin), operations::get()];
            let op_rec = client.operate(&wpolicy, &key, ops);
            println!("operate: {}", op_rec.unwrap());

            let existed = client.delete(&wpolicy, &key).unwrap();
            println!("existed (sould be true): {}", existed);

            let existed = client.delete(&wpolicy, &key).unwrap();
            println!("existed (should be false): {}", existed);
        });

        threads.push(t);
    }

    for t in threads {
        t.join().unwrap();
    }

    println!("total time: {:?}", now.elapsed());
}

Re-exports

Modules

  • Error and Result types for the Aerospike client.
  • Functions used for Filter Expressions. This module requires Aerospike Server version >= 5.2
  • Functions used to create database operations used in the client’s operate() method.
  • Policy types encapsulate optional parameters for various client operations.
  • Types and methods used for database queries and scans.
  • Types and methods used for long running status queries.

Macros

  • Construct a new bin from a name and an optional value (defaults to the empty value nil).
  • Constructs a new Blob Value from one of the supported native data types.
  • Create contains number filter for queries on a collection index.
  • Create contains range filter for queries on a collection index.
  • Create equality filter for queries; supports integer and string values.
  • Constructs a new GeoJSON Value from one of the supported native data types.
  • Construct a new key given a namespace, a set name and a user key.
  • Constructs a new List Value from a list of one or more native data types.
  • Constructs a Map Value from a list of key/value pairs.
  • Create range filter for queries; supports integer values.
  • Create geospatial “regions containing point” filter for queries. For queries on a collection index the collection index type must be specified.
  • Constructs a new Value from one of the supported native data types.
  • Constructs a vector of Values from a list of one or more native data types.
  • Create geospatial “points within radius” filter for queries. For queries on a collection index the collection index type must be specified.
  • Create geospatial “points within region” filter for queries. For queries on a collection index the collection index type must be specified.

Structs

  • Key and bin names used in batch read commands where variable bins are needed for each key.
  • Container object for a record bin, comprising a name and a value.
  • Instantiate a Client instance to access an Aerospike database cluster and perform database operations.
  • Host name/port of database server.
  • Unique record identifier. Records can be identified using a specified namespace, an optional set name and a user defined key which must be uique within a set. Records can also be identified by namespace/digest, which is the combination used on the server.
  • Container object for a database record.
  • User and assigned roles.

Enums

  • Specify which, if any, bins to return in read operations.
  • Container for floating point bin values stored in the Aerospike database.
  • Database operation error codes. The error codes are defined in the server-side file proto.h.
  • Container for bin values stored in the Aerospike database.