arangors is an intuitive rust client for arangoDB,
inspired by pyArango.
arangors enables you to connect with arangoDB server, access to database,
execute AQL query, manage arangoDB in an easy and intuitive way.
arangors will stay synchronous until the async/await syntax are available in stable channel.
arangors is targeted at ergonomic, intuitive and OOP-like API for ArangoDB,
both top level and low level API for users' choice.
Overall architecture of arangoDB:
databases -> collections -> documents/edges
In fact, the design of arangors just mimic this architecture, with a
slight difference that in the top level, there is a connection object on top
of databases, containing a HTTP client with authentication information in
HTTP headers.
Hierarchy of arangors:
connection -> databases(cached) -> collections -> documents/edges
By now, the available features of arangors are:
Synchronous connection based on reqwest and full featured AQL query.
Remove cache behaviour and fix severe bugs in 0.2 that only root user can have access to arangoDB, which impose breaking API changes.
Fill the unimplemented API in Connection, Database, Collection and Document.
In this stage, all operations available for database, collection and document should be implemented.
Provides the API related to graph, index and user management.
Implement both sync and async client.
There is three way to establish connections:
So are the arangors API.
When a connection is successfully established,
arangors will automatically fetch the structure of arangoDB
by get the list of database, and then lists of collections per database.
Example:
```rust use arangors::Connection;
// (Recommended) Handy functions let conn = Connection::establishjwt("http://localhost:8529", "username", "password").unwrap(); let conn = Connection::establishbasic_auth("http://localhost:8529", "username", "password").unwrap(); ```
rust, ignore
use arangors::Connection;
let conn = Connection::establish_without_auth("http://localhost:8529").unwrap();
```rust use arangors::Connection;
fn main(){ let conn = Connection::establishjwt("http://localhost:8529", "username", "password").unwrap(); let db = conn.db("testdb").unwrap(); let collection = db.collection("test_collection").unwrap(); } ```
All aql query related functions are associated with database, as AQL query is performed at database level.
There are several way to execute AQL query, and can be categorized into two classes:
batch query
aql_query_batch
aql_next_batch
query to fetch all results
aql_straql_bind_varsaql_queryThis later category provides a convenient high level API, whereas batch query offers more control.
Note that results can be strong typed given deserializable struct, or
arbitrary JSON object with serde::Value.
```rust use serde_json::Value; use arangors::Connection;
let conn = Connection::establishjwt("http://localhost:8529", "username", "password").unwrap();
let db = conn.db("testdb").unwrap();
let resp: Vec
```rust use serde::Deserialize; use arangors::Connection;
struct User { pub username: String, pub password: String, }
let conn = Connection::establishjwt("http://localhost:8529", "username", "password").unwrap();
let db = conn.db("testdb").unwrap();
let resp: Vec
arangors offers a way to manually handle batch query.
There are three functions for AQL query that fetch all results from ArangoDB. These functions internally fetch batch results one after another to get all results.
The functions for fetching all results are listed as bellow:
aql_strThis function only accept a AQL query string.
Here is an example of strong typed query result with aql_str:
```rust use serde::Deserialize; use arangors::Connection;
struct User { pub username: String, pub password: String, }
fn main() {
let conn = Connection::establishjwt("http://localhost:8529", "username", "password").unwrap();
let db = conn.db("testdb").unwrap();
let result: Vec
aql_bind_varsThis function can be used to start a AQL query with bind variables.
```rust use arangors::{Connection, Document}; use std::collections::HashMap; use serde::{Serialize, Deserialize};
struct User { pub username: String, pub password: String, }
let conn = Connection::establishjwt("http://localhost:8529", "username", "password").unwrap(); let db = conn.db("testdb").unwrap();
let mut vars = HashMap::new();
let user = User{
username:"test".tostring(),
password:"testpwd".tostring(),
};
vars.insert("user", serdejson::value::tovalue(&user).unwrap());
let result:Vec
```
aql_queryThis function offers all the options available to tweak a AQL query.
Users have to construct a AqlQuery object first. And AqlQuery offer all
the options needed to tweak AQL query. You can set batch size, add bind
vars, limit memory, and all others
options available.
```rust use arangors::{AqlQuery, Connection, Cursor, Database}; use serde_json::value::Value;
let conn = Connection::establishjwt("http://localhost:8529", "username", "password").unwrap(); let database = conn.db("testdb").unwrap();
let aql = AqlQuery::new("FOR u IN @@collection LIMIT 3 RETURN u").batchsize(1).count(true).bindvar("@collection","test_collection");
let resp: Vec
Contributions and feed back are welcome following Github workflow.
arangors is provided under the MIT license. See LICENSE.
An ergonomic arangoDB client for rust.