rinq 0.1.0

Type-safe, zero-cost LINQ-inspired query engine for Rust — filter, sort, aggregate, window analytics, parallel execution, and statistical extensions.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

// src/macros/mod.rs
// Convenience macros exported from the `rinq` crate.

/// Time and optionally log a query terminal operation.
///
/// In debug builds (`cfg(debug_assertions)`), `rinq_explain!` wraps the
/// expression with [`std::time::Instant`] timing and prints the elapsed time
/// to stderr. In release builds the macro is a zero-cost pass-through.
///
/// # Examples
///
/// ```rust
/// use rinq::{QueryBuilder, rinq_explain};
///
/// let result: Vec<i32> = rinq_explain!(
///     QueryBuilder::from(vec![1, 2, 3, 4, 5])
///         .where_(|x| x % 2 == 0)
///         .collect::<Vec<_>>()
/// );
/// assert_eq!(result, vec![2, 4]);
/// ```
#[macro_export]
macro_rules! rinq_explain {
    ($expr:expr) => {{
        #[cfg(debug_assertions)]
        {
            let __start = ::std::time::Instant::now();
            let __result = $expr;
            let __elapsed = __start.elapsed();
            ::std::eprintln!("[rinq_explain] elapsed: {:?}", __elapsed);
            __result
        }
        #[cfg(not(debug_assertions))]
        {
            $expr
        }
    }};
}

/// Build a predicate closure from a simple expression.
///
/// `pred!` converts a boolean expression into a `|x| x.field op value`
/// closure, removing the repetition of the closure syntax.
///
/// # Single condition
///
/// ```rust
/// use rinq::{QueryBuilder, pred};
///
/// #[derive(Debug, Clone)]
/// struct User { age: u32, active: bool }
///
/// let users = vec![
///     User { age: 20, active: true },
///     User { age: 15, active: false },
///     User { age: 30, active: true },
/// ];
///
/// let result: Vec<_> = QueryBuilder::from(users)
///     .where_(pred!(age > 18))
///     .collect();
/// assert_eq!(result.len(), 2);
/// ```
///
/// # Compound condition with `&&`
///
/// ```rust
/// use rinq::{QueryBuilder, pred};
///
/// #[derive(Debug, Clone)]
/// struct User { age: u32, active: bool }
///
/// let users = vec![
///     User { age: 20, active: true },
///     User { age: 15, active: false },
///     User { age: 30, active: false },
/// ];
///
/// let result: Vec<_> = QueryBuilder::from(users)
///     .where_(pred!(age > 18 && active == true))
///     .collect();
/// assert_eq!(result.len(), 1);
/// ```
/// Internal helper for `pred!` — expands into an inline boolean expression
/// (not a closure) given a bound variable name and the condition tokens.
#[macro_export]
#[doc(hidden)]
macro_rules! pred_inner {
    // terminal: field op literal
    ($item:ident, $field:ident $op:tt $value:literal) => {
        $item.$field $op $value
    };
    // terminal: field op bool ident (true / false)
    ($item:ident, $field:ident $op:tt $value:ident) => {
        $item.$field $op $value
    };
    // compound: field op literal && rest
    ($item:ident, $field:ident $op:tt $value:literal && $($rest:tt)+) => {
        $item.$field $op $value && $crate::pred_inner!($item, $($rest)+)
    };
    // compound: field op ident && rest
    ($item:ident, $field:ident $op:tt $value:ident && $($rest:tt)+) => {
        $item.$field $op $value && $crate::pred_inner!($item, $($rest)+)
    };
}

/// Build a predicate closure from a field-expression shorthand.
///
/// `pred!(field op value)` expands to `|item: &_| item.field op value`,
/// saving repetition when used with `where_`.
/// Multiple conditions can be chained with `&&`.
///
/// # Examples
///
/// ```rust
/// use rinq::{QueryBuilder, pred};
///
/// #[derive(Debug, Clone)]
/// struct User { age: u32, active: bool }
///
/// let users = vec![
///     User { age: 20, active: true },
///     User { age: 15, active: false },
///     User { age: 30, active: true },
/// ];
///
/// // Single condition
/// let adults: Vec<_> = QueryBuilder::from(users.clone())
///     .where_(pred!(age > 18))
///     .collect();
/// assert_eq!(adults.len(), 2);
///
/// // Compound condition
/// let active_adults: Vec<_> = QueryBuilder::from(users)
///     .where_(pred!(age > 18 && active == true))
///     .collect();
/// assert_eq!(active_adults.len(), 2);
/// ```
#[macro_export]
macro_rules! pred {
    ($($tt:tt)+) => {
        |__pred_item: &_| $crate::pred_inner!(__pred_item, $($tt)+)
    };
}