Struct gremlin_client::GremlinClient

pub struct GremlinClient { /* private fields */ }

Implementations

impl GremlinClient

pub fn close_session(&mut self) -> GremlinResult<GResultSet>

impl GremlinClient

pub fn connect<T>(options: T) -> GremlinResult<GremlinClient>where
T: Into<ConnectionOptions>,

Examples found in repository

examples/path.rs (line 4)

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

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

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

    Ok(())
}

examples/multithread.rs (line 5)

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

    let c = client.clone();

    let result = thread::spawn(move || {
        c.execute("g.V(param)", &[("param", &1)])?
            .filter_map(Result::ok)
            .map(|f| f.take::<Vertex>())
            .collect::<Result<Vec<Vertex>, _>>()
    });

    println!("{:?}", result.join());

    Ok(())
}

examples/traversal.rs (line 4)

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

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

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

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

    let friends = g
        .v(())
        .has_label("person")
        .has(("name", "marko"))
        .out("knows")
        .to_list()?;

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

    Ok(())
}

examples/vertex.rs (line 4)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    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!("Vertex count: {}", results.len());

    let vertex = &results[0];

    println!(
        "Vertex with id: [{}] and label: [{}]",
        vertex.id().get::<i64>()?,
        vertex.label()
    );

    Ok(())
}

examples/connection_options.rs (lines 4-11)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = GremlinClient::connect(
        ConnectionOptions::builder()
            .host("localhost")
            .port(8182)
            .pool_size(1)
            .credentials("stephen", "password")
            .build(),
    )?;

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

examples/edge_properties.rs (line 4)

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

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

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

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

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

    Ok(())
}

Additional examples can be found in:

• examples/edge.rs
• examples/vertex_properties.rs
• examples/traversal_complex.rs

pub fn create_session(&mut self, name: String) -> GremlinResult<GremlinClient>

pub fn alias<T>(&self, alias: T) -> GremlinClientwhere
T: Into<String>,

Return a cloned client with the provided alias

pub fn execute<T>(
&self,
script: T,
params: &[(&str, &dyn ToGValue)]
) -> GremlinResult<GResultSet>where
T: Into<String>,

Examples found in repository

examples/path.rs (line 7)

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

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

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

    Ok(())
}

examples/multithread.rs (line 10)

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

    let c = client.clone();

    let result = thread::spawn(move || {
        c.execute("g.V(param)", &[("param", &1)])?
            .filter_map(Result::ok)
            .map(|f| f.take::<Vertex>())
            .collect::<Result<Vec<Vertex>, _>>()
    });

    println!("{:?}", result.join());

    Ok(())
}

examples/vertex.rs (line 7)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    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!("Vertex count: {}", results.len());

    let vertex = &results[0];

    println!(
        "Vertex with id: [{}] and label: [{}]",
        vertex.id().get::<i64>()?,
        vertex.label()
    );

    Ok(())
}

examples/connection_options.rs (line 14)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = GremlinClient::connect(
        ConnectionOptions::builder()
            .host("localhost")
            .port(8182)
            .pool_size(1)
            .credentials("stephen", "password")
            .build(),
    )?;

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

examples/edge_properties.rs (line 7)

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

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

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

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

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

    Ok(())
}

examples/edge.rs (line 8)

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

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

    println!("Edges count {}", results.len());

    let first = &results[0];

    println!(
        "Edge with id: [{}] and label: [{}] from: [{}] to: [{}]",
        first.id().get::<i32>()?,
        first.label(),
        first.out_v().id().get::<i64>()?,
        first.in_v().id().get::<i64>()?
    );

    Ok(())
}

Additional examples can be found in:

• examples/vertex_properties.rs

pub fn generate_message(
&self,
bytecode: &Bytecode
) -> GremlinResult<Message<Value>>

Trait Implementations

impl Clone for GremlinClient

fn clone(&self) -> GremlinClient

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for GremlinClient

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.