https://github.com/wolf4ood/gremlin-rs

Gremlin Rust
https://github.com/wolf4ood/gremlin-rs

apache-tinkerpop graph hacktoberfest rust tinkerpop3

Last synced: 6 days ago
JSON representation

Gremlin Rust

• Host: GitHub
• URL: https://github.com/wolf4ood/gremlin-rs
• Owner: wolf4ood
• License: apache-2.0
• Created: 2019-03-16T21:30:26.000Z (almost 6 years ago)
• Default Branch: master
• Last Pushed: 2024-10-16T11:50:46.000Z (3 months ago)
• Last Synced: 2024-12-23T00:02:04.793Z (13 days ago)
• Topics: apache-tinkerpop, graph, hacktoberfest, rust, tinkerpop3
• Language: Rust
• Homepage:
• Size: 1.21 MB
• Stars: 108
• Watchers: 8
• Forks: 30
• Open Issues: 23
• Metadata Files:
  • Readme: README.md
  • License: LICENSE.md
  • Code of conduct: CODE_OF_CONDUCT.md

Awesome Lists containing this project

README

        


Gremlin-rs



  

    Rust driver and tools for Apache TinkerPop™.

  








  

    

  

  

  

    

  

  

    

  

  

    

  


   

    

  

   

    

  

  



## gremlin-client

A Rust client for Apache TinkerPop™.

### Installation

Install from [crates.io](https://crates.io/)

```toml

[dependencies]

gremlin-client = "0.8"

```

with [async-std](https://async.rs/) support 

```toml

[dependencies]

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

```

with [tokio](https://tokio.rs/) support 

```toml

[dependencies]

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

```

### 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::())

        .collect::, _>>()?;

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

    Ok(())

}

```

**Asynchronous**

With [async-std](https://async.rs/)

activate the feature `async-std-runtime`

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

```rust

     

use gremlin_client::{aio::GremlinClient, Vertex};

use async_std::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::())

        .collect::, _>>().await?;

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

    Ok(())

    

}

```

With [tokio](https://tokio.rs/)

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::())

        .collect::, _>>().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](https://async.rs/)

```rust

use gremlin_client::{aio::GremlinClient, Vertex, process::traversal::traversal};

use async_std::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](https://tokio.rs/)

```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(())

}

```

### Additional Features

#### `derive` feature

By including the `derive` feature in your Cargo.toml

```

[dependencies]

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

```

two derive macros are available 

- FromGMap

- FromGValue

which you can use to derive the mapping from GMap and GValue (only Map currently) into structs.

with `GValue`

```rust

use gremlin_client::derive::{FromGMap, FromGValue};

use gremlin_client::process::traversal::traversal;

use gremlin_client::GremlinClient;

use std::convert::TryFrom;

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

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

    #[derive(Debug, PartialEq, FromGValue, FromGMap)]

    struct Person {

        name: String,

    }

    let results = client

        .execute("g.V(param).valueMap()", &[("param", &1)])?

        .filter_map(Result::ok)

        .map(|f| Person::try_from(f))

        .collect::, _>>()?;

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

    Ok(())

}

```

with `GMap`

```rust

use gremlin_client::derive::FromGMap;

use gremlin_client::process::traversal::traversal;

use gremlin_client::GremlinClient;

use std::convert::TryFrom;

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

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

    #[derive(Debug, PartialEq, FromGMap)]

    struct Person {

        name: String,

    }

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

    let results = g

        .v(1)

        .value_map(())

        .iter()?

        .filter_map(Result::ok)

        .map(Person::try_from)

        .collect::, _>>()?;

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

    Ok(())

}

```

### Development

#### Compiling

```

git clone https://github.com/wolf4ood/gremlin-rs.git

cd gremlin-rs

cargo build

```

#### Running Tests

Some tests run against a running instance of Gremlin Server with a sample in-memory graph installed.

You can use docker-compose to start an instance for testing. Use the env variable `GREMLIN_SERVER`

in order to specify the version of the Gremlin Server

```

cd docker-compose

export GREMLIN_SERVER=3.4.4

docker-compose up -d

cd ..

cargo test --all-features

```

## gremlin-cli 

A minimal cli for exploring graphs data in Gremlin Server.

### Install

```

cargo install gremlin-cli

```

or latest release [here](https://github.com/wolf4ood/gremlin-rs/releases)