Struct arel::statements::filter::Filter

pub struct Filter<M: Arel> { /* private fields */ }

Implementations

impl<M: Arel> Filter<M>

pub fn and_filter<K: AsRef<str>, V: Into<Value>>( &mut self, key: K, value: V ) -> &mut Self

Examples

use arel::prelude::*;
use arel::statements::filter::Filter;
#[arel]
struct User {}
impl Arel for User {}
let mut filter = Filter::<User>::default();
filter.and_filter("username", "sanmu");
#[cfg(any(feature = "sqlite", feature = "mysql"))]
assert_eq!(filter.to_sql().unwrap().unwrap().to_sql_string().unwrap(), r#""user"."username" = ?"#);

filter.and_filter("age", vec![18, 20]);
#[cfg(any(feature = "sqlite", feature = "mysql"))]
assert_eq!(filter.to_sql().unwrap().unwrap().to_sql_string().unwrap(), r#""user"."username" = ? AND "user"."age" IN (?, ?)"#);

pub fn and_filter_pairs<K: AsRef<str>, V: Into<Value>>( &mut self, pairs: Vec<(K, V)> ) -> &mut Self

Examples

use arel::prelude::*;
use arel::statements::filter::Filter;
#[arel]
struct User {}
impl Arel for User {}
let mut filter = Filter::<User>::default();
filter.and_filter_pairs(vec![("username", Into::<arel::Value>::into("sanmu")), ("age", Into::<arel::Value>::into(vec![18, 20]))]);
#[cfg(any(feature = "sqlite", feature = "mysql"))]
assert_eq!(filter.to_sql().unwrap().unwrap().to_sql_string().unwrap(), r#""user"."username" = ? AND "user"."age" IN (?, ?)"#);

filter.and_filter("gender", "male");
#[cfg(any(feature = "sqlite", feature = "mysql"))]
assert_eq!(filter.to_sql().unwrap().unwrap().to_sql_string().unwrap(), r#""user"."username" = ? AND "user"."age" IN (?, ?) AND "user"."gender" = ?"#);

pub fn and_filter_sql<S: Into<Sql>>(&mut self, sql: S) -> &mut Self

pub fn and_not_filter<K: AsRef<str>, V: Into<Value>>( &mut self, key: K, value: V ) -> &mut Self

Examples

use arel::prelude::*;
use arel::statements::filter::Filter;
#[arel]
struct User {}
impl Arel for User {}
let mut filter = Filter::<User>::default();
filter.and_not_filter("username", "sanmu");
#[cfg(any(feature = "sqlite", feature = "mysql"))]
assert_eq!(filter.to_sql().unwrap().unwrap().to_sql_string().unwrap(), r#""user"."username" != ?"#);

filter.and_not_filter("aga", vec![18, 20]);
#[cfg(any(feature = "sqlite", feature = "mysql"))]
assert_eq!(filter.to_sql().unwrap().unwrap().to_sql_string().unwrap(), r#""user"."username" != ? AND "user"."aga" NOT IN (?, ?)"#);

pub fn and_not_filter_pairs<K: AsRef<str>, V: Into<Value>>( &mut self, pairs: Vec<(K, V)> ) -> &mut Self

pub fn or_filter<K: AsRef<str>, V: Into<Value>>( &mut self, key: K, value: V ) -> &mut Self

Examples

use arel::prelude::*;
use arel::statements::filter::Filter;
#[arel]
struct User {}
impl Arel for User {}
let mut filter = Filter::<User>::default();
filter.or_filter("username", "sanmu");
#[cfg(any(feature = "sqlite", feature = "mysql"))]
assert_eq!(filter.to_sql().unwrap().unwrap().to_sql_string().unwrap(), r#""user"."username" = ?"#);

filter.or_filter("age", vec![18, 20]);
#[cfg(any(feature = "sqlite", feature = "mysql"))]
assert_eq!(filter.to_sql().unwrap().unwrap().to_sql_string().unwrap(), r#""user"."username" = ? OR "user"."age" IN (?, ?)"#);

filter.and_filter("gender", "male");
#[cfg(any(feature = "sqlite", feature = "mysql"))]
assert_eq!(filter.to_sql().unwrap().unwrap().to_sql_string().unwrap(), r#""user"."username" = ? OR "user"."age" IN (?, ?) AND "user"."gender" = ?"#);

pub fn or_filter_pairs<K: AsRef<str>, V: Into<Value>>( &mut self, pairs: Vec<(K, V)> ) -> &mut Self

Examples

use arel::prelude::*;
use arel::statements::filter::Filter;
#[arel]
struct User {}
impl Arel for User {}
let mut filter = Filter::<User>::default();
filter.or_filter_pairs(vec![("username", Into::<arel::Value>::into("sanmu")), ("age", Into::<arel::Value>::into(vec![18, 20]))]);
#[cfg(any(feature = "sqlite", feature = "mysql"))]
assert_eq!(filter.to_sql().unwrap().unwrap().to_sql_string().unwrap(), r#"("user"."username" = ? OR "user"."age" IN (?, ?))"#);

filter.or_filter("gender", "male");
#[cfg(any(feature = "sqlite", feature = "mysql"))]
assert_eq!(filter.to_sql().unwrap().unwrap().to_sql_string().unwrap(), r#"("user"."username" = ? OR "user"."age" IN (?, ?)) OR "user"."gender" = ?"#);

pub fn or_filter_sql<S: Into<Sql>>(&mut self, sql: S) -> &mut Self

pub fn or_not_filter<K: AsRef<str>, V: Into<Value>>( &mut self, key: K, value: V ) -> &mut Self

Examples

#[cfg(any(feature = “sqlite”, feature = “mysql”))]

use arel::prelude::*;
use arel::statements::filter::Filter;
#[arel]
struct User {}
impl Arel for User {}
let mut filter = Filter::<User>::default();
filter.or_not_filter("username", "sanmu");
#[cfg(any(feature = "sqlite", feature = "mysql"))]
assert_eq!(filter.to_sql().unwrap().unwrap().to_sql_string().unwrap(), r#""user"."username" != ?"#);

filter.or_not_filter("aga", vec![18, 20]);
#[cfg(any(feature = "sqlite", feature = "mysql"))]
assert_eq!(filter.to_sql().unwrap().unwrap().to_sql_string().unwrap(), r#""user"."username" != ? OR "user"."aga" NOT IN (?, ?)"#);

pub fn or_not_filter_pairs<K: AsRef<str>, V: Into<Value>>( &mut self, pairs: Vec<(K, V)> ) -> &mut Self

pub fn unfilter_starts_with<K: AsRef<str>>(&mut self, start: K) -> &mut Self

pub fn unfilter<K: ToString>(&mut self, key: K) -> &mut Self

Examples

use arel::prelude::*;
use arel::statements::filter::Filter;
#[arel]
struct User {}
impl Arel for User {}
let mut filter = Filter::<User>::default();
filter.and_filter_pairs(vec![("username", Into::<arel::Value>::into("sanmu")), ("age", Into::<arel::Value>::into(vec![18, 20]))]);
filter.unfilter("age");
#[cfg(any(feature = "sqlite", feature = "mysql"))]
assert_eq!(filter.to_sql().unwrap().unwrap().to_sql_string().unwrap(), r#""user"."username" = ?"#);

Trait Implementations

impl<M: Arel> ArelStatement for Filter<M>

fn to_sql(&self) -> Result<Option<Sql>>

impl<M: Debug + Arel> Debug for Filter<M>

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

Formats the value using the given formatter.

impl<M: Arel> Default for Filter<M>

fn default() -> Self

Returns the “default value” for a type.