Struct sea_query::query::SelectStatement [−][src]
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]
pub fn new() -> Self
[src]
Construct a new SelectStatement
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]
&mut self,
b: bool,
if_true: T,
if_false: F
) -> &mut Self where
T: FnOnce(&mut Self),
F: FnOnce(&mut Self),
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 expr<T: 'static>(&mut self, expr: T) -> &mut Self where
T: Into<SelectExpr>,
[src]
T: Into<SelectExpr>,
Add a new select expression from SelectExpr
.
Examples
use sea_query::{*, tests_cfg::*}; let query = Query::select() .from(Char::Table) .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 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<T: 'static>(&mut self, exprs: Vec<T>) -> &mut Self where
T: Into<SelectExpr>,
[src]
T: Into<SelectExpr>,
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 distinct(&mut self) -> &mut Self
[src]
Select distinct
pub fn column<C: 'static>(&mut self, col: C) -> &mut Self where
C: Iden,
[src]
C: Iden,
Select column.
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`"# );
pub fn column_dyn(&mut self, col: Rc<dyn Iden>) -> &mut Self
[src]
Select column, variation of SelectStatement::column
.
Examples
use sea_query::{*, tests_cfg::*}; use std::rc::Rc; let query = Query::select() .from(Char::Table) .column_dyn(Rc::new(Char::Character)) .column_dyn(Rc::new(Char::SizeW)) .column_dyn(Rc::new(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`"# );
pub fn columns<T: 'static>(&mut self, cols: Vec<T>) -> &mut Self where
T: Iden,
[src]
T: Iden,
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`"# );
pub fn columns_dyn(&mut self, cols: Vec<Rc<dyn Iden>>) -> &mut Self
[src]
Select column, variation of SelectStatement::column
.
Examples
use sea_query::{*, tests_cfg::*}; use std::rc::Rc; let query = Query::select() .from(Char::Table) .columns_dyn(vec![ Rc::new(Char::Character), Rc::new(Char::SizeW), Rc::new(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`"# );
pub fn table_column<T: 'static, C: 'static>(&mut self, t: T, c: C) -> &mut Self where
T: Iden,
C: Iden,
[src]
T: Iden,
C: Iden,
Select column with table prefix.
Examples
use sea_query::{*, tests_cfg::*}; let query = Query::select() .from(Char::Table) .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_dyn(
&mut self,
t: Rc<dyn Iden>,
c: Rc<dyn Iden>
) -> &mut Self
[src]
&mut self,
t: Rc<dyn Iden>,
c: Rc<dyn Iden>
) -> &mut Self
Select column with table prefix, variation of SelectStatement::table_column
.
Examples
use sea_query::{*, tests_cfg::*}; use std::rc::Rc; let query = Query::select() .from(Char::Table) .table_column_dyn(Rc::new(Char::Table), Rc::new(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_columns<T: 'static, C: 'static>(
&mut self,
cols: Vec<(T, C)>
) -> &mut Self where
T: Iden,
C: Iden,
[src]
&mut self,
cols: Vec<(T, C)>
) -> &mut Self where
T: Iden,
C: Iden,
Select columns with table prefix.
Examples
use sea_query::{*, tests_cfg::*}; let query = Query::select() .from(Char::Table) .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_dyn(
&mut self,
cols: Vec<(Rc<dyn Iden>, Rc<dyn Iden>)>
) -> &mut Self
[src]
&mut self,
cols: Vec<(Rc<dyn Iden>, Rc<dyn Iden>)>
) -> &mut Self
Select columns with table prefix, variation of SelectStatement::table_columns_dyn
.
Examples
use sea_query::{*, tests_cfg::*}; use std::rc::Rc; let query = Query::select() .from(Char::Table) .table_columns_dyn(vec![ (Rc::new(Char::Table), Rc::new(Char::Character)), (Rc::new(Char::Table), Rc::new(Char::SizeW)), (Rc::new(Char::Table), Rc::new(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 expr_as<T, A: 'static>(&mut self, expr: T, alias: A) -> &mut Self where
T: Into<SimpleExpr>,
A: Iden,
[src]
T: Into<SimpleExpr>,
A: Iden,
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: 'static>(&mut self, expr: T, alias: A) -> &mut Self where
T: Into<SimpleExpr>,
A: Iden,
[src]
T: Into<SimpleExpr>,
A: Iden,
Please use the [SelectStatement::expr_as
] instead
pub fn from<T: 'static>(&mut self, table: T) -> &mut Self where
T: Iden,
[src]
T: Iden,
From table.
pub fn from_dyn(&mut self, table: Rc<dyn Iden>) -> &mut Self
[src]
From table, variation of SelectStatement::from
.
pub fn from_schema<S: 'static, T: 'static>(
&mut self,
schema: S,
table: T
) -> &mut Self where
S: Iden,
T: Iden,
[src]
&mut self,
schema: S,
table: T
) -> &mut Self where
S: Iden,
T: Iden,
From schema.table.
Examples
use sea_query::{*, tests_cfg::*}; let query = Query::select() .from_schema(Char::Table, Glyph::Table) .column(Char::FontSize) .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_dyn(
&mut self,
schema: Rc<dyn Iden>,
table: Rc<dyn Iden>
) -> &mut Self
[src]
&mut self,
schema: Rc<dyn Iden>,
table: Rc<dyn Iden>
) -> &mut Self
From schema.table, variation of SelectStatement::from_schema
.
pub fn from_as<T: 'static, Y: 'static>(
&mut self,
table: T,
alias: Y
) -> &mut Self where
T: Iden,
Y: Iden,
[src]
&mut self,
table: T,
alias: Y
) -> &mut Self where
T: Iden,
Y: Iden,
From table with alias.
Examples
use sea_query::{*, tests_cfg::*}; let table_as = Alias::new("char"); let query = Query::select() .from_as(Char::Table, table_as.clone()) .table_column(table_as, 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`"# );
pub fn from_alias<T: 'static, Y: 'static>(
&mut self,
table: T,
alias: Y
) -> &mut Self where
T: Iden,
Y: Iden,
[src]
&mut self,
table: T,
alias: Y
) -> &mut Self where
T: Iden,
Y: Iden,
Please use the [SelectStatement::from_as
] instead
pub fn from_as_dyn(
&mut self,
table: Rc<dyn Iden>,
alias: Rc<dyn Iden>
) -> &mut Self
[src]
&mut self,
table: Rc<dyn Iden>,
alias: Rc<dyn Iden>
) -> &mut Self
From table with alias, variation of SelectStatement::from_as
.
pub fn from_schema_as<S: 'static, T: 'static, A: 'static>(
&mut self,
schema: S,
table: T,
alias: A
) -> &mut Self where
S: Iden,
T: Iden,
A: Iden,
[src]
&mut self,
schema: S,
table: T,
alias: A
) -> &mut Self where
S: Iden,
T: Iden,
A: Iden,
From schema.table with alias.
Examples
use sea_query::{*, tests_cfg::*}; let table_as = Alias::new("alias"); let query = Query::select() .from_schema_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_schema_as_dyn(
&mut self,
schema: Rc<dyn Iden>,
table: Rc<dyn Iden>,
alias: Rc<dyn Iden>
) -> &mut Self
[src]
&mut self,
schema: Rc<dyn Iden>,
table: Rc<dyn Iden>,
alias: Rc<dyn Iden>
) -> &mut Self
From table with alias, variation of SelectStatement::from_schema_as
.
pub fn from_subquery<T: 'static>(
&mut self,
query: SelectStatement,
alias: T
) -> &mut Self where
T: Iden,
[src]
&mut self,
query: SelectStatement,
alias: T
) -> &mut Self where
T: Iden,
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 from_subquery_dyn(
&mut self,
query: SelectStatement,
alias: Rc<dyn Iden>
) -> &mut Self
[src]
&mut self,
query: SelectStatement,
alias: Rc<dyn Iden>
) -> &mut Self
From sub-query, variation of SelectStatement::from_subquery
.
pub fn left_join<T: 'static>(
&mut self,
table: T,
condition: SimpleExpr
) -> &mut Self where
T: Iden,
[src]
&mut self,
table: T,
condition: SimpleExpr
) -> &mut Self where
T: Iden,
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 left_join_dyn(
&mut self,
table: Rc<dyn Iden>,
condition: SimpleExpr
) -> &mut Self
[src]
&mut self,
table: Rc<dyn Iden>,
condition: SimpleExpr
) -> &mut Self
Left join, variation of SelectStatement::left_join
.
pub fn inner_join<T: 'static>(
&mut self,
table: T,
condition: SimpleExpr
) -> &mut Self where
T: Iden,
[src]
&mut self,
table: T,
condition: SimpleExpr
) -> &mut Self where
T: Iden,
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 inner_join_dyn(
&mut self,
table: Rc<dyn Iden>,
condition: SimpleExpr
) -> &mut Self
[src]
&mut self,
table: Rc<dyn Iden>,
condition: SimpleExpr
) -> &mut Self
Inner join, variation of SelectStatement::inner_join
.
pub fn join<T: 'static>(
&mut self,
join: JoinType,
table: T,
condition: SimpleExpr
) -> &mut Self where
T: Iden,
[src]
&mut self,
join: JoinType,
table: T,
condition: SimpleExpr
) -> &mut Self where
T: Iden,
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_dyn(
&mut self,
join: JoinType,
table: Rc<dyn Iden>,
condition: SimpleExpr
) -> &mut Self
[src]
&mut self,
join: JoinType,
table: Rc<dyn Iden>,
condition: SimpleExpr
) -> &mut Self
Join with other table by JoinType
, variation of SelectStatement::join
.
pub fn join_as<T: 'static, A: 'static>(
&mut self,
join: JoinType,
table: T,
alias: A,
condition: SimpleExpr
) -> &mut Self where
T: Iden,
A: Iden,
[src]
&mut self,
join: JoinType,
table: T,
alias: A,
condition: SimpleExpr
) -> &mut Self where
T: Iden,
A: Iden,
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<T: 'static, A: 'static>(
&mut self,
join: JoinType,
table: T,
alias: A,
condition: SimpleExpr
) -> &mut Self where
T: Iden,
A: Iden,
[src]
&mut self,
join: JoinType,
table: T,
alias: A,
condition: SimpleExpr
) -> &mut Self where
T: Iden,
A: Iden,
Please use the [SelectStatement::join_as
] instead
pub fn join_as_dyn(
&mut self,
join: JoinType,
table: Rc<dyn Iden>,
alias: Rc<dyn Iden>,
condition: SimpleExpr
) -> &mut Self
[src]
&mut self,
join: JoinType,
table: Rc<dyn Iden>,
alias: Rc<dyn Iden>,
condition: SimpleExpr
) -> &mut Self
Join with other table by JoinType
and alias, variation of SelectStatement::join_as
.
pub fn join_subquery<T: 'static>(
&mut self,
join: JoinType,
query: SelectStatement,
alias: T,
condition: SimpleExpr
) -> &mut Self where
T: Iden,
[src]
&mut self,
join: JoinType,
query: SelectStatement,
alias: T,
condition: SimpleExpr
) -> &mut Self where
T: Iden,
pub fn join_subquery_dyn(
&mut self,
join: JoinType,
query: SelectStatement,
alias: Rc<dyn Iden>,
condition: SimpleExpr
) -> &mut Self
[src]
&mut self,
join: JoinType,
query: SelectStatement,
alias: Rc<dyn Iden>,
condition: SimpleExpr
) -> &mut Self
Join with sub-query, variation of SelectStatement::join_subquery
.
pub fn group_by_columns<T: 'static>(&mut self, cols: Vec<T>) -> &mut Self where
T: Iden,
[src]
T: Iden,
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`"# );
pub fn group_by_columns_dyn(&mut self, cols: Vec<Rc<dyn Iden>>) -> &mut Self
[src]
Group by columns, variation of SelectStatement::group_by_columns
.
pub fn group_by_table_columns<T: 'static>(
&mut self,
cols: Vec<(T, T)>
) -> &mut Self where
T: Iden,
[src]
&mut self,
cols: Vec<(T, T)>
) -> &mut Self where
T: Iden,
Group by columns with table prefix.
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_table_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_table_columns_dyn(
&mut self,
cols: Vec<(Rc<dyn Iden>, Rc<dyn Iden>)>
) -> &mut Self
[src]
&mut self,
cols: Vec<(Rc<dyn Iden>, Rc<dyn Iden>)>
) -> &mut Self
Group by columns with table prefix, variation of SelectStatement::group_by_table_columns
.
pub fn and_where(&mut self, other: SimpleExpr) -> &mut Self
[src]
And where condition.
Examples
use sea_query::{*, tests_cfg::*}; let query = Query::select() .table_column(Glyph::Table, Glyph::Image) .from(Glyph::Table) .and_where(Expr::tbl(Glyph::Table, Glyph::Aspect).is_in(vec![3, 4])) .and_where(Expr::tbl(Glyph::Table, Glyph::Image).like("A%")) .to_owned(); assert_eq!( query.to_string(MysqlQueryBuilder), r#"SELECT `glyph`.`image` FROM `glyph` WHERE `glyph`.`aspect` IN (3, 4) AND `glyph`.`image` LIKE 'A%'"# ); assert_eq!( query.to_string(PostgresQueryBuilder), r#"SELECT "glyph"."image" FROM "glyph" WHERE "glyph"."aspect" IN (3, 4) AND "glyph"."image" LIKE 'A%'"# ); assert_eq!( query.to_string(SqliteQueryBuilder), r#"SELECT `glyph`.`image` FROM `glyph` WHERE `glyph`.`aspect` IN (3, 4) AND `glyph`.`image` LIKE 'A%'"# );
pub fn and_where_option(&mut self, other: Option<SimpleExpr>) -> &mut Self
[src]
And where condition, variation of SelectStatement::and_where
.
pub fn or_where(&mut self, other: SimpleExpr) -> &mut Self
[src]
Or where condition.
Examples
use sea_query::{*, tests_cfg::*}; let query = Query::select() .table_column(Glyph::Table, Glyph::Image) .from(Glyph::Table) .or_where(Expr::tbl(Glyph::Table, Glyph::Aspect).is_in(vec![3, 4])) .or_where(Expr::tbl(Glyph::Table, Glyph::Image).like("A%")) .to_owned(); assert_eq!( query.to_string(MysqlQueryBuilder), r#"SELECT `glyph`.`image` FROM `glyph` WHERE `glyph`.`aspect` IN (3, 4) OR `glyph`.`image` LIKE 'A%'"# ); assert_eq!( query.to_string(PostgresQueryBuilder), r#"SELECT "glyph"."image" FROM "glyph" WHERE "glyph"."aspect" IN (3, 4) OR "glyph"."image" LIKE 'A%'"# ); assert_eq!( query.to_string(SqliteQueryBuilder), r#"SELECT `glyph`.`image` FROM `glyph` WHERE `glyph`.`aspect` IN (3, 4) OR `glyph`.`image` LIKE 'A%'"# );
pub fn add_group_by(&mut self, expr: Vec<SimpleExpr>) -> &mut Self
[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 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]
Or 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, ]) .or_having(Expr::col(Glyph::Aspect).lt(1)) .or_having(Expr::col(Glyph::Aspect).gt(10)) .to_owned(); assert_eq!( query.to_string(MysqlQueryBuilder), r#"SELECT `aspect`, MAX(`image`) FROM `glyph` GROUP BY `aspect` HAVING `aspect` < 1 OR `aspect` > 10"# ); assert_eq!( query.to_string(PostgresQueryBuilder), r#"SELECT "aspect", MAX("image") FROM "glyph" GROUP BY "aspect" HAVING "aspect" < 1 OR "aspect" > 10"# ); assert_eq!( query.to_string(SqliteQueryBuilder), r#"SELECT `aspect`, MAX(`image`) FROM `glyph` GROUP BY `aspect` HAVING `aspect` < 1 OR `aspect` > 10"# );
pub fn order_by<T: 'static>(&mut self, col: T, order: Order) -> &mut Self where
T: Iden,
[src]
T: Iden,
Order by column.
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"# ); assert_eq!( query.to_string(PostgresQueryBuilder), r#"SELECT "aspect" FROM "glyph" WHERE COALESCE("aspect", 0) > 2 ORDER BY "image" DESC, "glyph"."aspect" ASC"# ); assert_eq!( query.to_string(SqliteQueryBuilder), r#"SELECT `aspect` FROM `glyph` WHERE IFNULL(`aspect`, 0) > 2 ORDER BY `image` DESC, `glyph`.`aspect` ASC"# );
pub fn order_by_dyn(&mut self, col: Rc<dyn Iden>, order: Order) -> &mut Self
[src]
Order by column, variation of SelectStatement::order_by
pub fn order_by_tbl<T: 'static, C: 'static>(
&mut self,
table: T,
col: C,
order: Order
) -> &mut Self where
T: Iden,
C: Iden,
[src]
&mut self,
table: T,
col: C,
order: Order
) -> &mut Self where
T: Iden,
C: Iden,
pub fn order_by_tbl_dyn(
&mut self,
table: Rc<dyn Iden>,
col: Rc<dyn Iden>,
order: Order
) -> &mut Self
[src]
&mut self,
table: Rc<dyn Iden>,
col: Rc<dyn Iden>,
order: Order
) -> &mut Self
Order by column with table prefix, variation of SelectStatement::order_by_tbl
.
pub fn order_by_expr(&mut self, expr: SimpleExpr, order: Order) -> &mut Self
[src]
Order by SimpleExpr
.
pub fn order_by_customs<T: 'static>(
&mut self,
cols: Vec<(T, Order)>
) -> &mut Self where
T: ToString,
[src]
&mut self,
cols: Vec<(T, Order)>
) -> &mut Self where
T: ToString,
Order by custom string expression.
pub fn order_by_columns<T: 'static>(
&mut self,
cols: Vec<(T, Order)>
) -> &mut Self where
T: Iden,
[src]
&mut self,
cols: Vec<(T, Order)>
) -> &mut Self where
T: Iden,
Order by vector of columns.
pub fn order_by_columns_dyn(
&mut self,
cols: Vec<(Rc<dyn Iden>, Order)>
) -> &mut Self
[src]
&mut self,
cols: Vec<(Rc<dyn Iden>, Order)>
) -> &mut Self
Order by vector of columns, variation of SelectStatement::order_by_columns
.
pub fn order_by_table_columns<T: 'static, C: 'static>(
&mut self,
cols: Vec<(T, C, Order)>
) -> &mut Self where
T: Iden,
C: Iden,
[src]
&mut self,
cols: Vec<(T, C, Order)>
) -> &mut Self where
T: Iden,
C: Iden,
Order by vector of columns with table prefix.
pub fn order_by_table_columns_dyn(
&mut self,
cols: Vec<(Rc<dyn Iden>, Rc<dyn Iden>, Order)>
) -> &mut Self
[src]
&mut self,
cols: Vec<(Rc<dyn Iden>, Rc<dyn Iden>, Order)>
) -> &mut Self
Order by vector of columns with table prefix, variation of SelectStatement::order_by_table_columns
.
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]
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"# );
pub fn build_collect<T: QueryBuilder>(
&self,
query_builder: T,
collector: &mut dyn FnMut(Value)
) -> String
[src]
&self,
query_builder: T,
collector: &mut dyn FnMut(Value)
) -> String
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)] );
pub fn build_collect_any(
&self,
query_builder: &dyn QueryBuilder,
collector: &mut dyn FnMut(Value)
) -> String
[src]
&self,
query_builder: &dyn QueryBuilder,
collector: &mut dyn FnMut(Value)
) -> String
Build corresponding SQL statement for certain database backend and collect query parameters
pub fn build<T: QueryBuilder>(&self, query_builder: T) -> (String, Values)
[src]
Build corresponding SQL statement for certain database backend and collect query parameters into a vector
Examples
use sea_query::{*, tests_cfg::*}; let (query, params) = 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) .build(MysqlQueryBuilder); assert_eq!( query, r#"SELECT `aspect` FROM `glyph` WHERE IFNULL(`aspect`, ?) > ? ORDER BY `image` DESC, `glyph`.`aspect` ASC"# ); assert_eq!( params, Values(vec![Value::Int(0), Value::Int(2)]) );
pub fn build_any(&self, query_builder: &dyn QueryBuilder) -> (String, Values)
[src]
Build corresponding SQL statement for certain database backend and collect query parameters into a vector
pub fn to_string<T: QueryBuilder>(&self, query_builder: T) -> String
[src]
Build corresponding SQL statement for certain database backend and return SQL string
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_string(MysqlQueryBuilder); assert_eq!( query, r#"SELECT `aspect` FROM `glyph` WHERE IFNULL(`aspect`, 0) > 2 ORDER BY `image` DESC, `glyph`.`aspect` ASC"# );
Trait Implementations
impl Clone for SelectStatement
[src]
fn clone(&self) -> SelectStatement
[src]
pub fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl Debug for SelectStatement
[src]
impl Default for SelectStatement
[src]
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> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> Same<T> for T
type Output = T
Should always be Self
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
V: MultiLane<T>,