Struct ModelQuery 

pub struct ModelQuery<M> { /* private fields */ }

A trait for filtering queries

This allows you to filter, limit, offset, and order elements that you are querying.

Example

User::select()
    .filter(User::id.eq(1) & User::name.like("%test%"))
    .limit(1)
    .order(User::id.desc())
    .exec(&conn).unwrap();

Implementations

impl<M: Model> ModelQuery<M>

pub fn select() -> Self

pub fn count() -> ModelQuery<CountQuery>

impl<M> ModelQuery<M>

pub fn combine(self, query: String, params: Vec<Box<dyn ToSql>>) -> Self

pub fn filter(self, filter: impl ModelQueryFilter) -> Self

Filter the query with the given filter

Arguments

• filter - The filter to apply to the query

Example

let user = User::select()
    .filter(User::id.eq(1) & User::name.like("%test%"))
    .exec(&conn).unwrap();

pub fn with_id(self, id: i64) -> Self

Select element by id

Arguments

• id - The id of the element to select

Example

let user = User::select()
    .with_id(1)
    .exec(&conn).unwrap();

Note

This is equivalent to .filter(User::id.eq(id)).limit(1) and should not be combined with other filters or limits.

pub fn limit(self, limit: u32) -> Self

Limit the number of elements returned

Arguments

• limit - The maximum number of elements to return

Example

let users = User::select()
    .limit(10)
    .exec(&conn).unwrap();

pub fn offset(self, offset: u32) -> Self

Offset selection by the given number of elements

Arguments

• offset - The number of elements to skip

Example

let users = User::select()
    .offset(10)
    .exec(&conn).unwrap();

pub fn order_by(self, order: ColumnQueryOrder) -> Self

Order the elements by the given order

Arguments

• order - The order to apply to the elements

Example

let users = User::select()
    .order(User::id.desc())
    .exec(&conn).unwrap();

pub fn join_relation(self, relation: Column<'static>) -> Self

WARNING: This is highly experimental and may not work as expected Use Relation::get() or Relation::take() instead

Arguments

• relation - The relation to join

Example

let users = Post::select()
    .join_relation(Post::author)
    .exec(&conn).unwrap();

pub fn columns(self, columns: &[Column<'static>]) -> Self

Select only the given columns (do not use this if you want to map to a model column which is not an Option<T>)

Arguments

• columns - The columns to select

Example

let users = User::select()
    .columns(&[User::id, User::name])
    .exec(&conn).unwrap();

Trait Implementations

impl<M: Model> ColumnInQuery for ModelQuery<M>

fn to_query(self) -> RawQuery

impl<M: Model> Debug for ModelQuery<M>

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

Formats the value using the given formatter.

impl<M> Default for ModelQuery<M>

fn default() -> Self

Returns the “default value” for a type.

impl<M: Model> Executable<Vec<M>> for ModelQuery<M>

fn exec(self, conn: &Connection) -> Result<Vec<M>, Error>

impl Executable<usize> for ModelQuery<CountQuery>

fn exec(self, conn: &Connection) -> Result<usize, Error>

impl<M: Model> Queryable<Vec<M>> for ModelQuery<M>

fn get_query(&mut self) -> RawQuery

fn parse_result(&mut self, rows: Rows<'_>) -> Vec<M>

fn should_execute(&self) -> bool

impl Queryable<usize> for ModelQuery<CountQuery>

fn get_query(&mut self) -> RawQuery

fn parse_result(&mut self, rows: Rows<'_>) -> usize

fn should_execute(&self) -> bool