Struct AnonymousTraversalSource 

pub struct AnonymousTraversalSource { /* private fields */ }

Implementations

impl AnonymousTraversalSource

pub fn new() -> AnonymousTraversalSource

pub fn in_v(&self) -> TraversalBuilder

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

where A: Into<String>,

pub fn add_v<A>(&self, label: A) -> TraversalBuilder

where A: Into<Labels>,

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

where A: Into<GValue>,

pub fn v<T>(&self, ids: T) -> TraversalBuilder

where T: Into<GIDs>,

pub fn add_e<A>(&self, label: A) -> TraversalBuilder

where A: Into<Labels>,

pub fn count(&self) -> TraversalBuilder

pub fn out<L>(&self, labels: L) -> TraversalBuilder

where L: Into<Labels>,

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 out_e<L>(&self, labels: L) -> TraversalBuilder

where L: Into<Labels>,

pub fn in_<L>(&self, labels: L) -> TraversalBuilder

where L: Into<Labels>,

pub fn in_e<L>(&self, labels: L) -> TraversalBuilder

where L: Into<Labels>,

pub fn both<L>(&self, labels: L) -> TraversalBuilder

where L: Into<Labels>,

pub fn both_e<L>(&self, labels: L) -> TraversalBuilder

where L: Into<Labels>,

pub fn other(&self) -> TraversalBuilder

pub fn other_v(&self) -> TraversalBuilder

pub fn values<L>(&self, labels: L) -> TraversalBuilder

where L: Into<Labels>,

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

where L: Into<Labels>,

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

where A: Into<String>,

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

where A: Into<HasStep>,

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

where A: Into<HasStep>,

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

where A: Into<NotStep>,

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

where A: Into<LoopsStep>,

pub fn select<A>(&self, step: A) -> TraversalBuilder

where A: Into<SelectStep>,

pub fn fold(&self) -> TraversalBuilder

pub fn unfold(&self) -> TraversalBuilder

pub fn out_v(&self) -> TraversalBuilder

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

where A: IntoPredicate,

pub fn or<A>(&self, step: A) -> TraversalBuilder

where A: Into<OrStep>,

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

where A: Into<WhereStep>,

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

pub fn project<A>(&self, step: A) -> TraversalBuilder

where A: Into<SelectStep>,

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

where A: Into<GValue>,

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

where A: Into<UntilStep>,

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

where A: Into<RepeatStep>,

pub fn emit(&self) -> TraversalBuilder

Trait Implementations

impl Default for AnonymousTraversalSource

fn default() -> Self

Returns the “default value” for a type.