Struct Filter 

pub struct Filter {
    pub expr: Option<Expr>,
}

A WHERE clause filter for statements.

Wraps an optional expression. When expr is None, the filter matches all rows (equivalent to WHERE true). Filters can be combined with add_filter, which AND-s the expressions together.

Examples

use toasty_core::stmt::Filter;

// An empty filter matches everything
let filter = Filter::default();
assert!(filter.expr.is_none());

// Filter::ALL is a const alias for the same thing
assert!(Filter::ALL.expr.is_none());

Fields

expr: Option<Expr>

The filter expression, or None to match all rows.

Implementations

impl Filter

pub const ALL: Filter

A filter that matches all rows (no expression set).

pub fn new(expr: impl Into<Expr>) -> Filter

Creates a filter from an expression.

pub fn and(lhs: impl Into<Filter>, rhs: impl Into<Filter>) -> Filter

Creates a filter by AND-ing two filters together.

pub fn as_expr(&self) -> &Expr

Returns the filter expression.

When no expression is set, returns true, which matches all rows.

pub fn into_expr(self) -> Expr

Consumes the filter and returns the expression, defaulting to true.

pub fn is_false(&self) -> bool

Returns true if the filter expression is the literal false.

pub fn set(&mut self, expr: impl Into<Expr>)

Replaces the filter expression with the given expression.

pub fn add_filter(&mut self, filter: impl Into<Filter>)

Adds a filter by AND-ing it with the current expression.

If either filter is empty, the other is used directly.

pub fn take(&mut self) -> Filter

Takes the filter out, leaving an empty filter in its place.

Examples

let mut filter = Filter::default();
let taken = filter.take();
assert!(filter.expr.is_none());

Trait Implementations

impl Clone for Filter

fn clone(&self) -> Filter

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Filter

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

Formats the value using the given formatter.

impl Default for Filter

fn default() -> Filter

Returns the “default value” for a type.

impl<T> From<T> for Filter

where Expr: From<T>,

fn from(value: T) -> Filter

Converts to this type from the input type.

impl Node for Filter

fn visit<V>(&self, visit: V)

where V: Visit,

Traverses this node with an immutable visitor.

fn visit_mut<V>(&mut self, visit: V)

where V: VisitMut,

Traverses this node with a mutable visitor.

impl PartialEq for Filter

fn eq(&self, other: &Filter) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Filter