Struct sea_query::query::SelectStatement [−][src]
pub struct SelectStatement { /* fields omitted */ }
Expand description
Select rows from an existing table
Examples
use sea_query::{*, tests_cfg::*}; let query = Query::select() .column(Char::Character) .table_column(Font::Table, Font::Name) .from(Char::Table) .left_join(Font::Table, Expr::tbl(Char::Table, Char::FontId).equals(Font::Table, Font::Id)) .and_where(Expr::col(Char::SizeW).is_in(vec![3, 4])) .and_where(Expr::col(Char::Character).like("A%")) .to_owned(); assert_eq!( query.to_string(MysqlQueryBuilder), r#"SELECT `character`, `font`.`name` FROM `character` LEFT JOIN `font` ON `character`.`font_id` = `font`.`id` WHERE `size_w` IN (3, 4) AND `character` LIKE 'A%'"# ); assert_eq!( query.to_string(PostgresQueryBuilder), r#"SELECT "character", "font"."name" FROM "character" LEFT JOIN "font" ON "character"."font_id" = "font"."id" WHERE "size_w" IN (3, 4) AND "character" LIKE 'A%'"# ); assert_eq!( query.to_string(SqliteQueryBuilder), r#"SELECT `character`, `font`.`name` FROM `character` LEFT JOIN `font` ON `character`.`font_id` = `font`.`id` WHERE `size_w` IN (3, 4) AND `character` LIKE 'A%'"# );
Implementations
impl SelectStatement
[src]
impl SelectStatement
[src]pub fn new() -> Self
[src]
pub fn new() -> Self
[src]Construct a new SelectStatement
pub fn take(&mut self) -> Self
[src]
pub fn take(&mut self) -> Self
[src]Take the ownership of data in the current SelectStatement
pub fn conditions<T, F>(
&mut self,
b: bool,
if_true: T,
if_false: F
) -> &mut Self where
T: FnOnce(&mut Self),
F: FnOnce(&mut Self),
[src]
pub fn conditions<T, F>(
&mut self,
b: bool,
if_true: T,
if_false: F
) -> &mut Self where
T: FnOnce(&mut Self),
F: FnOnce(&mut Self),
[src]A shorthand to express if β¦ else β¦ when constructing the select statement.
Examples
use sea_query::{*, tests_cfg::*}; let query = Query::select() .column(Char::Character) .from(Char::Table) .conditions( true, |x| { x.and_where(Expr::col(Char::FontId).eq(5)); }, |x| { x.and_where(Expr::col(Char::FontId).eq(10)); } ) .to_owned(); assert_eq!( query.to_string(MysqlQueryBuilder), r#"SELECT `character` FROM `character` WHERE `font_id` = 5"# ); assert_eq!( query.to_string(PostgresQueryBuilder), r#"SELECT "character" FROM "character" WHERE "font_id" = 5"# ); assert_eq!( query.to_string(SqliteQueryBuilder), r#"SELECT `character` FROM `character` WHERE `font_id` = 5"# );
pub fn clear_selects(&mut self) -> &mut Self
[src]
pub fn clear_selects(&mut self) -> &mut Self
[src]Clear the select list
pub fn expr<T>(&mut self, expr: T) -> &mut Self where
T: Into<SelectExpr>,
[src]
pub fn expr<T>(&mut self, expr: T) -> &mut Self where
T: Into<SelectExpr>,
[src]Add an expression to the select expression list.
Examples
use sea_query::{*, tests_cfg::*}; let query = Query::select() .from(Char::Table) .expr(Expr::val(42)) .expr(Expr::col(Char::Id).max()) .expr((1..10_i32).fold(Expr::value(0), |expr, i| { expr.add(Expr::value(i)) })) .to_owned(); assert_eq!( query.to_string(MysqlQueryBuilder), r#"SELECT 42, MAX(`id`), 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 FROM `character`"# ); assert_eq!( query.to_string(PostgresQueryBuilder), r#"SELECT 42, MAX("id"), 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 FROM "character""# ); assert_eq!( query.to_string(SqliteQueryBuilder), r#"SELECT 42, MAX(`id`), 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 FROM `character`"# );
pub fn exprs<T, I>(&mut self, exprs: I) -> &mut Self where
T: Into<SelectExpr>,
I: IntoIterator<Item = T>,
[src]
pub fn exprs<T, I>(&mut self, exprs: I) -> &mut Self where
T: Into<SelectExpr>,
I: IntoIterator<Item = T>,
[src]Add select expressions from vector of SelectExpr
.
Examples
use sea_query::{*, tests_cfg::*}; let query = Query::select() .from(Char::Table) .exprs(vec![ Expr::col(Char::Id).max(), (1..10_i32).fold(Expr::value(0), |expr, i| { expr.add(Expr::value(i)) }), ]) .to_owned(); assert_eq!( query.to_string(MysqlQueryBuilder), r#"SELECT MAX(`id`), 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 FROM `character`"# ); assert_eq!( query.to_string(PostgresQueryBuilder), r#"SELECT MAX("id"), 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 FROM "character""# ); assert_eq!( query.to_string(SqliteQueryBuilder), r#"SELECT MAX(`id`), 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 FROM `character`"# );
pub fn exprs_mut_for_each<F>(&mut self, func: F) where
F: FnMut(&mut SelectExpr),
[src]
F: FnMut(&mut SelectExpr),
pub fn column<C>(&mut self, col: C) -> &mut Self where
C: IntoColumnRef,
[src]
pub fn column<C>(&mut self, col: C) -> &mut Self where
C: IntoColumnRef,
[src]Add a column to the select expression list.
Examples
use sea_query::{*, tests_cfg::*}; let query = Query::select() .from(Char::Table) .column(Char::Character) .column(Char::SizeW) .column(Char::SizeH) .to_owned(); assert_eq!( query.to_string(MysqlQueryBuilder), r#"SELECT `character`, `size_w`, `size_h` FROM `character`"# ); assert_eq!( query.to_string(PostgresQueryBuilder), r#"SELECT "character", "size_w", "size_h" FROM "character""# ); assert_eq!( query.to_string(SqliteQueryBuilder), r#"SELECT `character`, `size_w`, `size_h` FROM `character`"# );
use sea_query::{*, tests_cfg::*}; let query = Query::select() .from(Char::Table) .column((Char::Table, Char::Character)) .to_owned(); assert_eq!( query.to_string(MysqlQueryBuilder), r#"SELECT `character`.`character` FROM `character`"# ); assert_eq!( query.to_string(PostgresQueryBuilder), r#"SELECT "character"."character" FROM "character""# ); assert_eq!( query.to_string(SqliteQueryBuilder), r#"SELECT `character`.`character` FROM `character`"# );
pub fn table_column<T, C>(&mut self, t: T, c: C) -> &mut Self where
T: IntoIden,
C: IntoIden,
[src]
T: IntoIden,
C: IntoIden,
Please use the [SelectStatement::column
] with a tuple as [ColumnRef
]
pub fn columns<T, I>(&mut self, cols: I) -> &mut Self where
T: IntoColumnRef,
I: IntoIterator<Item = T>,
[src]
pub fn columns<T, I>(&mut self, cols: I) -> &mut Self where
T: IntoColumnRef,
I: IntoIterator<Item = T>,
[src]Select columns.
Examples
use sea_query::{*, tests_cfg::*}; let query = Query::select() .from(Char::Table) .columns(vec![ Char::Character, Char::SizeW, Char::SizeH, ]) .to_owned(); assert_eq!( query.to_string(MysqlQueryBuilder), r#"SELECT `character`, `size_w`, `size_h` FROM `character`"# ); assert_eq!( query.to_string(PostgresQueryBuilder), r#"SELECT "character", "size_w", "size_h" FROM "character""# ); assert_eq!( query.to_string(SqliteQueryBuilder), r#"SELECT `character`, `size_w`, `size_h` FROM `character`"# );
use sea_query::{*, tests_cfg::*}; let query = Query::select() .from(Char::Table) .columns(vec![ (Char::Table, Char::Character), (Char::Table, Char::SizeW), (Char::Table, Char::SizeH), ]) .to_owned(); assert_eq!( query.to_string(MysqlQueryBuilder), r#"SELECT `character`.`character`, `character`.`size_w`, `character`.`size_h` FROM `character`"# ); assert_eq!( query.to_string(PostgresQueryBuilder), r#"SELECT "character"."character", "character"."size_w", "character"."size_h" FROM "character""# ); assert_eq!( query.to_string(SqliteQueryBuilder), r#"SELECT `character`.`character`, `character`.`size_w`, `character`.`size_h` FROM `character`"# );
pub fn table_columns<T, C>(&mut self, cols: Vec<(T, C)>) -> &mut Self where
T: IntoIden,
C: IntoIden,
[src]
T: IntoIden,
C: IntoIden,
Please use the [SelectStatement::columns
] with a tuple as [ColumnRef
]
pub fn expr_as<T, A>(&mut self, expr: T, alias: A) -> &mut Self where
T: Into<SimpleExpr>,
A: IntoIden,
[src]
pub fn expr_as<T, A>(&mut self, expr: T, alias: A) -> &mut Self where
T: Into<SimpleExpr>,
A: IntoIden,
[src]Select column.
Examples
use sea_query::{*, tests_cfg::*}; let query = Query::select() .from(Char::Table) .expr_as(Expr::col(Char::Character), Alias::new("C")) .to_owned(); assert_eq!( query.to_string(MysqlQueryBuilder), r#"SELECT `character` AS `C` FROM `character`"# ); assert_eq!( query.to_string(PostgresQueryBuilder), r#"SELECT "character" AS "C" FROM "character""# ); assert_eq!( query.to_string(SqliteQueryBuilder), r#"SELECT `character` AS `C` FROM `character`"# );
pub fn expr_alias<T, A>(&mut self, expr: T, alias: A) -> &mut Self where
T: Into<SimpleExpr>,
A: IntoIden,
[src]
T: Into<SimpleExpr>,
A: IntoIden,
Please use the [SelectStatement::expr_as
] instead
pub fn from<R>(&mut self, tbl_ref: R) -> &mut Self where
R: IntoTableRef,
[src]
pub fn from<R>(&mut self, tbl_ref: R) -> &mut Self where
R: IntoTableRef,
[src]From table.
Examples
use sea_query::{*, tests_cfg::*}; let query = Query::select() .column(Char::FontSize) .from(Char::Table) .to_owned(); assert_eq!( query.to_string(MysqlQueryBuilder), r#"SELECT `font_size` FROM `character`"# ); assert_eq!( query.to_string(PostgresQueryBuilder), r#"SELECT "font_size" FROM "character""# ); assert_eq!( query.to_string(SqliteQueryBuilder), r#"SELECT `font_size` FROM `character`"# );
use sea_query::{*, tests_cfg::*}; let query = Query::select() .column(Char::FontSize) .from((Char::Table, Glyph::Table)) .to_owned(); assert_eq!( query.to_string(MysqlQueryBuilder), r#"SELECT `font_size` FROM `character`.`glyph`"# ); assert_eq!( query.to_string(PostgresQueryBuilder), r#"SELECT "font_size" FROM "character"."glyph""# ); assert_eq!( query.to_string(SqliteQueryBuilder), r#"SELECT `font_size` FROM `character`.`glyph`"# );
pub fn from_schema<S: 'static, T: 'static>(
&mut self,
schema: S,
table: T
) -> &mut Self where
S: IntoIden,
T: IntoIden,
[src]
π Deprecated since 0.9.0: Please use the [SelectStatement::from
] with a tuple as [TableRef
]
pub fn from_schema<S: 'static, T: 'static>(
&mut self,
schema: S,
table: T
) -> &mut Self where
S: IntoIden,
T: IntoIden,
[src]Please use the [SelectStatement::from
] with a tuple as [TableRef
]
From schema.table.
Examples
use sea_query::{*, tests_cfg::*}; let query = Query::select() .column(Char::FontSize) .from_schema(Char::Table, Glyph::Table) .to_owned(); assert_eq!( query.to_string(MysqlQueryBuilder), r#"SELECT `font_size` FROM `character`.`glyph`"# ); assert_eq!( query.to_string(PostgresQueryBuilder), r#"SELECT "font_size" FROM "character"."glyph""# ); assert_eq!( query.to_string(SqliteQueryBuilder), r#"SELECT `font_size` FROM `character`.`glyph`"# );
pub fn from_as<R, A>(&mut self, tbl_ref: R, alias: A) -> &mut Self where
R: IntoTableRef,
A: IntoIden,
[src]
pub fn from_as<R, A>(&mut self, tbl_ref: R, alias: A) -> &mut Self where
R: IntoTableRef,
A: IntoIden,
[src]From table with alias.
Examples
use std::rc::Rc; use sea_query::{*, tests_cfg::*}; let table_as: Rc<dyn Iden> = Rc::new(Alias::new("char")); let query = Query::select() .from_as(Char::Table, table_as.clone()) .table_column(table_as.clone(), Char::Character) .to_owned(); assert_eq!( query.to_string(MysqlQueryBuilder), r#"SELECT `char`.`character` FROM `character` AS `char`"# ); assert_eq!( query.to_string(PostgresQueryBuilder), r#"SELECT "char"."character" FROM "character" AS "char""# ); assert_eq!( query.to_string(SqliteQueryBuilder), r#"SELECT `char`.`character` FROM `character` AS `char`"# );
use sea_query::{*, tests_cfg::*}; let table_as = Alias::new("alias"); let query = Query::select() .from_as((Font::Table, Char::Table), table_as.clone()) .table_column(table_as, Char::Character) .to_owned(); assert_eq!( query.to_string(MysqlQueryBuilder), r#"SELECT `alias`.`character` FROM `font`.`character` AS `alias`"# ); assert_eq!( query.to_string(PostgresQueryBuilder), r#"SELECT "alias"."character" FROM "font"."character" AS "alias""# ); assert_eq!( query.to_string(SqliteQueryBuilder), r#"SELECT `alias`.`character` FROM `font`.`character` AS `alias`"# );
pub fn from_alias<R, A>(&mut self, tbl_ref: R, alias: A) -> &mut Self where
R: IntoTableRef,
A: IntoIden,
[src]
R: IntoTableRef,
A: IntoIden,
Please use the [SelectStatement::from_as
] instead
pub fn from_schema_as<S: 'static, T: 'static, A>(
&mut self,
schema: S,
table: T,
alias: A
) -> &mut Self where
S: IntoIden,
T: IntoIden,
A: IntoIden,
[src]
&mut self,
schema: S,
table: T,
alias: A
) -> &mut Self where
S: IntoIden,
T: IntoIden,
A: IntoIden,
Please use the [SelectStatement::from_as
] with a tuple as [TableRef
]
pub fn from_subquery<T>(
&mut self,
query: SelectStatement,
alias: T
) -> &mut Self where
T: IntoIden,
[src]
pub fn from_subquery<T>(
&mut self,
query: SelectStatement,
alias: T
) -> &mut Self where
T: IntoIden,
[src]From sub-query.
Examples
use sea_query::{*, tests_cfg::*}; let query = Query::select() .columns(vec![ Glyph::Image ]) .from_subquery( Query::select() .columns(vec![ Glyph::Image, Glyph::Aspect ]) .from(Glyph::Table) .take(), Alias::new("subglyph") ) .to_owned(); assert_eq!( query.to_string(MysqlQueryBuilder), r#"SELECT `image` FROM (SELECT `image`, `aspect` FROM `glyph`) AS `subglyph`"# ); assert_eq!( query.to_string(PostgresQueryBuilder), r#"SELECT "image" FROM (SELECT "image", "aspect" FROM "glyph") AS "subglyph""# ); assert_eq!( query.to_string(SqliteQueryBuilder), r#"SELECT `image` FROM (SELECT `image`, `aspect` FROM `glyph`) AS `subglyph`"# );
pub fn left_join<R>(&mut self, tbl_ref: R, condition: SimpleExpr) -> &mut Self where
R: IntoTableRef,
[src]
pub fn left_join<R>(&mut self, tbl_ref: R, condition: SimpleExpr) -> &mut Self where
R: IntoTableRef,
[src]Left join.
Examples
use sea_query::{*, tests_cfg::*}; let query = Query::select() .column(Char::Character) .table_column(Font::Table, Font::Name) .from(Char::Table) .left_join(Font::Table, Expr::tbl(Char::Table, Char::FontId).equals(Font::Table, Font::Id)) .to_owned(); assert_eq!( query.to_string(MysqlQueryBuilder), r#"SELECT `character`, `font`.`name` FROM `character` LEFT JOIN `font` ON `character`.`font_id` = `font`.`id`"# ); assert_eq!( query.to_string(PostgresQueryBuilder), r#"SELECT "character", "font"."name" FROM "character" LEFT JOIN "font" ON "character"."font_id" = "font"."id""# ); assert_eq!( query.to_string(SqliteQueryBuilder), r#"SELECT `character`, `font`.`name` FROM `character` LEFT JOIN `font` ON `character`.`font_id` = `font`.`id`"# );
pub fn inner_join<R>(&mut self, tbl_ref: R, condition: SimpleExpr) -> &mut Self where
R: IntoTableRef,
[src]
pub fn inner_join<R>(&mut self, tbl_ref: R, condition: SimpleExpr) -> &mut Self where
R: IntoTableRef,
[src]Inner join.
Examples
use sea_query::{*, tests_cfg::*}; let query = Query::select() .column(Char::Character) .table_column(Font::Table, Font::Name) .from(Char::Table) .inner_join(Font::Table, Expr::tbl(Char::Table, Char::FontId).equals(Font::Table, Font::Id)) .to_owned(); assert_eq!( query.to_string(MysqlQueryBuilder), r#"SELECT `character`, `font`.`name` FROM `character` INNER JOIN `font` ON `character`.`font_id` = `font`.`id`"# ); assert_eq!( query.to_string(PostgresQueryBuilder), r#"SELECT "character", "font"."name" FROM "character" INNER JOIN "font" ON "character"."font_id" = "font"."id""# ); assert_eq!( query.to_string(SqliteQueryBuilder), r#"SELECT `character`, `font`.`name` FROM `character` INNER JOIN `font` ON `character`.`font_id` = `font`.`id`"# );
pub fn join<R>(
&mut self,
join: JoinType,
tbl_ref: R,
condition: SimpleExpr
) -> &mut Self where
R: IntoTableRef,
[src]
pub fn join<R>(
&mut self,
join: JoinType,
tbl_ref: R,
condition: SimpleExpr
) -> &mut Self where
R: IntoTableRef,
[src]Join with other table by JoinType
.
Examples
use sea_query::{*, tests_cfg::*}; let query = Query::select() .column(Char::Character) .table_column(Font::Table, Font::Name) .from(Char::Table) .join(JoinType::RightJoin, Font::Table, Expr::tbl(Char::Table, Char::FontId).equals(Font::Table, Font::Id)) .to_owned(); assert_eq!( query.to_string(MysqlQueryBuilder), r#"SELECT `character`, `font`.`name` FROM `character` RIGHT JOIN `font` ON `character`.`font_id` = `font`.`id`"# ); assert_eq!( query.to_string(PostgresQueryBuilder), r#"SELECT "character", "font"."name" FROM "character" RIGHT JOIN "font" ON "character"."font_id" = "font"."id""# ); assert_eq!( query.to_string(SqliteQueryBuilder), r#"SELECT `character`, `font`.`name` FROM `character` RIGHT JOIN `font` ON `character`.`font_id` = `font`.`id`"# );
pub fn join_as<R, A>(
&mut self,
join: JoinType,
tbl_ref: R,
alias: A,
condition: SimpleExpr
) -> &mut Self where
R: IntoTableRef,
A: IntoIden,
[src]
pub fn join_as<R, A>(
&mut self,
join: JoinType,
tbl_ref: R,
alias: A,
condition: SimpleExpr
) -> &mut Self where
R: IntoTableRef,
A: IntoIden,
[src]Join with other table by JoinType
, assigning an alias to the joined table.
Examples
use sea_query::{*, tests_cfg::*}; let query = Query::select() .column(Char::Character) .table_column(Font::Table, Font::Name) .from(Char::Table) .join_as( JoinType::RightJoin, Font::Table, Alias::new("f"), Expr::tbl(Char::Table, Char::FontId).equals(Font::Table, Font::Id) ) .to_owned(); assert_eq!( query.to_string(MysqlQueryBuilder), r#"SELECT `character`, `font`.`name` FROM `character` RIGHT JOIN `font` AS `f` ON `character`.`font_id` = `font`.`id`"# ); assert_eq!( query.to_string(PostgresQueryBuilder), r#"SELECT "character", "font"."name" FROM "character" RIGHT JOIN "font" AS "f" ON "character"."font_id" = "font"."id""# ); assert_eq!( query.to_string(SqliteQueryBuilder), r#"SELECT `character`, `font`.`name` FROM `character` RIGHT JOIN `font` AS `f` ON `character`.`font_id` = `font`.`id`"# );
pub fn join_alias<R, A>(
&mut self,
join: JoinType,
tbl_ref: R,
alias: A,
condition: SimpleExpr
) -> &mut Self where
R: IntoTableRef,
A: IntoIden,
[src]
&mut self,
join: JoinType,
tbl_ref: R,
alias: A,
condition: SimpleExpr
) -> &mut Self where
R: IntoTableRef,
A: IntoIden,
Please use the [SelectStatement::join_as
] instead
pub fn join_subquery<T>(
&mut self,
join: JoinType,
query: SelectStatement,
alias: T,
condition: SimpleExpr
) -> &mut Self where
T: IntoIden,
[src]
pub fn join_subquery<T>(
&mut self,
join: JoinType,
query: SelectStatement,
alias: T,
condition: SimpleExpr
) -> &mut Self where
T: IntoIden,
[src]Join with sub-query.
Examples
use std::rc::Rc; use sea_query::{*, tests_cfg::*}; let sub_glyph: Rc<dyn Iden> = Rc::new(Alias::new("sub_glyph")); let query = Query::select() .column(Font::Name) .from(Font::Table) .join_subquery( JoinType::LeftJoin, Query::select() .column(Glyph::Id) .from(Glyph::Table) .take(), sub_glyph.clone(), Expr::tbl(Font::Table, Font::Id).equals(sub_glyph.clone(), Glyph::Id) ) .to_owned(); assert_eq!( query.to_string(MysqlQueryBuilder), r#"SELECT `name` FROM `font` LEFT JOIN (SELECT `id` FROM `glyph`) AS `sub_glyph` ON `font`.`id` = `sub_glyph`.`id`"# ); assert_eq!( query.to_string(PostgresQueryBuilder), r#"SELECT "name" FROM "font" LEFT JOIN (SELECT "id" FROM "glyph") AS "sub_glyph" ON "font"."id" = "sub_glyph"."id""# ); assert_eq!( query.to_string(SqliteQueryBuilder), r#"SELECT `name` FROM `font` LEFT JOIN (SELECT `id` FROM `glyph`) AS `sub_glyph` ON `font`.`id` = `sub_glyph`.`id`"# );
pub fn group_by_columns<T, I>(&mut self, cols: I) -> &mut Self where
T: IntoColumnRef,
I: IntoIterator<Item = T>,
[src]
pub fn group_by_columns<T, I>(&mut self, cols: I) -> &mut Self where
T: IntoColumnRef,
I: IntoIterator<Item = T>,
[src]Group by columns.
Examples
use sea_query::{*, tests_cfg::*}; let query = Query::select() .column(Char::Character) .table_column(Font::Table, Font::Name) .from(Char::Table) .join(JoinType::RightJoin, Font::Table, Expr::tbl(Char::Table, Char::FontId).equals(Font::Table, Font::Id)) .group_by_columns(vec![ Char::Character, ]) .to_owned(); assert_eq!( query.to_string(MysqlQueryBuilder), r#"SELECT `character`, `font`.`name` FROM `character` RIGHT JOIN `font` ON `character`.`font_id` = `font`.`id` GROUP BY `character`"# ); assert_eq!( query.to_string(PostgresQueryBuilder), r#"SELECT "character", "font"."name" FROM "character" RIGHT JOIN "font" ON "character"."font_id" = "font"."id" GROUP BY "character""# ); assert_eq!( query.to_string(SqliteQueryBuilder), r#"SELECT `character`, `font`.`name` FROM `character` RIGHT JOIN `font` ON `character`.`font_id` = `font`.`id` GROUP BY `character`"# );
use sea_query::{*, tests_cfg::*}; let query = Query::select() .column(Char::Character) .table_column(Font::Table, Font::Name) .from(Char::Table) .join(JoinType::RightJoin, Font::Table, Expr::tbl(Char::Table, Char::FontId).equals(Font::Table, Font::Id)) .group_by_columns(vec![ (Char::Table, Char::Character), ]) .to_owned(); assert_eq!( query.to_string(MysqlQueryBuilder), r#"SELECT `character`, `font`.`name` FROM `character` RIGHT JOIN `font` ON `character`.`font_id` = `font`.`id` GROUP BY `character`.`character`"# ); assert_eq!( query.to_string(PostgresQueryBuilder), r#"SELECT "character", "font"."name" FROM "character" RIGHT JOIN "font" ON "character"."font_id" = "font"."id" GROUP BY "character"."character""# ); assert_eq!( query.to_string(SqliteQueryBuilder), r#"SELECT `character`, `font`.`name` FROM `character` RIGHT JOIN `font` ON `character`.`font_id` = `font`.`id` GROUP BY `character`.`character`"# );
pub fn group_by_col<T>(&mut self, col: T) -> &mut Self where
T: IntoColumnRef,
[src]
pub fn group_by_col<T>(&mut self, col: T) -> &mut Self where
T: IntoColumnRef,
[src]Add a group by column.
use sea_query::{*, tests_cfg::*}; let query = Query::select() .column(Char::Character) .table_column(Font::Table, Font::Name) .from(Char::Table) .join(JoinType::RightJoin, Font::Table, Expr::tbl(Char::Table, Char::FontId).equals(Font::Table, Font::Id)) .group_by_col((Char::Table, Char::Character)) .to_owned(); assert_eq!( query.to_string(MysqlQueryBuilder), r#"SELECT `character`, `font`.`name` FROM `character` RIGHT JOIN `font` ON `character`.`font_id` = `font`.`id` GROUP BY `character`.`character`"# ); assert_eq!( query.to_string(PostgresQueryBuilder), r#"SELECT "character", "font"."name" FROM "character" RIGHT JOIN "font" ON "character"."font_id" = "font"."id" GROUP BY "character"."character""# ); assert_eq!( query.to_string(SqliteQueryBuilder), r#"SELECT `character`, `font`.`name` FROM `character` RIGHT JOIN `font` ON `character`.`font_id` = `font`.`id` GROUP BY `character`.`character`"# );
pub fn group_by_table_columns<T, C>(&mut self, cols: Vec<(T, C)>) -> &mut Self where
T: IntoIden,
C: IntoIden,
[src]
T: IntoIden,
C: IntoIden,
Please use the [SelectStatement::group_by_columns
] with a tuple as [ColumnRef
]
pub fn add_group_by<I>(&mut self, expr: I) -> &mut Self where
I: IntoIterator<Item = SimpleExpr>,
[src]
pub fn add_group_by<I>(&mut self, expr: I) -> &mut Self where
I: IntoIterator<Item = SimpleExpr>,
[src]Add group by expressions from vector of SelectExpr
.
Examples
use sea_query::{*, tests_cfg::*}; let query = Query::select() .from(Char::Table) .column(Char::Character) .add_group_by(vec![ Expr::col(Char::SizeW).into(), Expr::col(Char::SizeH).into(), ]) .to_owned(); assert_eq!( query.to_string(MysqlQueryBuilder), r#"SELECT `character` FROM `character` GROUP BY `size_w`, `size_h`"# ); assert_eq!( query.to_string(PostgresQueryBuilder), r#"SELECT "character" FROM "character" GROUP BY "size_w", "size_h""# ); assert_eq!( query.to_string(SqliteQueryBuilder), r#"SELECT `character` FROM `character` GROUP BY `size_w`, `size_h`"# );
pub fn cond_having(&mut self, condition: Condition) -> &mut Self
[src]
pub fn cond_having(&mut self, condition: Condition) -> &mut Self
[src]Having condition, expressed with any!
and all!
.
Examples
use sea_query::{*, tests_cfg::*}; let query = Query::select() .column(Glyph::Aspect) .expr(Expr::col(Glyph::Image).max()) .from(Glyph::Table) .group_by_columns(vec![ Glyph::Aspect, ]) .cond_having( all![ Expr::tbl(Glyph::Table, Glyph::Aspect).is_in(vec![3, 4]), any![ Expr::tbl(Glyph::Table, Glyph::Image).like("A%"), Expr::tbl(Glyph::Table, Glyph::Image).like("B%")]]) .to_owned(); assert_eq!( query.to_string(MysqlQueryBuilder), r#"SELECT `aspect`, MAX(`image`) FROM `glyph` GROUP BY `aspect` HAVING `glyph`.`aspect` IN (3, 4) AND (`glyph`.`image` LIKE 'A%' OR `glyph`.`image` LIKE 'B%')"# );
pub fn and_having(&mut self, other: SimpleExpr) -> &mut Self
[src]
pub fn and_having(&mut self, other: SimpleExpr) -> &mut Self
[src]And having condition.
Examples
use sea_query::{*, tests_cfg::*}; let query = Query::select() .column(Glyph::Aspect) .expr(Expr::col(Glyph::Image).max()) .from(Glyph::Table) .group_by_columns(vec![ Glyph::Aspect, ]) .and_having(Expr::col(Glyph::Aspect).gt(2)) .and_having(Expr::col(Glyph::Aspect).lt(8)) .to_owned(); assert_eq!( query.to_string(MysqlQueryBuilder), r#"SELECT `aspect`, MAX(`image`) FROM `glyph` GROUP BY `aspect` HAVING `aspect` > 2 AND `aspect` < 8"# ); assert_eq!( query.to_string(PostgresQueryBuilder), r#"SELECT "aspect", MAX("image") FROM "glyph" GROUP BY "aspect" HAVING "aspect" > 2 AND "aspect" < 8"# ); assert_eq!( query.to_string(SqliteQueryBuilder), r#"SELECT `aspect`, MAX(`image`) FROM `glyph` GROUP BY `aspect` HAVING `aspect` > 2 AND `aspect` < 8"# );
pub fn or_having(&mut self, other: SimpleExpr) -> &mut Self
[src]
Please use [SelectStatement::cond_having
] or only [SelectStatement::and_having
]. The evaluation of mixed and_having
and or_having
can be surprising.
pub fn limit(&mut self, limit: u64) -> &mut Self
[src]
pub fn limit(&mut self, limit: u64) -> &mut Self
[src]Limit the number of returned rows.
Examples
use sea_query::{*, tests_cfg::*}; let query = Query::select() .column(Glyph::Aspect) .from(Glyph::Table) .limit(10) .to_owned(); assert_eq!( query.to_string(MysqlQueryBuilder), r#"SELECT `aspect` FROM `glyph` LIMIT 10"# ); assert_eq!( query.to_string(PostgresQueryBuilder), r#"SELECT "aspect" FROM "glyph" LIMIT 10"# ); assert_eq!( query.to_string(SqliteQueryBuilder), r#"SELECT `aspect` FROM `glyph` LIMIT 10"# );
pub fn offset(&mut self, offset: u64) -> &mut Self
[src]
pub fn offset(&mut self, offset: u64) -> &mut Self
[src]Offset number of returned rows.
Examples
use sea_query::{*, tests_cfg::*}; let query = Query::select() .column(Glyph::Aspect) .from(Glyph::Table) .limit(10) .offset(10) .to_owned(); assert_eq!( query.to_string(MysqlQueryBuilder), r#"SELECT `aspect` FROM `glyph` LIMIT 10 OFFSET 10"# ); assert_eq!( query.to_string(PostgresQueryBuilder), r#"SELECT "aspect" FROM "glyph" LIMIT 10 OFFSET 10"# ); assert_eq!( query.to_string(SqliteQueryBuilder), r#"SELECT `aspect` FROM `glyph` LIMIT 10 OFFSET 10"# );
impl SelectStatement
[src]
impl SelectStatement
[src]impl SelectStatement
[src]
impl SelectStatement
[src]pub fn order_by<T>(&mut self, col: T, order: Order) -> &mut Self where
T: IntoColumnRef,
[src]
T: IntoColumnRef,
pub fn order_by_tbl<T, C>(
&mut self,
table: T,
col: C,
order: Order
) -> &mut Self where
T: IntoIden,
C: IntoIden,
[src]
&mut self,
table: T,
col: C,
order: Order
) -> &mut Self where
T: IntoIden,
C: IntoIden,
Please use the [OrderedStatement::order_by
] with a tuple as [ColumnRef
]
pub fn order_by_expr(&mut self, expr: SimpleExpr, order: Order) -> &mut Self
[src]
pub fn order_by_customs<T>(&mut self, cols: Vec<(T, Order)>) -> &mut Self where
T: ToString,
[src]
T: ToString,
pub fn order_by_columns<T>(&mut self, cols: Vec<(T, Order)>) -> &mut Self where
T: IntoColumnRef,
[src]
T: IntoColumnRef,
pub fn order_by_table_columns<T, C>(
&mut self,
cols: Vec<(T, C, Order)>
) -> &mut Self where
T: IntoIden,
C: IntoIden,
[src]
&mut self,
cols: Vec<(T, C, Order)>
) -> &mut Self where
T: IntoIden,
C: IntoIden,
Please use the [OrderedStatement::order_by_columns
] with a tuple as [ColumnRef
]
impl SelectStatement
[src]
impl SelectStatement
[src]pub fn and_where(&mut self, other: SimpleExpr) -> &mut Self
[src]
pub fn and_where_option(&mut self, other: Option<SimpleExpr>) -> &mut Self
[src]
pub fn or_where(&mut self, other: SimpleExpr) -> &mut Self
[src]
Please use [ConditionalStatement::cond_where
]. Calling or_where
after and_where
will panic.
pub fn cond_where<C>(&mut self, condition: C) -> &mut Self where
C: IntoCondition,
[src]
C: IntoCondition,
Trait Implementations
impl Clone for SelectStatement
[src]
impl Clone for SelectStatement
[src]fn clone(&self) -> SelectStatement
[src]
fn clone(&self) -> SelectStatement
[src]Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0[src]
fn clone_from(&mut self, source: &Self)
1.0.0[src]Performs copy-assignment from source
. Read more
impl ConditionalStatement for SelectStatement
[src]
impl ConditionalStatement for SelectStatement
[src]fn and_or_where(&mut self, condition: LogicalChainOper) -> &mut Self
[src]
fn cond_where<C>(&mut self, condition: C) -> &mut Self where
C: IntoCondition,
[src]
fn cond_where<C>(&mut self, condition: C) -> &mut Self where
C: IntoCondition,
[src]Where condition, expressed with any
and all
.
This cannot be mixed with ConditionalStatement::and_where
.
Calling cond_where
after and_where
will panic.
Calling cond_where
multiple times will conjoin them. Read more
fn and_where(&mut self, other: SimpleExpr) -> &mut Self
[src]
fn and_where(&mut self, other: SimpleExpr) -> &mut Self
[src]And where condition. This cannot be mixed with ConditionalStatement::or_where
.
Calling or_where
after and_where
will panic. Read more
fn and_where_option(&mut self, other: Option<SimpleExpr>) -> &mut Self
[src]
fn and_where_option(&mut self, other: Option<SimpleExpr>) -> &mut Self
[src]And where condition, short hand for if c.is_some() q.and_where(c)
.
fn or_where(&mut self, other: SimpleExpr) -> &mut Self
[src]
fn or_where(&mut self, other: SimpleExpr) -> &mut Self
[src]Please use [ConditionalStatement::cond_where
]. Calling or_where
after and_where
will panic.
impl Debug for SelectStatement
[src]
impl Debug for SelectStatement
[src]impl Default for SelectStatement
[src]
impl Default for SelectStatement
[src]impl OrderedStatement for SelectStatement
[src]
impl OrderedStatement for SelectStatement
[src]fn add_order_by(&mut self, order: OrderExpr) -> &mut Self
[src]
fn order_by<T>(&mut self, col: T, order: Order) -> &mut Self where
T: IntoColumnRef,
[src]
fn order_by<T>(&mut self, col: T, order: Order) -> &mut Self where
T: IntoColumnRef,
[src]Order by column. Read more
fn order_by_tbl<T, C>(&mut self, table: T, col: C, order: Order) -> &mut Self where
T: IntoIden,
C: IntoIden,
[src]
fn order_by_tbl<T, C>(&mut self, table: T, col: C, order: Order) -> &mut Self where
T: IntoIden,
C: IntoIden,
[src]Please use the [OrderedStatement::order_by
] with a tuple as [ColumnRef
]
fn order_by_expr(&mut self, expr: SimpleExpr, order: Order) -> &mut Self
[src]
fn order_by_expr(&mut self, expr: SimpleExpr, order: Order) -> &mut Self
[src]Order by SimpleExpr
.
fn order_by_customs<T>(&mut self, cols: Vec<(T, Order)>) -> &mut Self where
T: ToString,
[src]
fn order_by_customs<T>(&mut self, cols: Vec<(T, Order)>) -> &mut Self where
T: ToString,
[src]Order by custom string.
fn order_by_columns<T>(&mut self, cols: Vec<(T, Order)>) -> &mut Self where
T: IntoColumnRef,
[src]
fn order_by_columns<T>(&mut self, cols: Vec<(T, Order)>) -> &mut Self where
T: IntoColumnRef,
[src]Order by vector of columns.
impl QueryStatementBuilder for SelectStatement
[src]
impl QueryStatementBuilder for SelectStatement
[src]fn build_collect<T: QueryBuilder>(
&self,
query_builder: T,
collector: &mut dyn FnMut(Value)
) -> String
[src]
fn build_collect<T: QueryBuilder>(
&self,
query_builder: T,
collector: &mut dyn FnMut(Value)
) -> String
[src]Build corresponding SQL statement for certain database backend and collect query parameters
Examples
use sea_query::{*, tests_cfg::*}; let query = Query::select() .column(Glyph::Aspect) .from(Glyph::Table) .and_where(Expr::expr(Expr::col(Glyph::Aspect).if_null(0)).gt(2)) .order_by(Glyph::Image, Order::Desc) .order_by_tbl(Glyph::Table, Glyph::Aspect, Order::Asc) .to_owned(); assert_eq!( query.to_string(MysqlQueryBuilder), r#"SELECT `aspect` FROM `glyph` WHERE IFNULL(`aspect`, 0) > 2 ORDER BY `image` DESC, `glyph`.`aspect` ASC"# ); let mut params = Vec::new(); let mut collector = |v| params.push(v); assert_eq!( query.build_collect(MysqlQueryBuilder, &mut collector), r#"SELECT `aspect` FROM `glyph` WHERE IFNULL(`aspect`, ?) > ? ORDER BY `image` DESC, `glyph`.`aspect` ASC"# ); assert_eq!( params, vec![Value::Int(0), Value::Int(2)] );
fn build_collect_any(
&self,
query_builder: &dyn QueryBuilder,
collector: &mut dyn FnMut(Value)
) -> String
[src]
fn build_collect_any(
&self,
query_builder: &dyn QueryBuilder,
collector: &mut dyn FnMut(Value)
) -> String
[src]Build corresponding SQL statement for certain database backend and collect query parameters
fn to_string<T: QueryBuilder>(&self, query_builder: T) -> String
[src]
fn to_string<T: QueryBuilder>(&self, query_builder: T) -> String
[src]Build corresponding SQL statement for certain database backend and return SQL string Read more
Auto Trait Implementations
impl !RefUnwindSafe for SelectStatement
impl !Send for SelectStatement
impl !Sync for SelectStatement
impl Unpin for SelectStatement
impl !UnwindSafe for SelectStatement
Blanket Implementations
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]pub fn borrow_mut(&mut self) -> &mut T
[src]
pub fn borrow_mut(&mut self) -> &mut T
[src]Mutably borrows from an owned value. Read more
impl<T> Same<T> for T
impl<T> Same<T> for T
type Output = T
type Output = T
Should always be Self
impl<T> ToOwned for T where
T: Clone,
[src]
impl<T> ToOwned for T where
T: Clone,
[src]type Owned = T
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn to_owned(&self) -> T
[src]Creates owned data from borrowed data, usually by cloning. Read more
pub fn clone_into(&self, target: &mut T)
[src]
pub fn clone_into(&self, target: &mut T)
[src]π¬ This is a nightly-only experimental API. (toowned_clone_into
)
recently added
Uses borrowed data to replace owned data, usually by cloning. Read more
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
impl<V, T> VZip<V> for T where
V: MultiLane<T>,