Struct QueryBuilder 

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

Builder for creating and executing document queries.

QueryBuilder uses a fluent interface pattern to construct and execute queries against Aurora collections.

Examples

// Query for active premium users
let premium_users = db.query("users")
    .filter(|f| f.eq("status", "active") && f.eq("account_type", "premium"))
    .order_by("created_at", false)
    .limit(10)
    .collect()
    .await?;

Implementations

impl<'a> QueryBuilder<'a>

pub fn new(db: &'a Aurora, collection: &str) -> Self

Create a new query builder for the specified collection

Examples

let query = db.query("users");

pub fn filter<F>(self, filter_fn: F) -> Self

where F: Fn(&FilterBuilder<'_, '_>) -> bool + Send + Sync + 'a,

Add a filter function to the query

Examples

let active_users = db.query("users")
    .filter(|f| f.eq("status", "active"))
    .collect()
    .await?;

pub fn order_by(self, field: &str, ascending: bool) -> Self

Sort results by a field (ascending or descending)

Parameters

• field - The field to sort by
• ascending - true for ascending order, false for descending

Examples

// Sort by age ascending
.order_by("age", true)

// Sort by creation date descending (newest first)
.order_by("created_at", false)

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

Limit the number of results returned

Examples

// Get at most 10 results
.limit(10)

pub fn offset(self, offset: usize) -> Self

Skip a number of results (for pagination)

Examples

// For pagination: skip the first 20 results and get the next 10
.offset(20).limit(10)

pub fn select(self, fields: &[&str]) -> Self

Select only specific fields to return

Examples

// Only return name and email fields
.select(&["name", "email"])

pub async fn collect(self) -> Result<Vec<Document>>

Execute the query and collect the results

Returns

A vector of documents matching the query criteria

Examples

let results = db.query("products")
    .filter(|f| f.lt("price", 100))
    .collect()
    .await?;

pub async fn watch(self) -> Result<QueryWatcher>

where 'a: 'static,

Watch the query for real-time updates

Returns a QueryWatcher that emits updates when documents are added, removed, or modified in ways that affect the query results.

Note: This method requires the QueryBuilder to have a ’static lifetime, which means the database reference must also be ’static (e.g., Arc).

Examples

let mut watcher = db.query("users")
    .filter(|f| f.eq("active", true))
    .watch()
    .await?;

// Receive updates in real-time
while let Some(update) = watcher.next().await {
    match update {
        QueryUpdate::Added(doc) => println!("New: {:?}", doc),
        QueryUpdate::Removed(doc) => println!("Removed: {:?}", doc),
        QueryUpdate::Modified { old, new } => println!("Modified: {:?}", new),
    }
}

pub async fn first_one(self) -> Result<Option<Document>>

Get only the first matching document or None if no matches

Examples

let user = db.query("users")
    .filter(|f| f.eq("email", "jane@example.com"))
    .first_one()
    .await?;

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

Count the number of documents matching the query

Examples

let active_count = db.query("users")
    .filter(|f| f.eq("status", "active"))
    .count()
    .await?;

pub async fn update(self, updates: HashMap<&str, Value>) -> Result<usize>

Update documents matching the query with new field values

Returns

The number of documents updated

Examples

let updated = db.query("products")
    .filter(|f| f.lt("stock", 5))
    .update([
        ("status", Value::String("low_stock".to_string())),
        ("needs_reorder", Value::Bool(true))
    ].into_iter().collect())
    .await?;