Struct arel::manager::select_manager::SelectManager

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

Implementations

impl<M: Arel> SelectManager<M>

pub fn select<T: AsRef<str>>(&mut self, columns: Vec<T>) -> &mut Self

Examples

use arel::prelude::*;
use arel::manager::SelectManager;
#[arel]
struct User {}
impl Arel for User {}
let mut select_manager = SelectManager::<User>::default();
assert_eq!(select_manager.to_sql().unwrap().to_sql_string().unwrap(), r#"SELECT "user".* FROM "user""#);

select_manager.select(vec!["id", "name"]);
assert_eq!(select_manager.to_sql().unwrap().to_sql_string().unwrap(), r#"SELECT "user"."id", "user"."name" FROM "user""#);

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

Examples

use arel::prelude::*;
use arel::manager::SelectManager;
#[arel]
struct User {}
impl Arel for User {}
let mut select_manager = SelectManager::<User>::default();
select_manager.select_sql("COUNT(*)");
assert_eq!(select_manager.to_sql().unwrap().to_sql_string().unwrap(), r#"SELECT COUNT(*) FROM "user""#);

pub fn distinct(&mut self) -> &mut Self

Examples

use arel::prelude::*;
use arel::manager::SelectManager;
#[arel]
struct User {}
impl Arel for User {}
let mut select_manager = SelectManager::<User>::default();
select_manager.distinct();
assert_eq!(select_manager.to_sql().unwrap().to_sql_string().unwrap(), r#"SELECT DISTINCT "user".* FROM "user""#);

pub fn join<U: Arel>(&mut self, join_type: JoinConst) -> &mut Self

Examples

use arel::prelude::*;
use arel::manager::SelectManager;
#[arel]
struct User {}
impl Arel for User {}
#[arel]
struct Wallet {}
impl Arel for Wallet {}
let mut select_manager = SelectManager::<User>::default();
select_manager.join::<Wallet>(arel::JoinConst::InnerJoin);
assert_eq!(select_manager.to_sql().unwrap().to_sql_string().unwrap(), r#"SELECT "user".* FROM "user" INNER JOIN "wallet" ON "user"."id" = "wallet"."user_id""#);

pub fn inner_join<U: Arel>(&mut self) -> &mut Self

pub fn left_join<U: Arel>(&mut self) -> &mut Self

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

Examples

use arel::prelude::*;
use arel::manager::SelectManager;
#[arel]
struct User {}
impl Arel for User {}
let mut select_manager = SelectManager::<User>::default();
select_manager.join_sql("LEFT JOIN wallet on user.id = wallet.user_id");
assert_eq!(select_manager.to_sql().unwrap().to_sql_string().unwrap(), r#"SELECT "user".* FROM "user" LEFT JOIN wallet on user.id = wallet.user_id"#);

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

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

pub fn where_range<K: AsRef<str>, V: ToString, R: RangeBounds<V>>( &mut self, key: K, range: R ) -> &mut Self

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

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

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

pub fn group<T: AsRef<str>>(&mut self, columns: Vec<T>) -> &mut Self

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

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

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

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

pub fn order<T: AsRef<str>>( &mut self, column: T, sort_type: SortConst ) -> &mut Self

pub fn order_asc<T: AsRef<str>>(&mut self, column: T) -> &mut Self

pub fn order_desc<T: AsRef<str>>(&mut self, column: T) -> &mut Self

pub fn limit(&mut self, num: usize) -> &mut Self

pub fn offset(&mut self, num: usize) -> &mut Self

pub fn paginate(&mut self, page: usize, page_size: usize) -> &mut Self

pub fn lock(&mut self) -> &mut Self

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

impl<M> SelectManager<M>

where for<'b> M: Send + Unpin + FromRow<'b, DatabaseRow> + Arel,

pub fn to_query_builder<'a>(&self) -> Result<QueryBuilder<'a>>

pub async fn fetch_count_with_exec<'a, E>(&self, executor: E) -> Result<i64>

where E: Executor<'a, Database = Database>,

pub async fn fetch_count(&self) -> Result<i64>

pub async fn fetch_one_as<T>(&self) -> Result<T>

where for<'b> T: Send + Unpin + FromRow<'b, DatabaseRow>,

pub async fn fetch_one_optional_as<T>(&self) -> Result<Option<T>>

where for<'b> T: Send + Unpin + FromRow<'b, DatabaseRow>,

pub async fn fetch_one(&self) -> Result<M>

pub async fn fetch_one_optional(&self) -> Result<Option<M>>

pub async fn fetch_all_as<T>(&self) -> Result<Vec<T>>

where for<'b> T: Send + Unpin + FromRow<'b, DatabaseRow>,

pub async fn fetch_all(&self) -> Result<Vec<M>>

Trait Implementations

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

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

Formats the value using the given formatter.

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

fn default() -> Self

Returns the “default value” for a type.