Struct Predicate 

pub struct Predicate<T: IEntityType> { /* private fields */ }

A composable WHERE predicate for entity type T.

T tags the predicate so that fragments written for different entities do not silently combine or get applied to the wrong query builder.

use rust_ef::prelude::*;
use rust_ef::query::QueryBuilder;

#[derive(Debug, Clone, EntityType)]
#[table("products")]
struct Product {
    #[primary_key]
    id: i32,
    name: String,
    description: String,
    price: f64,
    is_deleted: bool,
}

fn product_filter(keyword: Option<&str>, min_price: Option<f64>) -> Predicate<Product> {
    let keyword_group = keyword.map(|keyword| {
        linq!(|p: Product| p.name.contains(keyword))
            .or(linq!(|p: Product| p.description.contains(keyword)))
    });
    let min_price = min_price.map(|min_price| linq!(|p: Product| p.price >= min_price));

    // always() 是 AND 链起点，本身不产生 SQL；
    // and_opt 让「可选条件」不需要额外 if let。
    Predicate::<Product>::always()
        .and(linq!(|p: Product| !p.is_deleted))
        .and_opt(keyword_group)
        .and_opt(min_price)
}

let predicate = product_filter(Some("rust"), Some(9.9));
let sql = QueryBuilder::<Product>::new("products")
    .filter(predicate)
    .to_sql();
// NOT (is_deleted = ?) AND ((name LIKE ?) OR (description LIKE ?)) AND (price >= ?)
assert!(sql.contains("(name LIKE ?) OR (description LIKE ?)"));

Implementations

impl<T: IEntityType> Predicate<T>

pub fn always() -> Self

A predicate that matches every row — the seed of an AND chain.

Predicate::always().and(p) is p, so seeding with it adds no SQL.

pub fn never() -> Self

A predicate that matches no row — the seed of an OR chain.

Predicate::never().or(p) is p, so seeding with it adds no SQL.

pub fn from_expr(expr: BoolExpr) -> Self

Wraps an expression tree as a predicate.

Prefer linq!(|b: T| ...), which is already typed and self-contained. This is the unchecked door for reusing a BoolExpr produced elsewhere (e.g. a filter read back from ModelBuilder).

pub fn is_always(&self) -> bool

Whether the predicate matches every row (the AND identity).

pub fn is_never(&self) -> bool

Whether the predicate matches no row.

pub fn and(self, other: impl Into<Predicate<T>>) -> Self

self AND other.

always() is the identity (always().and(p) == p) and never() is absorbing (never().and(p) == never()), so identities never leak into the generated SQL.

pub fn and_opt(self, other: Option<impl Into<Predicate<T>>>) -> Self

self AND other when other is Some — the one-liner for an optional filter. None leaves the predicate unchanged.

pub fn or(self, other: impl Into<Predicate<T>>) -> Self

self OR other.

never() is the identity (never().or(p) == p) and always() is absorbing (always().or(p) == always()).

pub fn or_opt(self, other: Option<impl Into<Predicate<T>>>) -> Self

self OR other when other is Some; None leaves the predicate unchanged.

pub fn not(self) -> Self

NOT self.

pub fn into_expr(self) -> BoolExpr

Converts the predicate to a BoolExpr — for APIs that take an expression directly, such as ModelBuilder::has_query_filter.

always() and never() become the literal fragments 1=1 / 1=0.

Trait Implementations

impl<T: Clone + IEntityType> Clone for Predicate<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug + IEntityType> Debug for Predicate<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: IEntityType> From<BoolExpr> for Predicate<T>

fn from(expr: BoolExpr) -> Self

Lets BoolExpr fragments (e.g. a stored global filter) be combined directly. This conversion is unchecked: prefer linq!(...).

impl<T: IEntityType> From<Predicate<T>> for BoolExpr

fn from(predicate: Predicate<T>) -> Self

Converts to this type from the input type.