Crate ruarango

ruarango

A database driver written in Rust for the ArangoDB database.

While the API for ruarango is async, ArangoDB supports 3 modes of operation. They are blocking, store, and fire & forget. The latter two modes are asynchronus, while the first is synchronous. More details can be found here. See below for examples of using the driver in these various modes.

Synchronous Blocking Connection

Use the driver in Blocking mode

// Use `ConnectionBuilder` to build a connection and pull in the
// traits for operations you wish to use
use ruarango::{ConnectionBuilder, Database};

// Setup a synchronous connection to the database
let conn = ConnectionBuilder::default()
    .url(url) // The normal url for ArangoDB running locally is http://localhost:8529
    .username("root")
    .password("")
    .database("test_db")
    .build()
    .await?;

// Use the connection to query information about the current database
let res = conn.current().await?;

// Get the sync results out of the right side of the `Either`
assert!(res.is_right());
let contents = res.right_safe()?;
assert!(!contents.error());
assert_eq!(*contents.code(), 200);
assert_eq!(contents.result().name(), "test");
assert_eq!(contents.result().id(), "123");
assert!(!contents.result().is_system());

Asynchronous Store Connection

Use the driver in Store mode

// Use `ConnectionBuilder` to build a connection and pull in the
// traits for operations you wish to use
use ruarango::{ConnectionBuilder, Database, Job};

// Setup a asynchronous store connection to the database
let conn = ConnectionBuilder::default()
    .url(url) // The normal url for ArangoDB running locally is http://localhost:8529
    .username("root")
    .password("")
    .database("test_db")
    .async_kind(AsyncKind::Store)
    .build()
    .await?;

// Use the connection to spawn a job for information about the current database
// This will return immediately with a 202 code and job information if the job
// was accepted into the queue.
let res = conn.current().await?;

// Get the async job info results out of the left side of the `Either`
assert!(res.is_left());
let contents = res.left_safe()?;
assert_eq!(*contents.code(), 202);
assert!(contents.id().is_some());
let job_id = contents.id().as_ref().ok_or_else(|| anyhow!("invalid job_id"))?;
assert_eq!(job_id, "123456");

// Check status until we get 200 (or error out on 404)
let mut status = conn.status(job_id).await?;
assert!(status == 200 || status == 204);

while status != 200 {
    std::thread::sleep(std::time::Duration::from_millis(500));
    status = conn.status(job_id).await?;
}

// Fetch the results (this has the side effect of removing the job off of the server)
let res: Response<Current> = conn.fetch(job_id).await?;
assert!(!res.error());
assert_eq!(*res.code(), 200);
assert_eq!(res.result().name(), "test");
assert_eq!(res.result().id(), "123");
assert!(!res.result().is_system());

Asynchronous Fire & Forget Connection

Use the driver in Fire & Forget mode

// Use `ConnectionBuilder` to build a connection and pull in the
// traits for operations you wish to use
use ruarango::{ConnectionBuilder, Database, Job};

// Setup a asynchronous store connection to the database
let conn = ConnectionBuilder::default()
    .url(url) // The normal url for ArangoDB running locally is http://localhost:8529
    .username("root")
    .password("")
    .database("test_db")
    .async_kind(AsyncKind::FireAndForget)
    .build()
    .await?;

// Use the connection to spawn a job for information about the current database
// In this case, fire and forget isn't useful, but for other operations it
// may be.  Fire and Forget jobs run on the server and do not store results.
let res = conn.current().await?;

// Check that the job was accepted into the queue.
assert!(res.is_left());
let contents = res.left_safe()?;
assert_eq!(*contents.code(), 202);
assert!(contents.id().is_none());

Modules

coll

Input/Output for Collection operations

common

Input/Output that is common/shared

cursor

Input/Output for Cursor operations

db

Input/Output for Database operations

doc

Input/Output for Document operations

graph

Input/Output for Graph operations

Structs

Connection

An ArangoDB connection implementing the database operation traits

ConnectionBuilder

Builder for Connection.

JobInfo

Job Information from an asynchronous invocation

Enums

AsyncKind

The kind of asynchronouse request you would like to make

Error

When bad things happen

Traits

Collection

Collection Operations

Cursor

Cursor Operations

Database

Database Operations

Document

Document Operations

Graph

Database Operations

Job

Collection Operations

Type Aliases

ArangoEither

Either JobInfo from an asynchronous invocation on the left or the result T from a synchronous invocation on the right

ArangoResult

A result that on success is either JobInfo from an asynchronous invocation on the left or the result T from a synchronous invocation on the right

ArangoVec

ArangoVecResult

DocMetaResult

An ArangoResult that has DocMeta on the right.

DocMetaVecResult