Struct SelectQuery 

pub struct SelectQuery<'a> {
    pub table_name: &'a str,
    pub distinct: bool,
    pub columns: &'a [&'a str],
    pub filters: Option<Vec<Box<dyn BooleanExpression>>>,
    pub joins: Option<Vec<Join<'a>>>,
    pub sorts: Option<Vec<Sort>>,
    pub limit: Option<usize>,
}

Fields

table_name: &'a str

distinct: bool

columns: &'a [&'a str]

filters: Option<Vec<Box<dyn BooleanExpression>>>

joins: Option<Vec<Join<'a>>>

sorts: Option<Vec<Sort>>

limit: Option<usize>

Implementations

impl<'a> SelectQuery<'a>

pub const fn distinct(self) -> Self

pub const fn columns(self, columns: &'a [&'a str]) -> Self

pub fn joins(self, joins: Vec<Join<'a>>) -> Self

pub fn join(self, table_name: &'a str, on: &'a str) -> Self

pub fn left_joins(self, left_joins: Vec<Join<'a>>) -> Self

pub fn left_join(self, table_name: &'a str, on: &'a str) -> Self

pub fn sorts(self, sorts: Vec<Sort>) -> Self

pub fn sort<T>(self, expression: T, direction: SortDirection) -> Self

where T: Into<Identifier>,

pub const fn limit(self, limit: usize) -> Self

pub async fn execute(self, db: &dyn Database) -> Result<Vec<Row>, DatabaseError>

Errors

Will return Err if the select query execution failed.

pub async fn execute_first( self, db: &dyn Database, ) -> Result<Option<Row>, DatabaseError>

Errors

Will return Err if the select query execution failed.

Trait Implementations

impl<'a> Debug for SelectQuery<'a>

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

Formats the value using the given formatter.

impl Expression for SelectQuery<'_>

fn expression_type(&self) -> ExpressionType<'_>

fn values(&self) -> Option<Vec<&DatabaseValue>>

fn params(&self) -> Option<Vec<&DatabaseValue>>

fn is_null(&self) -> bool

impl FilterableQuery for SelectQuery<'_>

fn filter(self, filter: Box<dyn BooleanExpression>) -> Self

fn filters(self, filters: Vec<Box<dyn BooleanExpression>>) -> Self

fn filter_if_some<T: BooleanExpression + 'static>( self, filter: Option<T>, ) -> Self

fn where_in<L, V>(self, left: L, values: V) -> Self

where L: Into<Identifier>, V: Into<Box<dyn List>>,

fn where_not_in<L, V>(self, left: L, values: V) -> Self

where L: Into<Identifier>, V: Into<Box<dyn List>>,

fn where_and(self, conditions: Vec<Box<dyn BooleanExpression>>) -> Self

fn where_or(self, conditions: Vec<Box<dyn BooleanExpression>>) -> Self

fn where_eq<L, R>(self, left: L, right: R) -> Self

where L: Into<Identifier>, R: Into<Box<dyn Expression>>,

fn where_not_eq<L, R>(self, left: L, right: R) -> Self

where L: Into<Identifier>, R: Into<Box<dyn Expression>>,

fn where_gt<L, R>(self, left: L, right: R) -> Self

where L: Into<Identifier>, R: Into<Box<dyn Expression>>,

fn where_gte<L, R>(self, left: L, right: R) -> Self

where L: Into<Identifier>, R: Into<Box<dyn Expression>>,

fn where_lt<L, R>(self, left: L, right: R) -> Self

where L: Into<Identifier>, R: Into<Box<dyn Expression>>,

fn where_lte<L, R>(self, left: L, right: R) -> Self

where L: Into<Identifier>, R: Into<Box<dyn Expression>>,

impl<'a> From<SelectQuery<'a>> for Box<dyn List + 'a>

fn from(val: SelectQuery<'a>) -> Self

Converts to this type from the input type.

impl<'a> From<UpsertStatement<'a>> for SelectQuery<'a>

fn from(value: UpsertStatement<'a>) -> Self

Converts to this type from the input type.

impl List for SelectQuery<'_>