Struct GraphTraversal 

pub struct GraphTraversal<S, E: FromGValue, T: Terminator<E>> { /* private fields */ }

Implementations

impl<S, E: FromGValue, T: Terminator<E>> GraphTraversal<S, E, T>

pub fn new(terminator: T, builder: TraversalBuilder) -> GraphTraversal<S, E, T>

pub fn change_remote( self, client: GremlinClient, ) -> GraphTraversal<S, E, SyncTerminator>

pub fn does_write(&self) -> bool

pub fn bytecode(&self) -> &Bytecode

pub fn has_label<L>(self, labels: L) -> Self

where L: Into<Labels>,

Examples found in repository

examples/traversal.rs (line 10)

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 16)

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<A>(self, label: A) -> GraphTraversal<Vertex, Vertex, T>

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

pub fn property<A>(self, key: &str, value: A) -> Self

where A: Into<GValue>,

Examples found in repository

examples/traversal_complex.rs (line 72)

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 property_with_cardinality<A>( self, cardinality: Cardinality, key: &str, value: A, ) -> Self

where A: Into<GValue>,

pub fn property_many<A>(self, values: Vec<(String, A)>) -> Self

where A: Into<GValue>,

pub fn property_many_with_cardinality<A>( self, values: Vec<(Cardinality, String, A)>, ) -> Self

where A: Into<GValue>,

pub fn has<A>(self, step: A) -> Self

where A: Into<HasStep>,

Examples found in repository

examples/traversal.rs (line 11)

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 17)

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

pub fn has_many<A>(self, steps: Vec<A>) -> Self

where A: Into<HasStep>,

pub fn has_not<A>(self, key: A) -> Self

where A: Into<String>,

pub fn as_<A>(self, alias: A) -> Self

where A: Into<String>,

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

where A: Into<GValue> + FromGValue,

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

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

pub fn out<A>(self, labels: A) -> GraphTraversal<S, Vertex, T>

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

Examples found in repository

examples/traversal.rs (line 20)

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 18)

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

pub fn out_e<A>(self, labels: A) -> GraphTraversal<S, Edge, T>

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

pub fn out_v(self) -> GraphTraversal<S, Vertex, T>

where T: Terminator<Vertex>,

pub fn in_<A>(self, labels: A) -> GraphTraversal<S, Vertex, T>

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

pub fn in_e<A>(self, labels: A) -> GraphTraversal<S, Edge, T>

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

pub fn in_v(self) -> GraphTraversal<S, Vertex, T>

where T: Terminator<Vertex>,

pub fn both<A>(self, labels: A) -> GraphTraversal<S, Vertex, T>

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

pub fn both_e<A>(self, labels: A) -> GraphTraversal<S, Edge, T>

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

pub fn other(self) -> GraphTraversal<S, Vertex, T>

where T: Terminator<Vertex>,

pub fn other_v(self) -> GraphTraversal<S, Vertex, T>

where T: Terminator<Vertex>,

pub fn label(self) -> GraphTraversal<S, String, T>

where T: Terminator<String>,

pub fn to_list(&self) -> T::List

Examples found in repository

examples/traversal.rs (line 12)

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 33)

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

pub fn next(&self) -> T::Next

Examples found in repository

examples/traversal_complex.rs (line 21)

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 has_next(&self) -> T::HasNext

pub fn iter(&self) -> T::Iter

pub fn from<A>(self, target: A) -> Self

where A: Into<FromStep>,

Examples found in repository

examples/traversal_complex.rs (line 79)

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 to<A>(self, target: A) -> Self

where A: Into<ToStep>,

Examples found in repository

examples/traversal_complex.rs (line 80)

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 properties<L>(self, labels: L) -> GraphTraversal<S, GProperty, T>

where L: Into<Labels>, T: Terminator<GProperty>,

pub fn property_map<L>(self, labels: L) -> GraphTraversal<S, Map, T>

where L: Into<Labels>, T: Terminator<Map>,

pub fn values<L>(self, labels: L) -> GraphTraversal<S, GValue, T>

where L: Into<Labels>, T: Terminator<GValue>,

pub fn value_map<L>(self, labels: L) -> GraphTraversal<S, Map, T>

where L: Into<Labels>, T: Terminator<Map>,

Examples found in repository

examples/traversal_complex.rs (line 20)

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

pub fn element_map<L>(self, labels: L) -> GraphTraversal<S, Map, T>

where L: Into<Labels>, T: Terminator<Map>,

pub fn count(self) -> GraphTraversal<S, i64, T>

where T: Terminator<i64>,

pub fn group_count(self) -> GraphTraversal<S, Map, T>

where T: Terminator<Map>,

pub fn group_count_as<A>(self, key: A) -> GraphTraversal<S, E, T>

where T: Terminator<Map>, A: Into<String>,

pub fn group(self) -> GraphTraversal<S, Map, T>

where T: Terminator<Map>,

pub fn group_as<A>(self, key: A) -> GraphTraversal<S, E, T>

where T: Terminator<Map>, A: Into<String>,

pub fn by<A>(self, step: A) -> Self

where A: Into<ByStep>,

pub fn select<A>(self, step: A) -> GraphTraversal<S, GValue, T>

where A: Into<SelectStep>, T: Terminator<GValue>,

pub fn fold(self) -> GraphTraversal<S, List, T>

where T: Terminator<List>,

pub fn unfold(self) -> Self

pub fn path(self) -> GraphTraversal<S, Path, T>

where T: Terminator<Path>,

pub fn limit<A>(self, limit: A) -> Self

where A: Into<LimitStep>,

pub fn dedup<A>(self, dedup: A) -> Self

where A: Into<DedupStep>,

pub fn sum<A>(self, scope: A) -> GraphTraversal<S, GValue, T>

where A: Into<Scope>, T: Terminator<GValue>,

pub fn max<A>(self, scope: A) -> GraphTraversal<S, GValue, T>

where A: Into<Scope>, T: Terminator<GValue>,

pub fn mean<A>(self, scope: A) -> GraphTraversal<S, GValue, T>

where A: Into<Scope>, T: Terminator<GValue>,

pub fn min<A>(self, scope: A) -> GraphTraversal<S, GValue, T>

where A: Into<Scope>, T: Terminator<GValue>,

pub fn is<A>(self, val: A) -> Self

where A: IntoPredicate,

pub fn where_<A>(self, step: A) -> Self

where A: Into<WhereStep>,

Examples found in repository

examples/traversal_complex.rs (line 51)

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

pub fn not<A>(self, step: A) -> Self

where A: Into<NotStep>,

pub fn order<A>(self, scope: A) -> Self

where A: Into<Scope>,

pub fn match_<A>(self, step: A) -> GraphTraversal<S, Map, T>

where A: Into<MatchStep>, T: Terminator<Map>,

pub fn drop(self) -> Self

Examples found in repository

examples/traversal_complex.rs (line 65)

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 or<A>(self, step: A) -> Self

where A: Into<OrStep>,

pub fn map<A>(self, step: A) -> Self

where A: Into<ByStep>,

pub fn project<A>(self, step: A) -> GraphTraversal<S, GValue, T>

where A: Into<SelectStep>, T: Terminator<GValue>,

pub fn v<VT>(self, ids: VT) -> Self

where VT: Into<GIDs>,

pub fn repeat<A>(self, step: A) -> Self

where A: Into<RepeatStep>,

pub fn until<A>(self, step: A) -> Self

where A: Into<UntilStep>,

pub fn simple_path(self) -> Self

pub fn sample(self, step: i32) -> Self

pub fn loops<A>(self, step: A) -> Self

where A: Into<LoopsStep>,

pub fn local<A>(self, step: A) -> Self

where A: Into<LocalStep>,

pub fn aggregate<A>(self, alias: A) -> Self

where A: Into<String>,

pub fn value(self) -> Self

pub fn choose<A>(self, step: A) -> Self

where A: IntoChooseStep,

pub fn coalesce<B, A>(self, colaesce: A) -> GraphTraversal<S, B, T>

where A: Into<CoalesceStep>, B: FromGValue, T: Terminator<B>,

pub fn identity(self) -> Self

pub fn range(self, step: i64, step2: i64) -> Self

pub fn cap(self, step: &'static str) -> Self

pub fn barrier(self) -> Self

pub fn optional(self, step: TraversalBuilder) -> Self

pub fn constant<A>(self, value: A) -> Self

where A: Into<GValue>,

pub fn emit(self) -> Self

Trait Implementations

impl<S: Clone, E: Clone + FromGValue, T: Clone + Terminator<E>> Clone for GraphTraversal<S, E, T>

fn clone(&self) -> GraphTraversal<S, E, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.