Struct QueryBuilder 

pub struct QueryBuilder<'a> { /* private fields */ }

Fluent query builder for graph operations.

Allows chaining multiple filters to find specific nodes in the graph.

Examples

use codegraph::{CodeGraph, NodeType};

let mut graph = CodeGraph::in_memory()?;
// ... populate graph ...

// Find all public functions in a specific file
let results = graph.query()
    .node_type(NodeType::Function)
    .in_file("src/main.rs")
    .property("visibility", "public")
    .execute()?;

Implementations

impl<'a> QueryBuilder<'a>

pub fn new(graph: &'a CodeGraph) -> Self

Create a new query builder for the given graph.

pub fn node_type(self, node_type: NodeType) -> Self

Filter nodes by type.

Examples

let functions = graph.query()
    .node_type(NodeType::Function)
    .execute()?;

pub fn in_file(self, file_path: &str) -> Self

Filter nodes that are contained in a specific file.

Looks up the file by path and finds all nodes connected via Contains edges.

pub fn file_pattern(self, pattern: &str) -> Self

Filter files by glob pattern.

Supports wildcards: * matches any characters, ** matches directories.

Examples

• src/*.rs - All Rust files in src/
• **/*.py - All Python files recursively
• tests/**/*.rs - All Rust files under tests/

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

Filter nodes by exact property match.

Supports string, int, float, and bool property values.

pub fn property_exists(self, key: &str) -> Self

Filter nodes that have a specific property (regardless of value).

pub fn name_contains(self, substring: &str) -> Self

Filter nodes by name containing a substring (case-insensitive).

pub fn name_matches(self, pattern: &str) -> Self

Filter nodes by name matching a regex pattern.

pub fn custom<F>(self, predicate: F) -> Self

where F: Fn(&Node) -> bool + 'static,

Filter nodes using a custom predicate function.

Examples

// Find functions longer than 50 lines
let results = graph.query()
    .node_type(NodeType::Function)
    .custom(|node| {
        if let (Some(start), Some(end)) = (
            node.properties.get_int("line_start"),
            node.properties.get_int("line_end")
        ) {
            (end - start) > 50
        } else {
            false
        }
    })
    .execute()?;

pub fn limit(self, n: usize) -> Self

Limit the number of results returned.

pub fn execute(&self) -> Result<Vec<NodeId>>

Execute the query and return matching node IDs.

pub fn count(&self) -> Result<usize>

Count the number of matching nodes without allocating a result vector.

pub fn exists(&self) -> Result<bool>

Check if any nodes match the query (short-circuits on first match).