Struct GraphTraversalSource 

pub struct GraphTraversalSource<A: Terminator<GValue>> { /* private fields */ }

Implementations

impl<A: Terminator<GValue>> GraphTraversalSource<A>

pub fn new(terminator: A) -> GraphTraversalSource<A>

pub fn empty() -> GraphTraversalSource<MockTerminator>

pub fn with_remote( &self, client: GremlinClient, ) -> GraphTraversalSource<SyncTerminator>

pub fn v<T>(&self, ids: T) -> GraphTraversal<Vertex, Vertex, A>

where T: Into<GIDs>, A: Terminator<Vertex>,

Examples found in repository

examples/traversal.rs (line 9)

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/traversal_complex.rs (line 15)

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

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

    create_graph(&g)?;

    let result = g
        .v(())
        .has_label("complex_vertex")
        .has(("name", "test1"))
        .out("complex_label")
        .out("complex_label")
        .value_map(())
        .next()?
        .expect("no vertices found");

    println!(
        "Found vertex with name {:?}",
        result["name"].get::<List>().unwrap()[0]
    );

    let results = g
        .v(())
        .has_label("complex_vertex")
        .has(("number", P::gt(3)))
        .to_list()?;

    println!(
        "Found {} vertices with number greater than 3",
        results.len()
    );

    let results = g
        .v(())
        .has_label("complex_vertex")
        .has(("number", P::within((3, 6))))
        .to_list()?;

    println!("Found {} vertices with number 3 or 6", results.len());

    let results = g
        .v(())
        .has_label("complex_vertex")
        .where_(__.out("complex_label").count().is(P::gte(1)))
        .to_list()?;

    println!(
        "Found {} vertices with 1 or more connected edges with label complex_label",
        results.len()
    );

    Ok(())
}

fn create_graph(
    g: &GraphTraversalSource<SyncTerminator>,
) -> Result<(), Box<dyn std::error::Error>> {
    g.v(()).has_label("complex_vertex").drop().next()?;
    g.e(()).has_label("complex_label").drop().next()?;

    let mut current_next: Option<Vertex> = None;
    (0..10).for_each(|e| {
        let next = g
            .add_v("complex_vertex")
            .property("name", format!("test{}", e))
            .property("number", e)
            .next()
            .expect("failed to create vertex");

        current_next.iter().zip(next.iter()).for_each(|(a, b)| {
            g.add_e("complex_label")
                .from(a)
                .to(b)
                .next()
                .expect("failed to create edge");
        });

        current_next = next;
    });

    Ok(())
}

pub fn add_v<T>(&self, label: T) -> GraphTraversal<Vertex, Vertex, A>

where T: Into<Labels>, A: Terminator<Vertex>,

Examples found in repository

examples/traversal_complex.rs (line 71)

fn create_graph(
    g: &GraphTraversalSource<SyncTerminator>,
) -> Result<(), Box<dyn std::error::Error>> {
    g.v(()).has_label("complex_vertex").drop().next()?;
    g.e(()).has_label("complex_label").drop().next()?;

    let mut current_next: Option<Vertex> = None;
    (0..10).for_each(|e| {
        let next = g
            .add_v("complex_vertex")
            .property("name", format!("test{}", e))
            .property("number", e)
            .next()
            .expect("failed to create vertex");

        current_next.iter().zip(next.iter()).for_each(|(a, b)| {
            g.add_e("complex_label")
                .from(a)
                .to(b)
                .next()
                .expect("failed to create edge");
        });

        current_next = next;
    });

    Ok(())
}

pub fn add_e<T>(&self, label: T) -> GraphTraversal<Edge, Edge, A>

where T: Into<Labels>, A: Terminator<Edge>,

Examples found in repository

examples/traversal_complex.rs (line 78)

fn create_graph(
    g: &GraphTraversalSource<SyncTerminator>,
) -> Result<(), Box<dyn std::error::Error>> {
    g.v(()).has_label("complex_vertex").drop().next()?;
    g.e(()).has_label("complex_label").drop().next()?;

    let mut current_next: Option<Vertex> = None;
    (0..10).for_each(|e| {
        let next = g
            .add_v("complex_vertex")
            .property("name", format!("test{}", e))
            .property("number", e)
            .next()
            .expect("failed to create vertex");

        current_next.iter().zip(next.iter()).for_each(|(a, b)| {
            g.add_e("complex_label")
                .from(a)
                .to(b)
                .next()
                .expect("failed to create edge");
        });

        current_next = next;
    });

    Ok(())
}

pub fn e<T>(&self, ids: T) -> GraphTraversal<Edge, Edge, A>

where T: Into<GIDs>, A: Terminator<Edge>,

Examples found in repository

examples/traversal_complex.rs (line 66)

fn create_graph(
    g: &GraphTraversalSource<SyncTerminator>,
) -> Result<(), Box<dyn std::error::Error>> {
    g.v(()).has_label("complex_vertex").drop().next()?;
    g.e(()).has_label("complex_label").drop().next()?;

    let mut current_next: Option<Vertex> = None;
    (0..10).for_each(|e| {
        let next = g
            .add_v("complex_vertex")
            .property("name", format!("test{}", e))
            .property("number", e)
            .next()
            .expect("failed to create vertex");

        current_next.iter().zip(next.iter()).for_each(|(a, b)| {
            g.add_e("complex_label")
                .from(a)
                .to(b)
                .next()
                .expect("failed to create edge");
        });

        current_next = next;
    });

    Ok(())
}

pub fn with_side_effect<T>( &self, step: (&'static str, T), ) -> GraphTraversal<GValue, GValue, A>

where T: Into<GValue> + FromGValue, A: Terminator<T>,

Trait Implementations

impl<A: Clone + Terminator<GValue>> Clone for GraphTraversalSource<A>

fn clone(&self) -> GraphTraversalSource<A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.