Crate aerospike

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

pub use commands::particle_type::ParticleType;

pub use errors::Error;

pub use errors::ErrorKind;

pub use errors::Result;

pub use expressions::regex_flag::RegexFlag;

pub use operations::MapPolicy;

pub use operations::MapReturnType;

pub use operations::MapWriteMode;

pub use policy::BatchPolicy;

pub use policy::ClientPolicy;

pub use policy::CommitLevel;

pub use policy::Concurrency;

pub use policy::ConsistencyLevel;

pub use policy::Expiration;

pub use policy::GenerationPolicy;

pub use policy::Policy;

pub use policy::Priority;

pub use policy::QueryPolicy;

pub use policy::ReadPolicy;

pub use policy::RecordExistsAction;

pub use policy::ScanPolicy;

pub use policy::WritePolicy;

pub use query::CollectionIndexType;

pub use query::IndexType;

pub use query::Recordset;

pub use query::Statement;

pub use query::UDFLang;

pub use task::IndexTask;

pub use task::RegisterTask;

pub use task::Task;

Modules

errors

Error and Result types for the Aerospike client.

expressions

Functions used for Filter Expressions. This module requires Aerospike Server version >= 5.2

operations

Functions used to create database operations used in the client’s operate() method.

policy

Policy types encapsulate optional parameters for various client operations.

query

Types and methods used for database queries and scans.

task

Types and methods used for long running status queries.

Macros

as_bin

Construct a new bin from a name and an optional value (defaults to the empty value nil).

as_blob

Constructs a new Blob Value from one of the supported native data types.

as_contains

Create contains number filter for queries on a collection index.

as_contains_range

Create contains range filter for queries on a collection index.

as_eq

Create equality filter for queries; supports integer and string values.

as_geo

Constructs a new GeoJSON Value from one of the supported native data types.

as_key

Construct a new key given a namespace, a set name and a user key.

as_list

Constructs a new List Value from a list of one or more native data types.

as_map

Constructs a Map Value from a list of key/value pairs.

as_range

Create range filter for queries; supports integer values.

as_regions_containing_point

Create geospatial “regions containing point” filter for queries. For queries on a collection index the collection index type must be specified.

as_val

Constructs a new Value from one of the supported native data types.

as_values

Constructs a vector of Values from a list of one or more native data types.

as_within_radius

Create geospatial “points within radius” filter for queries. For queries on a collection index the collection index type must be specified.

as_within_region

Create geospatial “points within region” filter for queries. For queries on a collection index the collection index type must be specified.

Structs

BatchRead

Key and bin names used in batch read commands where variable bins are needed for each key.

Bin

Container object for a record bin, comprising a name and a value.

Client

Instantiate a Client instance to access an Aerospike database cluster and perform database operations.

Host

Host name/port of database server.

Key

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.

Record

Container object for a database record.

User

User and assigned roles.

Enums

Bins

Specify which, if any, bins to return in read operations.

FloatValue

Container for floating point bin values stored in the Aerospike database.

ResultCode

Database operation error codes. The error codes are defined in the server-side file proto.h.

Value

Container for bin values stored in the Aerospike database.