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(), |&price| price < 100.0)
    .order_by_float(Product::price());

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(), |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());

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());

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()).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());

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());

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());

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());

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(), &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(), &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(), &start, &end);

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

pub fn where_after<Tz>( self, path: KeyPaths<T, DateTime<Tz>>, reference: DateTime<Tz>, ) -> Self

where Tz: TimeZone + 'static, Tz::Offset: Display,

Filter by DateTime being after a reference time.

Arguments

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

Example

let recent = query.where_after(Event::timestamp(), &cutoff_time);

pub fn where_before<Tz>( self, path: KeyPaths<T, DateTime<Tz>>, reference: DateTime<Tz>, ) -> Self

where Tz: TimeZone + 'static, Tz::Offset: Display,

Filter by DateTime being before a reference time.

Arguments

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

Example

let old = query.where_before(Event::timestamp(), &cutoff_time);

pub fn where_between<Tz>( self, path: KeyPaths<T, DateTime<Tz>>, start: DateTime<Tz>, end: DateTime<Tz>, ) -> Self

where Tz: TimeZone + 'static, Tz::Offset: Display,

Filter by DateTime being between two times (inclusive).

Arguments

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

Example

let range = query.where_between(Event::timestamp(), &start, &end);

pub fn where_today<Tz>( self, path: KeyPaths<T, DateTime<Tz>>, now: DateTime<Tz>, ) -> Self

where Tz: TimeZone + 'static, Tz::Offset: Display,

Filter by DateTime being today.

Arguments

• path - The key-path to the DateTime field
• now - The current DateTime to compare against

Example

let today = query.where_today(Event::timestamp(), &Utc::now());

pub fn where_year<Tz>(self, path: KeyPaths<T, DateTime<Tz>>, year: i32) -> Self

where Tz: TimeZone + 'static, Tz::Offset: Display,

Filter by DateTime year.

Arguments

• path - The key-path to the DateTime field
• year - The year to filter by

Example

let this_year = query.where_year(Event::timestamp(), 2024);

pub fn where_month<Tz>( self, path: KeyPaths<T, DateTime<Tz>>, month: u32, ) -> Self

where Tz: TimeZone + 'static, Tz::Offset: Display,

Filter by DateTime month.

Arguments

• path - The key-path to the DateTime field
• month - The month to filter by (1-12)

Example

let december = query.where_month(Event::timestamp(), 12);

pub fn where_day<Tz>(self, path: KeyPaths<T, DateTime<Tz>>, day: u32) -> Self

where Tz: TimeZone + 'static, Tz::Offset: Display,

Filter by DateTime day.

Arguments

• path - The key-path to the DateTime field
• day - The day to filter by (1-31)

Example

let first = query.where_day(Event::timestamp(), 1);

pub fn where_weekend<Tz>(self, path: KeyPaths<T, DateTime<Tz>>) -> Self

where Tz: TimeZone + 'static, Tz::Offset: Display,

Filter by weekend dates (Saturday and Sunday).

Arguments

• path - The key-path to the DateTime field

Example

let weekend_events = query.where_weekend(Event::timestamp());

pub fn where_weekday<Tz>(self, path: KeyPaths<T, DateTime<Tz>>) -> Self

where Tz: TimeZone + 'static, Tz::Offset: Display,

Filter by weekday dates (Monday through Friday).

Arguments

• path - The key-path to the DateTime field

Example

let weekday_events = query.where_weekday(Event::timestamp());

pub fn where_business_hours<Tz>(self, path: KeyPaths<T, DateTime<Tz>>) -> Self

where Tz: TimeZone + 'static, Tz::Offset: Display,

Filter by business hours (9 AM - 5 PM).

Arguments

• path - The key-path to the DateTime field

Example

let business_hours = query.where_business_hours(Event::timestamp());

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());

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());

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());

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());

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());

pub fn min_timestamp(&self, path: KeyPaths<T, i64>) -> Option<i64>

Finds the minimum i64 timestamp value.

Arguments

• path - The key-path to the i64 timestamp field

Example

let earliest = query.min_timestamp(Event::created_at());

pub fn max_timestamp(&self, path: KeyPaths<T, i64>) -> Option<i64>

Finds the maximum i64 timestamp value.

Arguments

• path - The key-path to the i64 timestamp field

Example

let latest = query.max_timestamp(Event::created_at());

pub fn avg_timestamp(&self, path: KeyPaths<T, i64>) -> Option<i64>

Calculates the average of i64 timestamp values.

Arguments

• path - The key-path to the i64 timestamp field

Example

let avg_timestamp = query.avg_timestamp(Event::created_at()).unwrap_or(0);

pub fn sum_timestamp(&self, path: KeyPaths<T, i64>) -> i64

Calculates the sum of i64 timestamp values.

Arguments

• path - The key-path to the i64 timestamp field

Example

let total_timestamp = query.sum_timestamp(Event::created_at());

pub fn count_timestamp(&self, path: KeyPaths<T, i64>) -> usize

Counts the number of non-null i64 timestamp values.

Arguments

• path - The key-path to the i64 timestamp field

Example

let timestamp_count = query.count_timestamp(Event::created_at());

pub fn where_after_timestamp( self, path: KeyPaths<T, i64>, reference: i64, ) -> Self

Filters by i64 timestamp being after a reference timestamp.

Arguments

• path - The key-path to the i64 timestamp field
• reference - The reference timestamp to compare against

Example

let recent = query.where_after_timestamp(Event::created_at(), cutoff_timestamp);

pub fn where_before_timestamp( self, path: KeyPaths<T, i64>, reference: i64, ) -> Self

Filters by i64 timestamp being before a reference timestamp.

Arguments

• path - The key-path to the i64 timestamp field
• reference - The reference timestamp to compare against

Example

let old = query.where_before_timestamp(Event::created_at(), cutoff_timestamp);

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

Filters by i64 timestamp being between two timestamps (inclusive).

Arguments

• path - The key-path to the i64 timestamp field
• start - The start timestamp
• end - The end timestamp

Example

let range = query.where_between_timestamp(Event::created_at(), start_ts, end_ts);

pub fn where_last_days_timestamp( self, path: KeyPaths<T, i64>, days: i64, ) -> Self

Filters by i64 timestamp being within the last N days from now.

Arguments

• path - The key-path to the i64 timestamp field
• days - Number of days to look back

Example

let recent = query.where_last_days_timestamp(Event::created_at(), 30);

pub fn where_next_days_timestamp( self, path: KeyPaths<T, i64>, days: i64, ) -> Self

Filters by i64 timestamp being within the next N days from now.

Arguments

• path - The key-path to the i64 timestamp field
• days - Number of days to look ahead

Example

let upcoming = query.where_next_days_timestamp(Event::scheduled_at(), 7);

pub fn where_last_hours_timestamp( self, path: KeyPaths<T, i64>, hours: i64, ) -> Self

Filters by i64 timestamp being within the last N hours from now.

Arguments

• path - The key-path to the i64 timestamp field
• hours - Number of hours to look back

Example

let recent = query.where_last_hours_timestamp(Event::created_at(), 24);

pub fn where_next_hours_timestamp( self, path: KeyPaths<T, i64>, hours: i64, ) -> Self

Filters by i64 timestamp being within the next N hours from now.

Arguments

• path - The key-path to the i64 timestamp field
• hours - Number of hours to look ahead

Example

let upcoming = query.where_next_hours_timestamp(Event::scheduled_at(), 2);

pub fn where_last_minutes_timestamp( self, path: KeyPaths<T, i64>, minutes: i64, ) -> Self

Filters by i64 timestamp being within the last N minutes from now.

Arguments

• path - The key-path to the i64 timestamp field
• minutes - Number of minutes to look back

Example

let recent = query.where_last_minutes_timestamp(Event::created_at(), 60);

pub fn where_next_minutes_timestamp( self, path: KeyPaths<T, i64>, minutes: i64, ) -> Self

Filters by i64 timestamp being within the next N minutes from now.

Arguments

• path - The key-path to the i64 timestamp field
• minutes - Number of minutes to look ahead

Example

let upcoming = query.where_next_minutes_timestamp(Event::scheduled_at(), 30);

pub fn order_by_timestamp(&self, path: KeyPaths<T, i64>) -> Vec<T>

Orders results by i64 timestamp in ascending order (oldest first).

Arguments

• path - The key-path to the i64 timestamp field

Example

let sorted = query.order_by_timestamp(Event::created_at());

pub fn order_by_timestamp_desc(&self, path: KeyPaths<T, i64>) -> Vec<T>

Orders results by i64 timestamp in descending order (newest first).

Arguments

• path - The key-path to the i64 timestamp field

Example

let sorted = query.order_by_timestamp_desc(Event::created_at());