Struct Query 

pub struct Query<'a, T: 'static> { /* private fields */ }

A query builder for filtering, selecting, ordering, grouping, and aggregating data.

Type Parameters

• 'a - The lifetime of the data being queried
• T - The type of items in the collection

Example

let products = vec![/* ... */];
let query = Query::new(&products)
    .where_(Product::price_r(), |&price| price < 100.0)
    .order_by_float(Product::price_r());

Implementations

impl<'a, T: 'static> Query<'a, T>

pub fn new(data: &'a [T]) -> Self

Creates a new query from a slice of data.

Arguments

• data - A slice of items to query

Example

let query = Query::new(&products);

pub fn where_<F>( self, path: KeyPaths<T, F>, predicate: impl Fn(&F) -> bool + 'static, ) -> Self

where F: 'static,

Adds a filter predicate using a key-path.

Arguments

• path - The key-path to the field to filter on
• predicate - A function that returns true for items to keep

Example

let query = Query::new(&products)
    .where_(Product::category_r(), |cat| cat == "Electronics");

pub fn all(&self) -> Vec<&T>

Returns all items matching the query filters.

Example

let results = query.all();

pub fn first(&self) -> Option<&T>

Returns the first item matching the query filters.

Example

let first = query.first();

pub fn count(&self) -> usize

Returns the count of items matching the query filters.

Example

let count = query.count();

pub fn limit(&self, n: usize) -> Vec<&T>

Returns the first n items matching the query filters.

Arguments

• n - The maximum number of items to return

Example

let first_10 = query.limit(10);

pub fn skip<'b>(&'b self, offset: usize) -> QueryWithSkip<'a, 'b, T>

Skips the first offset items for pagination.

Arguments

• offset - The number of items to skip

Example

let page_2 = query.skip(20).limit(10);

pub fn select<F>(&self, path: KeyPaths<T, F>) -> Vec<F>

where F: Clone + 'static,

Projects/selects a single field from results.

Arguments

• path - The key-path to the field to select

Example

let names = query.select(Product::name_r());

pub fn sum<F>(&self, path: KeyPaths<T, F>) -> F

where F: Clone + Add<Output = F> + Default + 'static,

Computes the sum of a numeric field.

Arguments

• path - The key-path to the numeric field

Example

let total_price = query.sum(Product::price_r());

pub fn avg(&self, path: KeyPaths<T, f64>) -> Option<f64>

Computes the average of a float field.

Arguments

• path - The key-path to the f64 field

Example

let avg_price = query.avg(Product::price_r()).unwrap_or(0.0);

pub fn min<F>(&self, path: KeyPaths<T, F>) -> Option<F>

where F: Ord + Clone + 'static,

Finds the minimum value of a field.

Arguments

• path - The key-path to the field

Example

let min_stock = query.min(Product::stock_r());

pub fn max<F>(&self, path: KeyPaths<T, F>) -> Option<F>

where F: Ord + Clone + 'static,

Finds the maximum value of a field.

Arguments

• path - The key-path to the field

Example

let max_stock = query.max(Product::stock_r());

pub fn min_float(&self, path: KeyPaths<T, f64>) -> Option<f64>

Finds the minimum value of a float field.

Arguments

• path - The key-path to the f64 field

Example

let min_price = query.min_float(Product::price_r());

pub fn max_float(&self, path: KeyPaths<T, f64>) -> Option<f64>

Finds the maximum value of a float field.

Arguments

• path - The key-path to the f64 field

Example

let max_price = query.max_float(Product::price_r());

pub fn exists(&self) -> bool

Checks if any items match the query filters.

Example

let has_results = query.exists();

pub fn where_after_systemtime( self, path: KeyPaths<T, SystemTime>, reference: SystemTime, ) -> Self

Filter by SystemTime being after a reference time.

Arguments

• path - The key-path to the SystemTime field
• reference - The reference time to compare against

Example

let recent = query.where_after_systemtime(Event::timestamp_r(), &cutoff_time);

pub fn where_before_systemtime( self, path: KeyPaths<T, SystemTime>, reference: SystemTime, ) -> Self

Filter by SystemTime being before a reference time.

Arguments

• path - The key-path to the SystemTime field
• reference - The reference time to compare against

Example

let old = query.where_before_systemtime(Event::timestamp_r(), &cutoff_time);

pub fn where_between_systemtime( self, path: KeyPaths<T, SystemTime>, start: SystemTime, end: SystemTime, ) -> Self

Filter by SystemTime being between two times (inclusive).

Arguments

• path - The key-path to the SystemTime field
• start - The start time
• end - The end time

Example

let range = query.where_between_systemtime(Event::timestamp_r(), &start, &end);

impl<'a, T: 'static + Clone> Query<'a, T>

pub fn order_by<F>(&self, path: KeyPaths<T, F>) -> Vec<T>

where F: Ord + Clone + 'static,

Orders results by a field in ascending order.

Note: This method requires T: Clone as it creates owned sorted copies.

Arguments

• path - The key-path to the field to order by

Example

let sorted = query.order_by(Product::name_r());

pub fn order_by_desc<F>(&self, path: KeyPaths<T, F>) -> Vec<T>

where F: Ord + Clone + 'static,

Orders results by a field in descending order.

Note: This method requires T: Clone as it creates owned sorted copies.

Arguments

• path - The key-path to the field to order by

Example

let sorted = query.order_by_desc(Product::stock_r());

pub fn order_by_float(&self, path: KeyPaths<T, f64>) -> Vec<T>

Orders results by a float field in ascending order.

Note: This method requires T: Clone as it creates owned sorted copies.

Arguments

• path - The key-path to the f64 field to order by

Example

let sorted = query.order_by_float(Product::price_r());

pub fn order_by_float_desc(&self, path: KeyPaths<T, f64>) -> Vec<T>

Orders results by a float field in descending order.

Note: This method requires T: Clone as it creates owned sorted copies.

Arguments

• path - The key-path to the f64 field to order by

Example

let sorted = query.order_by_float_desc(Product::rating_r());

pub fn group_by<F>(&self, path: KeyPaths<T, F>) -> HashMap<F, Vec<T>>

where F: Eq + Hash + Clone + 'static,

Groups results by a field value.

Note: This method requires T: Clone as it creates owned copies in groups.

Arguments

• path - The key-path to the field to group by

Example

let by_category = query.group_by(Product::category_r());