Struct LockQuery 

pub struct LockQuery<'a, T: 'static, L>
where
    L: LockValue<T> + 'a,
{ /* private fields */ }

A query builder for locked data structures.

Provides full SQL-like query operations (WHERE, SELECT, ORDER BY, GROUP BY) on collections of locked values without unnecessary copying.

Implementations

impl<'a, T: 'static, L> LockQuery<'a, T, L>

where L: LockValue<T> + 'a,

pub fn from_locks(locks: Vec<&'a L>) -> Self

Create a new lock query from a collection of locks.

Example

let query = LockQuery::from_locks(product_map.values().collect());

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

where F: 'static,

Add a WHERE clause using a key-path.

Example

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

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

where T: Clone,

Get all matching items (collects by cloning).

Example

let results: Vec<Product> = query.all();

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

where T: Clone,

Get the first matching item.

Example

let first = query.first();

pub fn count(&self) -> usize

Count matching items.

Example

let count = query.count();

pub fn exists(&self) -> bool

Check if any items match.

Example

let exists = query.exists();

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

where T: Clone,

Limit results to first N items.

Example

let first_10 = query.limit(10);

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

where F: Clone + 'static,

Select/project a field.

Example

let names: Vec<String> = query.select(Product::name_r());

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

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

Sum a numeric field.

Example

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

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

Calculate average of f64 field.

Example

let avg = query.avg(Product::price_r());

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

where F: Ord + Clone + 'static,

Find minimum value.

Example

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

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

where F: Ord + Clone + 'static,

Find maximum value.

Example

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

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

Find minimum float value.

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

Find maximum float value.

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

where F: Ord + Clone + 'static, T: Clone,

Order by a field (requires collecting data).

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, T: Clone,

Order by a field descending.

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

where T: Clone,

Order by float field.

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

where T: Clone,

Order by float field descending.

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

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

Group by a field.

Example

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