Count Step

The count step consumes the walker and efficiently counts the number of elements that have passed through the traversal up to that point. It is a terminal step that returns a single usize value representing the total count.

In this diagram:

• Input Elements: The walker starts with elements A, B, C, D.
• The .count() step processes the stream and consumes the walker.
• Returns: usize: The step returns a single usize value, which is the total number of elements processed (4 in this case).
• Terminates Walker: This step ends the Graph API walker chain.

Syntax

walker.count()

Parameters

This step takes no parameters.

Return Value

Returns a usize representing the number of elements in the traversal.

Examples

Basic Count

Count the number of people in the graph:

    // Basic count - how many people are in the graph?
    let person_count = graph.walk().vertices(Vertex::person()).count();

    println!("Total people in graph: {}", person_count);

Filtered Count

Count elements that match specific criteria:

    // Count with filtering - how many people are over 30?
    let older_person_count = graph
        .walk()
        .vertices(Vertex::person())
        .filter_by_person(|person, _| person.age() > 30)
        .count();

    println!("People over 30: {}", older_person_count);

Edge Count

Count relationships in the graph:

    // Count relationships - how many 'follows' relationships exist?
    let knows_count = graph
        .walk()
        .vertices(VertexSearch::scan())
        .edges(Edge::follows())
        .count();

    println!("Total 'follows' relationships: {}", knows_count);

Analytics

Use counts to calculate graph analytics:

    // Count for analytics - average number of people followed per person
    let person_count = graph.walk().vertices(Vertex::person()).count();

    if person_count > 0 {
        let knows_count = graph
            .walk()
            .vertices(Vertex::person())
            .edges(Edge::follows().incoming())
            .count();

        let avg_known = knows_count as f64 / person_count as f64;
        println!("Average people followed per person: {:.2}", avg_known);
    }

Best Practices

• Use count directly rather than collecting results just to count them
• Consider indexed counts for large graphs when available in your implementation
• Combine with filter steps for specific counting queries
• Use count to validate expectations in tests and assertions

Common Use Cases

• Existence checking: Determining if any elements match criteria (count > 0)
• Graph analytics: Calculating statistics like average connections per node
• Validation: Ensuring expected numbers of elements exist in certain conditions
• Performance metrics: Measuring graph size and density characteristics