gremlin-rs

gremlin-client

A Rust client for Apache TinkerPop™.

Installation

Install from crates.io

toml [dependencies] gremlin_client = "0.4.0"

with async support via async-std

toml [dependencies] gremlin_client = { version = "0.4.0", features = ["async_std"] }

Examples

Basic usage

Execute a simple Gremlin query with an id and collect the results

Synchronous

```rust use gremlin_client::{GremlinClient, Vertex};

fn main() -> Result<(), Box> { let client = GremlinClient::connect("localhost")?;

let results = client
    .execute("g.V(param)", &[("param", &1)])?
    .filter_map(Result::ok)
    .map(|f| f.take::<Vertex>())
    .collect::<Result<Vec<Vertex>, _>>()?;

println!("{:?}", results);

Ok(())

} ```

Asynchronous

With async-std

activate the feature async-std-runtime

gremlin-client = { version = "*", features = ["async-std-runtime"] }

```rust

use gremlinclient::{aio::GremlinClient, Vertex}; use asyncstd::prelude::*;

[async_std::main]

async fn main() -> Result<(), Box> {

let client = GremlinClient::connect("localhost").await?;
let results = client.execute("g.V(param)", &[("param", &1)]).await?
    .filter_map(Result::ok)
    .map(|f| f.take::<Vertex>())
    .collect::<Result<Vec<Vertex>, _>>().await?;
println!("{:?}", results);
Ok(())

} ```

With tokio

activate the feature tokio-runtime

gremlin-client = { version = "*", features = ["tokio-runtime"] }

```rust

use gremlin_client::{aio::GremlinClient, Vertex}; use tokio::stream::StreamExt;

[tokio::main]

async fn main() -> Result<(), Box> {

let client = GremlinClient::connect("localhost").await?;
let results = client.execute("g.V(param)", &[("param", &1)]).await?
    .filter_map(Result::ok)
    .map(|f| f.take::<Vertex>())
    .collect::<Result<Vec<Vertex>, _>>().await?;
println!("{:?}", results);
Ok(())

} ```

Traversal example Rust GLV

Create a remote traversal with the provided GremlinClient and build a traversal using Rust language.

Synchronous

```rust use gremlin_client::{GremlinClient, Vertex, process::traversal::traversal};

fn main() -> Result<(), Box> { let client = GremlinClient::connect("localhost")?;

let g = traversal().with_remote(client);

let results = g.v(()).has_label("person").has(("name","Jon")).to_list()?;   

println!("{:?}", results);
Ok(())

} ```

Aynchronous

With async-std

```rust use gremlinclient::{aio::GremlinClient, Vertex, process::traversal::traversal}; use asyncstd::prelude::*;

[async_std::main]

async fn main() -> Result<(), Box> {

let client = GremlinClient::connect("localhost").await?;

let g = traversal().with_remote_async(client);

let results = g.v(()).has_label("person").has(("name","Jon")).to_list().await?;   

println!("{:?}", results);
Ok(())

} ```

With tokio

```rust use gremlin_client::{aio::GremlinClient, Vertex, process::traversal::traversal}; use tokio::stream::StreamExt;

[tokio::main]

async fn main() -> Result<(), Box> {

let client = GremlinClient::connect("localhost").await?;

let g = traversal().with_remote_async(client);

let results = g.v(()).has_label("person").has(("name","Jon")).to_list().await?;   

println!("{:?}", results);
Ok(())

} ```