Struct sea_orm_migration::prelude::SelectStatement

[−]

pub struct SelectStatement { /* private fields */ }

Expand description

Select rows from an existing table

Examples

use sea_query::{*, tests_cfg::*};

let query = Query::select()
    .column(Char::Character)
    .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

pub fn new() -> SelectStatement

Construct a new SelectStatement

pub fn take(&mut self) -> SelectStatement

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 SelectStatement where
 T: FnOnce(&mut SelectStatement),
 F: FnOnce(&mut SelectStatement),

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 SelectStatement

Clear the select list

pub fn expr<T>(&mut self, expr: T) -> &mut SelectStatement where
T: Into<SelectExpr>,

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 SelectStatement where
T: Into<SelectExpr>,
I: IntoIterator<Item = T>,

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),

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

Select distinct

pub fn distinct_on<T, I>(&mut self, cols: I) -> &mut SelectStatement where
T: IntoColumnRef,
I: IntoIterator<Item = T>,

Select distinct on for POSTGRES ONLY

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .from(Char::Table)
    .distinct_on(vec![Char::Character])
    .column(Char::Character)
    .column(Char::SizeW)
    .column(Char::SizeH)
    .to_owned();

assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT DISTINCT ON ("character") "character", "size_w", "size_h" FROM "character""#
)

use sea_query::{tests_cfg::*, *};

let distinct_cols: Vec<Character> = vec![];
let query = Query::select()
    .from(Char::Table)
    .distinct_on(distinct_cols)
    .column(Char::Character)
    .column(Char::SizeW)
    .column(Char::SizeH)
    .to_owned();

assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character""#
)

pub fn column<C>(&mut self, col: C) -> &mut SelectStatement where
C: IntoColumnRef,

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""#
);

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .from(Char::Table)
    .column((Alias::new("schema"), Char::Table, Char::Character))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `schema`.`character`.`character` FROM `character`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "schema"."character"."character" FROM "character""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "schema"."character"."character" FROM "character""#
);

pub fn table_column<T, C>(&mut self, t: T, c: C) -> &mut SelectStatement where
T: IntoIden,
C: IntoIden,

👎 Deprecated since 0.9.0:

Please use the [SelectStatement::column] with a tuple as [ColumnRef]

pub fn columns<T, I>(&mut self, cols: I) -> &mut SelectStatement where
T: IntoColumnRef,
I: IntoIterator<Item = T>,

Select columns.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .from(Char::Table)
    .columns([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([
        (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), Global>
) -> &mut SelectStatement where
 T: IntoIden,
 C: IntoIden,

👎 Deprecated since 0.9.0:

Please use the [SelectStatement::columns] with a tuple as [ColumnRef]

pub fn expr_as<T, A>(&mut self, expr: T, alias: A) -> &mut SelectStatement where
T: Into<SimpleExpr>,
A: IntoIden,

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 SelectStatement where
T: Into<SimpleExpr>,
A: IntoIden,

👎 Deprecated since 0.6.1:

Please use the [SelectStatement::expr_as] instead

pub fn expr_window<T>(
 &mut self,
 expr: T,
 window: WindowStatement
) -> &mut SelectStatement where
 T: Into<SimpleExpr>,

Select column with window function.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .from(Char::Table)
    .expr_window(
        Expr::col(Char::Character),
        WindowStatement::partition_by(Char::FontSize),
    )
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character` OVER ( PARTITION BY `font_size` ) FROM `character`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character" OVER ( PARTITION BY "font_size" ) FROM "character""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character" OVER ( PARTITION BY "font_size" ) FROM "character""#
);

pub fn expr_window_as<T, A>(
 &mut self,
 expr: T,
 window: WindowStatement,
 alias: A
) -> &mut SelectStatement where
 T: Into<SimpleExpr>,
 A: IntoIden,

Select column with window function and label.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .from(Char::Table)
    .expr_window_as(
        Expr::col(Char::Character),
        WindowStatement::partition_by(Char::FontSize),
        Alias::new("C"),
    )
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character` OVER ( PARTITION BY `font_size` ) AS `C` FROM `character`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character" OVER ( PARTITION BY "font_size" ) AS "C" FROM "character""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character" OVER ( PARTITION BY "font_size" ) AS "C" FROM "character""#
);

pub fn expr_window_name<T, W>(
 &mut self,
 expr: T,
 window: W
) -> &mut SelectStatement where
 T: Into<SimpleExpr>,
 W: IntoIden,

Select column with window name.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .from(Char::Table)
    .expr_window_name(Expr::col(Char::Character), Alias::new("w"))
    .window(
        Alias::new("w"),
        WindowStatement::partition_by(Char::FontSize),
    )
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character` OVER `w` FROM `character` WINDOW `w` AS PARTITION BY `font_size`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character" OVER "w" FROM "character" WINDOW "w" AS PARTITION BY "font_size""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character" OVER "w" FROM "character" WINDOW "w" AS PARTITION BY "font_size""#
);

pub fn expr_window_name_as<T, W, A>(
 &mut self,
 expr: T,
 window: W,
 alias: A
) -> &mut SelectStatement where
 T: Into<SimpleExpr>,
 A: IntoIden,
 W: IntoIden,

Select column with window name and label.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .from(Char::Table)
    .expr_window_name_as(Expr::col(Char::Character), Alias::new("w"), Alias::new("C"))
    .window(Alias::new("w"), WindowStatement::partition_by(Char::FontSize))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character` OVER `w` AS `C` FROM `character` WINDOW `w` AS PARTITION BY `font_size`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character" OVER "w" AS "C" FROM "character" WINDOW "w" AS PARTITION BY "font_size""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character" OVER "w" AS "C" FROM "character" WINDOW "w" AS PARTITION BY "font_size""#
);

pub fn from<R>(&mut self, tbl_ref: R) -> &mut SelectStatement where
R: IntoTableRef,

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""#
);

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .column(Char::FontSize)
    .from((Alias::new("database"), Char::Table, Glyph::Table))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `font_size` FROM `database`.`character`.`glyph`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "font_size" FROM "database"."character"."glyph""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "font_size" FROM "database"."character"."glyph""#
);

If you specify from multiple times, the resulting query will have multiple from clauses. You can perform an ‘old-school’ join this way.

use sea_query::{tests_cfg::*, *};

let query = sea_query::Query::select()
    .expr(Expr::asterisk())
    .from(Char::Table)
    .from(Font::Table)
    .and_where(Expr::tbl(Font::Table, Font::Id).equals(Char::Table, Char::FontId))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT * FROM `character`, `font` WHERE `font`.`id` = `character`.`font_id`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT * FROM "character", "font" WHERE "font"."id" = "character"."font_id""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT * FROM "character", "font" WHERE "font"."id" = "character"."font_id""#
);

pub fn from_values<I, V, A>(
 &mut self,
 value_tuples: I,
 alias: A
) -> &mut SelectStatement where
 I: IntoIterator<Item = V>,
 V: IntoValueTuple,
 A: IntoIden,

Shorthand for selecting from a constant value list. Panics on an empty values list.

use sea_query::{tests_cfg::*, *};

let query = sea_query::Query::select()
    .expr(Expr::asterisk())
    .from_values(vec![(1, "hello"), (2, "world")], Alias::new("x"))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT * FROM (VALUES ROW(1, 'hello'), ROW(2, 'world')) AS `x`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT * FROM (VALUES (1, 'hello'), (2, 'world')) AS "x""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT * FROM (VALUES (1, 'hello'), (2, 'world')) AS "x""#
);

pub fn from_schema<S, T>(&mut self, schema: S, table: T) -> &mut SelectStatement where
S: 'static + IntoIden,
T: 'static + IntoIden,

👎 Deprecated since 0.9.0:

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 SelectStatement where
R: IntoTableRef,
A: IntoIden,

From table with alias.

Examples

use sea_query::{tests_cfg::*, *};

let table_as: DynIden = SeaRc::new(Alias::new("char"));

let query = Query::select()
    .from_as(Char::Table, table_as.clone())
    .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())
    .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 SelectStatement where
R: IntoTableRef,
A: IntoIden,

👎 Deprecated since 0.6.1:

Please use the [SelectStatement::from_as] instead

pub fn from_schema_as<S, T, A>(
 &mut self,
 schema: S,
 table: T,
 alias: A
) -> &mut SelectStatement where
 S: 'static + IntoIden,
 T: 'static + IntoIden,
 A: IntoIden,

👎 Deprecated since 0.9.0:

Please use the [SelectStatement::from_as] with a tuple as [TableRef]

pub fn from_subquery<T>(
 &mut self,
 query: SelectStatement,
 alias: T
) -> &mut SelectStatement where
 T: IntoIden,

From sub-query.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .columns([Glyph::Image])
    .from_subquery(
        Query::select()
            .columns([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, C>(
 &mut self,
 tbl_ref: R,
 condition: C
) -> &mut SelectStatement where
 R: IntoTableRef,
 C: IntoCondition,

Left join.

Examples

use sea_query::{*, tests_cfg::*};

let query = Query::select()
    .column(Char::Character)
    .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""#
);

// Constructing chained join conditions
assert_eq!(
    Query::select()
        .column(Char::Character)
        .column((Font::Table, Font::Name))
        .from(Char::Table)
        .left_join(
            Font::Table,
            Condition::all()
                .add(Expr::tbl(Char::Table, Char::FontId).equals(Font::Table, Font::Id))
                .add(Expr::tbl(Char::Table, Char::FontId).equals(Font::Table, Font::Id))
        )
        .to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `font`.`name` FROM `character` LEFT JOIN `font` ON `character`.`font_id` = `font`.`id` AND `character`.`font_id` = `font`.`id`"#
);

pub fn inner_join<R, C>(
 &mut self,
 tbl_ref: R,
 condition: C
) -> &mut SelectStatement where
 R: IntoTableRef,
 C: IntoCondition,

Inner join.

Examples

use sea_query::{*, tests_cfg::*};

let query = Query::select()
    .column(Char::Character)
    .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""#
);

// Constructing chained join conditions
assert_eq!(
    Query::select()
        .column(Char::Character)
        .column((Font::Table, Font::Name))
        .from(Char::Table)
        .inner_join(
            Font::Table,
            Condition::all()
                .add(Expr::tbl(Char::Table, Char::FontId).equals(Font::Table, Font::Id))
                .add(Expr::tbl(Char::Table, Char::FontId).equals(Font::Table, Font::Id))
        )
        .to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `font`.`name` FROM `character` INNER JOIN `font` ON `character`.`font_id` = `font`.`id` AND `character`.`font_id` = `font`.`id`"#
);

pub fn join<R, C>(
 &mut self,
 join: JoinType,
 tbl_ref: R,
 condition: C
) -> &mut SelectStatement where
 R: IntoTableRef,
 C: IntoCondition,

Join with other table by JoinType.

Examples

use sea_query::{*, tests_cfg::*};

let query = Query::select()
    .column(Char::Character)
    .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""#
);

// Constructing chained join conditions
assert_eq!(
    Query::select()
        .column(Char::Character)
        .column((Font::Table, Font::Name))
        .from(Char::Table)
        .join(
            JoinType::RightJoin,
            Font::Table,
            Condition::all()
                .add(Expr::tbl(Char::Table, Char::FontId).equals(Font::Table, Font::Id))
                .add(Expr::tbl(Char::Table, Char::FontId).equals(Font::Table, Font::Id))
        )
        .to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `font`.`name` FROM `character` RIGHT JOIN `font` ON `character`.`font_id` = `font`.`id` AND `character`.`font_id` = `font`.`id`"#
);

pub fn join_as<R, A, C>(
 &mut self,
 join: JoinType,
 tbl_ref: R,
 alias: A,
 condition: C
) -> &mut SelectStatement where
 R: IntoTableRef,
 A: IntoIden,
 C: IntoCondition,

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)
    .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""#
);

// Constructing chained join conditions
assert_eq!(
    Query::select()
        .column(Char::Character)
        .column((Font::Table, Font::Name))
        .from(Char::Table)
        .join_as(
            JoinType::RightJoin,
            Font::Table,
            Alias::new("f"),
            Condition::all()
                .add(Expr::tbl(Char::Table, Char::FontId).equals(Font::Table, Font::Id))
                .add(Expr::tbl(Char::Table, Char::FontId).equals(Font::Table, Font::Id))
        )
        .to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `font`.`name` FROM `character` RIGHT JOIN `font` AS `f` ON `character`.`font_id` = `font`.`id` AND `character`.`font_id` = `font`.`id`"#
);

pub fn join_alias<R, A, C>(
 &mut self,
 join: JoinType,
 tbl_ref: R,
 alias: A,
 condition: C
) -> &mut SelectStatement where
 R: IntoTableRef,
 A: IntoIden,
 C: IntoCondition,

👎 Deprecated since 0.6.1:

Please use the [SelectStatement::join_as] instead

pub fn join_subquery<T, C>(
 &mut self,
 join: JoinType,
 query: SelectStatement,
 alias: T,
 condition: C
) -> &mut SelectStatement where
 T: IntoIden,
 C: IntoCondition,

Join with sub-query.

Examples

use sea_query::{*, tests_cfg::*};

let sub_glyph: DynIden = SeaRc::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""#
);

// Constructing chained join conditions
assert_eq!(
    Query::select()
        .column(Font::Name)
        .from(Font::Table)
        .join_subquery(
            JoinType::LeftJoin,
            Query::select().column(Glyph::Id).from(Glyph::Table).take(),
            sub_glyph.clone(),
            Condition::all()
                .add(Expr::tbl(Font::Table, Font::Id).equals(sub_glyph.clone(), Glyph::Id))
                .add(Expr::tbl(Font::Table, Font::Id).equals(sub_glyph.clone(), Glyph::Id))
        )
        .to_string(MysqlQueryBuilder),
    r#"SELECT `name` FROM `font` LEFT JOIN (SELECT `id` FROM `glyph`) AS `sub_glyph` ON `font`.`id` = `sub_glyph`.`id` AND `font`.`id` = `sub_glyph`.`id`"#
);

pub fn join_lateral<T, C>(
 &mut self,
 join: JoinType,
 query: SelectStatement,
 alias: T,
 condition: C
) -> &mut SelectStatement where
 T: IntoIden,
 C: IntoCondition,

Join Lateral with sub-query. Not supported by SQLite.

Examples

use sea_query::{*, tests_cfg::*};

let sub_glyph: DynIden = SeaRc::new(Alias::new("sub_glyph"));
let query = Query::select()
    .column(Font::Name)
    .from(Font::Table)
    .join_lateral(
        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 LATERAL (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 LATERAL (SELECT "id" FROM "glyph") AS "sub_glyph" ON "font"."id" = "sub_glyph"."id""#
);

// Constructing chained join conditions
assert_eq!(
    Query::select()
        .column(Font::Name)
        .from(Font::Table)
        .join_lateral(
            JoinType::LeftJoin,
            Query::select().column(Glyph::Id).from(Glyph::Table).take(),
            sub_glyph.clone(),
            Condition::all()
                .add(Expr::tbl(Font::Table, Font::Id).equals(sub_glyph.clone(), Glyph::Id))
                .add(Expr::tbl(Font::Table, Font::Id).equals(sub_glyph.clone(), Glyph::Id))
        )
        .to_string(MysqlQueryBuilder),
    r#"SELECT `name` FROM `font` LEFT JOIN LATERAL (SELECT `id` FROM `glyph`) AS `sub_glyph` ON `font`.`id` = `sub_glyph`.`id` AND `font`.`id` = `sub_glyph`.`id`"#
);

pub fn group_by_columns<T, I>(&mut self, cols: I) -> &mut SelectStatement where
T: IntoColumnRef,
I: IntoIterator<Item = T>,

Group by columns.

Examples

use sea_query::{*, tests_cfg::*};

let query = Query::select()
    .column(Char::Character)
    .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)
    .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 SelectStatement where
T: IntoColumnRef,

Add a group by column.

use sea_query::{*, tests_cfg::*};

let query = Query::select()
    .column(Char::Character)
    .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), Global>
) -> &mut SelectStatement where
 T: IntoIden,
 C: IntoIden,

👎 Deprecated since 0.9.0:

Please use the [SelectStatement::group_by_columns] with a tuple as [ColumnRef]

pub fn add_group_by(&mut self, expr: I) -> &mut SelectStatement where
I: IntoIterator<Item = SimpleExpr>,

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<C>(&mut self, condition: C) -> &mut SelectStatement where
C: IntoCondition,

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 SelectStatement

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))
    .cond_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 SelectStatement

👎 Deprecated since 0.12.0:

Please use [ConditionalStatement::cond_having]. Calling or_having after and_having will panic.

Or having condition. Please use cond_having instead. Calling or_having after and_having will panic.

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).gt(2))
    .or_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 OR `aspect` < 8"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "aspect", MAX("image") FROM "glyph" GROUP BY "aspect" HAVING "aspect" > 2 OR "aspect" < 8"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "aspect", MAX("image") FROM "glyph" GROUP BY "aspect" HAVING "aspect" > 2 OR "aspect" < 8"#
);

pub fn limit(&mut self, limit: u64) -> &mut SelectStatement

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 reset_limit(&mut self) -> &mut SelectStatement

Reset limit

pub fn offset(&mut self, offset: u64) -> &mut SelectStatement

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 reset_offset(&mut self) -> &mut SelectStatement

Reset offset

pub fn lock(&mut self, type: LockType) -> &mut SelectStatement

Row locking (if supported).

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .column(Char::Character)
    .from(Char::Table)
    .and_where(Expr::col(Char::FontId).eq(5))
    .lock(LockType::Update)
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character` FROM `character` WHERE `font_id` = 5 FOR UPDATE"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character" FROM "character" WHERE "font_id" = 5 FOR UPDATE"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character" FROM "character" WHERE "font_id" = 5 "#
);

pub fn lock_with_tables<T, I>(
 &mut self,
 type: LockType,
 tables: I
) -> &mut SelectStatement where
 T: IntoTableRef,
 I: IntoIterator<Item = T>,

Row locking with tables (if supported).

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .column(Char::Character)
    .from(Char::Table)
    .and_where(Expr::col(Char::FontId).eq(5))
    .lock_with_tables(LockType::Update, vec![Glyph::Table])
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character` FROM `character` WHERE `font_id` = 5 FOR UPDATE OF `glyph`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character" FROM "character" WHERE "font_id" = 5 FOR UPDATE OF "glyph""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character" FROM "character" WHERE "font_id" = 5 "#
);

pub fn lock_with_behavior(
    &mut self,
    type: LockType,
    behavior: LockBehavior
) -> &mut SelectStatement

Row locking with behavior (if supported).

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .column(Char::Character)
    .from(Char::Table)
    .and_where(Expr::col(Char::FontId).eq(5))
    .lock_with_behavior(LockType::Update, LockBehavior::Nowait)
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character` FROM `character` WHERE `font_id` = 5 FOR UPDATE NOWAIT"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character" FROM "character" WHERE "font_id" = 5 FOR UPDATE NOWAIT"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character" FROM "character" WHERE "font_id" = 5 "#
);

pub fn lock_with_tables_behavior<T, I>(
 &mut self,
 type: LockType,
 tables: I,
 behavior: LockBehavior
) -> &mut SelectStatement where
 T: IntoTableRef,
 I: IntoIterator<Item = T>,

Row locking with tables and behavior (if supported).

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .column(Char::Character)
    .from(Char::Table)
    .and_where(Expr::col(Char::FontId).eq(5))
    .lock_with_tables_behavior(LockType::Update, vec![Glyph::Table], LockBehavior::Nowait)
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character` FROM `character` WHERE `font_id` = 5 FOR UPDATE OF `glyph` NOWAIT"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character" FROM "character" WHERE "font_id" = 5 FOR UPDATE OF "glyph" NOWAIT"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character" FROM "character" WHERE "font_id" = 5 "#
);

pub fn lock_shared(&mut self) -> &mut SelectStatement

Shared row locking (if supported).

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .column(Char::Character)
    .from(Char::Table)
    .and_where(Expr::col(Char::FontId).eq(5))
    .lock_shared()
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character` FROM `character` WHERE `font_id` = 5 FOR SHARE"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character" FROM "character" WHERE "font_id" = 5 FOR SHARE"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character" FROM "character" WHERE "font_id" = 5 "#
);

pub fn lock_exclusive(&mut self) -> &mut SelectStatement

Exclusive row locking (if supported).

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .column(Char::Character)
    .from(Char::Table)
    .and_where(Expr::col(Char::FontId).eq(5))
    .lock_exclusive()
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character` FROM `character` WHERE `font_id` = 5 FOR UPDATE"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character" FROM "character" WHERE "font_id" = 5 FOR UPDATE"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character" FROM "character" WHERE "font_id" = 5 "#
);

pub fn union(
    &mut self,
    union_type: UnionType,
    query: SelectStatement
) -> &mut SelectStatement

Union with another SelectStatement that must have the same selected fields.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .column(Char::Character)
    .from(Char::Table)
    .and_where(Expr::col(Char::FontId).eq(5))
    .union(UnionType::All, Query::select()
        .column(Char::Character)
        .from(Char::Table)
        .and_where(Expr::col(Char::FontId).eq(4))
        .to_owned()
    )
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character` FROM `character` WHERE `font_id` = 5 UNION ALL SELECT `character` FROM `character` WHERE `font_id` = 4"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character" FROM "character" WHERE "font_id" = 5 UNION ALL SELECT "character" FROM "character" WHERE "font_id" = 4"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character" FROM "character" WHERE "font_id" = 5 UNION ALL SELECT "character" FROM "character" WHERE "font_id" = 4"#
);

pub fn unions<T>(&mut self, unions: T) -> &mut SelectStatement where
T: IntoIterator<Item = (UnionType, SelectStatement)>,

Union with multiple SelectStatement that must have the same selected fields.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .column(Char::Character)
    .from(Char::Table)
    .and_where(Expr::col(Char::FontId).eq(5))
    .unions(vec![
        (UnionType::All, Query::select()
            .column(Char::Character)
            .from(Char::Table)
            .and_where(Expr::col(Char::FontId).eq(4))
            .to_owned()),
        (UnionType::Distinct, Query::select()
            .column(Char::Character)
            .from(Char::Table)
            .and_where(Expr::col(Char::FontId).eq(3))
            .to_owned()),
    ])
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character` FROM `character` WHERE `font_id` = 5 UNION ALL SELECT `character` FROM `character` WHERE `font_id` = 4 UNION SELECT `character` FROM `character` WHERE `font_id` = 3"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character" FROM "character" WHERE "font_id" = 5 UNION ALL SELECT "character" FROM "character" WHERE "font_id" = 4 UNION SELECT "character" FROM "character" WHERE "font_id" = 3"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character" FROM "character" WHERE "font_id" = 5 UNION ALL SELECT "character" FROM "character" WHERE "font_id" = 4 UNION SELECT "character" FROM "character" WHERE "font_id" = 3"#
);

pub fn with(self, clause: WithClause) -> WithQuery

Create a WithQuery by specifying a WithClause to execute this query with.

Examples

use sea_query::{*, IntoCondition, IntoIden, tests_cfg::*};

let base_query = SelectStatement::new()
                    .column(Alias::new("id"))
                    .expr(Expr::val(1i32))
                    .column(Alias::new("next"))
                    .column(Alias::new("value"))
                    .from(Alias::new("table"))
                    .to_owned();

let cte_referencing = SelectStatement::new()
                            .column(Alias::new("id"))
                            .expr(Expr::col(Alias::new("depth")).add(1i32))
                            .column(Alias::new("next"))
                            .column(Alias::new("value"))
                            .from(Alias::new("table"))
                            .join(
                                JoinType::InnerJoin,
                                Alias::new("cte_traversal"),
                                Expr::tbl(Alias::new("cte_traversal"), Alias::new("next")).equals(Alias::new("table"), Alias::new("id")).into_condition()
                            )
                            .to_owned();

let common_table_expression = CommonTableExpression::new()
            .query(
                base_query.clone().union(UnionType::All, cte_referencing).to_owned()
            )
            .columns([Alias::new("id"), Alias::new("depth"), Alias::new("next"), Alias::new("value")])
            .table_name(Alias::new("cte_traversal"))
            .to_owned();

let select = SelectStatement::new()
        .column(ColumnRef::Asterisk)
        .from(Alias::new("cte_traversal"))
        .to_owned();

let with_clause = WithClause::new()
        .recursive(true)
        .cte(common_table_expression)
        .cycle(Cycle::new_from_expr_set_using(SimpleExpr::Column(ColumnRef::Column(Alias::new("id").into_iden())), Alias::new("looped"), Alias::new("traversal_path")))
        .to_owned();

let query = select.with(with_clause).to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"WITH RECURSIVE `cte_traversal` (`id`, `depth`, `next`, `value`) AS (SELECT `id`, 1, `next`, `value` FROM `table` UNION ALL SELECT `id`, `depth` + 1, `next`, `value` FROM `table` INNER JOIN `cte_traversal` ON `cte_traversal`.`next` = `table`.`id`) SELECT * FROM `cte_traversal`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"WITH RECURSIVE "cte_traversal" ("id", "depth", "next", "value") AS (SELECT "id", 1, "next", "value" FROM "table" UNION ALL SELECT "id", "depth" + 1, "next", "value" FROM "table" INNER JOIN "cte_traversal" ON "cte_traversal"."next" = "table"."id") CYCLE "id" SET "looped" USING "traversal_path" SELECT * FROM "cte_traversal""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"WITH RECURSIVE "cte_traversal" ("id", "depth", "next", "value") AS (SELECT "id", 1, "next", "value" FROM "table" UNION ALL SELECT "id", "depth" + 1, "next", "value" FROM "table" INNER JOIN "cte_traversal" ON "cte_traversal"."next" = "table"."id") SELECT * FROM "cte_traversal""#
);

pub fn window<A>(
 &mut self,
 name: A,
 window: WindowStatement
) -> &mut SelectStatement where
 A: IntoIden,

WINDOW

Examples:

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .from(Char::Table)
    .expr_window_name_as(Expr::col(Char::Character), Alias::new("w"), Alias::new("C"))
    .window(Alias::new("w"), WindowStatement::partition_by(Char::FontSize))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character` OVER `w` AS `C` FROM `character` WINDOW `w` AS PARTITION BY `font_size`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character" OVER "w" AS "C" FROM "character" WINDOW "w" AS PARTITION BY "font_size""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character" OVER "w" AS "C" FROM "character" WINDOW "w" AS PARTITION BY "font_size""#
);

impl SelectStatement

pub fn to_string<T>(&self, query_builder: T) -> String where
T: QueryBuilder,

pub fn build<T>(&self, query_builder: T) -> (String, Values) where
T: QueryBuilder,

pub fn build_any(&self, query_builder: &dyn QueryBuilder) -> (String, Values)

impl SelectStatement

pub fn order_by<T>(&mut self, col: T, order: Order) -> &mut SelectStatement where
T: IntoColumnRef,

pub fn order_by_tbl<T, C>(
 &mut self,
 table: T,
 col: C,
 order: Order
) -> &mut SelectStatement where
 T: IntoIden,
 C: IntoIden,

👎 Deprecated since 0.9.0:

Please use the [OrderedStatement::order_by] with a tuple as [ColumnRef]

pub fn order_by_expr(
    &mut self,
    expr: SimpleExpr,
    order: Order
) -> &mut SelectStatement

pub fn order_by_customs<T>(
 &mut self,
 cols: Vec<(T, Order), Global>
) -> &mut SelectStatement where
 T: ToString,

pub fn order_by_columns<T>(
 &mut self,
 cols: Vec<(T, Order), Global>
) -> &mut SelectStatement where
 T: IntoColumnRef,

pub fn order_by_table_columns<T, C>(
 &mut self,
 cols: Vec<(T, C, Order), Global>
) -> &mut SelectStatement where
 T: IntoIden,
 C: IntoIden,

👎 Deprecated since 0.9.0:

Please use the [OrderedStatement::order_by_columns] with a tuple as [ColumnRef]

impl SelectStatement

pub fn and_where(&mut self, other: SimpleExpr) -> &mut SelectStatement

pub fn and_where_option(
&mut self,
other: Option<SimpleExpr>
) -> &mut SelectStatement

pub fn or_where(&mut self, other: SimpleExpr) -> &mut SelectStatement

👎 Deprecated since 0.12.0:

Please use [ConditionalStatement::cond_where]. Calling or_where after and_where will panic.

pub fn cond_where<C>(&mut self, condition: C) -> &mut SelectStatement where
C: IntoCondition,

Trait Implementations

impl Clone for SelectStatement

fn clone(&self) -> SelectStatement

Returns a copy of the value. Read more

1.0.0 · source

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more

impl ConditionalStatement for SelectStatement

fn cond_where<C>(&mut self, condition: C) -> &mut SelectStatement where
C: IntoCondition,

Where condition, expressed with any and all. Calling cond_where multiple times will conjoin them. Calling or_where after cond_where will panic. Read more

fn and_where(&mut self, other: SimpleExpr) -> &mut Self

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

Optional and where, short hand for if c.is_some() q.and_where(c). Read more

fn or_where(&mut self, other: SimpleExpr) -> &mut Self

👎 Deprecated since 0.12.0:

Please use [ConditionalStatement::cond_where]. Calling or_where after and_where will panic.

Or where condition. This cannot be mixed with ConditionalStatement::and_where. Calling or_where after and_where will panic. Read more

impl Debug for SelectStatement

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

Formats the value using the given formatter. Read more

impl Default for SelectStatement

fn default() -> SelectStatement

Returns the “default value” for a type. Read more

impl OrderedStatement for SelectStatement

fn clear_order_by(&mut self) -> &mut SelectStatement

Clear order expressions

fn order_by<T>(&mut self, col: T, order: Order) -> &mut Self where
T: IntoColumnRef,

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,

👎 Deprecated since 0.9.0:

Please use the [OrderedStatement::order_by] with a tuple as [ColumnRef]

fn order_by_expr(&mut self, expr: SimpleExpr, order: Order) -> &mut Self

Order by SimpleExpr.

fn order_by_customs<T>(&mut self, cols: Vec<(T, Order), Global>) -> &mut Self where
T: ToString,

Order by custom string.

fn order_by_columns<T>(&mut self, cols: Vec<(T, Order), Global>) -> &mut Self where
T: IntoColumnRef,

Order by vector of columns.

fn order_by_table_columns<T, C>(
 &mut self,
 cols: Vec<(T, C, Order), Global>
) -> &mut Self where
 T: IntoIden,
 C: IntoIden,

👎 Deprecated since 0.9.0:

Please use the [OrderedStatement::order_by_columns] with a tuple as [ColumnRef]

fn order_by_with_nulls<T>(
 &mut self,
 col: T,
 order: Order,
 nulls: NullOrdering
) -> &mut Self where
 T: IntoColumnRef,

Order by column with nulls order option. Read more

fn order_by_expr_with_nulls(
    &mut self,
    expr: SimpleExpr,
    order: Order,
    nulls: NullOrdering
) -> &mut Self

Order by SimpleExpr with nulls order option.

fn order_by_customs_with_nulls<T>(
 &mut self,
 cols: Vec<(T, Order, NullOrdering), Global>
) -> &mut Self where
 T: ToString,

Order by custom string with nulls order option.

fn order_by_columns_with_nulls<T>(
 &mut self,
 cols: Vec<(T, Order, NullOrdering), Global>
) -> &mut Self where
 T: IntoColumnRef,

Order by vector of columns with nulls order option.

impl QueryStatementBuilder for SelectStatement

fn build_collect_any_into(
    &self,
    query_builder: &dyn QueryBuilder,
    sql: &mut SqlWriter,
    collector: &mut dyn FnMut(Value)
)

Build corresponding SQL statement into the SqlWriter for certain database backend and collect query parameters

fn into_sub_query_statement(self) -> SubQueryStatement

fn build_any(&self, query_builder: &dyn QueryBuilder) -> (String, Values)

Build corresponding SQL statement for certain database backend and collect query parameters into a vector

fn build_collect_any(
    &self,
    query_builder: &dyn QueryBuilder,
    collector: &mut dyn FnMut(Value)
) -> String

Build corresponding SQL statement for certain database backend and collect query parameters

impl QueryStatementWriter for SelectStatement

fn build_collect<T>(
 &self,
 query_builder: T,
 collector: &mut dyn FnMut(Value)
) -> String where
 T: QueryBuilder,

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(Some(0)), Value::Int(Some(2))]
);

fn to_string<T>(&self, query_builder: T) -> String where
T: QueryBuilder,

Build corresponding SQL statement for certain database backend and return SQL string Read more

fn build<T>(&self, query_builder: T) -> (String, Values) where
T: QueryBuilder,

Build corresponding SQL statement for certain database backend and collect query parameters into a vector Read more

source

impl StatementBuilder for SelectStatement

source

fn build(&self, db_backend: &DatabaseBackend) -> Statement

Method to call in order to build a Statement

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

source

impl<T> Any for T where
T: 'static + ?Sized,

source

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

source

impl<T> Borrow<T> for T where
T: ?Sized,

const: unstable · source

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

source

impl<T> BorrowMut<T> for T where
T: ?Sized,

const: unstable · source

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

source

impl<T> From<T> for T

const: unstable · source

fn from(t: T) -> T

Returns the argument unchanged.

source

impl<T> Instrument for T

source

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

source

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

source

impl<T, U> Into for T where
U: From<T>,

const: unstable · source

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source

impl<T> ToOwned for T where
T: Clone,

type Owned = T

The resulting type after obtaining ownership.

source

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

source

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

source

impl<T, U> TryFrom for T where
U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

source

impl<T, U> TryInto for T where
U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

const: unstable · source

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

source

impl<T> WithSubscriber for T

source

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where
S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more

source

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more

Struct sea_orm_migration::prelude::SelectStatement

Implementations

impl SelectStatement

pub fn new() -> SelectStatement

pub fn take(&mut self) -> SelectStatement

pub fn conditions<T, F>( &mut self, b: bool, if_true: T, if_false: F) -> &mut SelectStatement where T: FnOnce(&mut SelectStatement), F: FnOnce(&mut SelectStatement),

pub fn clear_selects(&mut self) -> &mut SelectStatement

pub fn expr<T>(&mut self, expr: T) -> &mut SelectStatement where T: Into<SelectExpr>,

pub fn exprs<T, I>(&mut self, exprs: I) -> &mut SelectStatement where T: Into<SelectExpr>, I: IntoIterator<Item = T>,

pub fn exprs_mut_for_each<F>(&mut self, func: F) where F: FnMut(&mut SelectExpr),

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

pub fn distinct_on<T, I>(&mut self, cols: I) -> &mut SelectStatement where T: IntoColumnRef, I: IntoIterator<Item = T>,

pub fn column<C>(&mut self, col: C) -> &mut SelectStatement where C: IntoColumnRef,

pub fn table_column<T, C>(&mut self, t: T, c: C) -> &mut SelectStatement where T: IntoIden, C: IntoIden,

pub fn columns<T, I>(&mut self, cols: I) -> &mut SelectStatement where T: IntoColumnRef, I: IntoIterator<Item = T>,

pub fn table_columns<T, C>( &mut self, cols: Vec<(T, C), Global>) -> &mut SelectStatement where T: IntoIden, C: IntoIden,

pub fn expr_as<T, A>(&mut self, expr: T, alias: A) -> &mut SelectStatement where T: Into<SimpleExpr>, A: IntoIden,

pub fn expr_alias<T, A>(&mut self, expr: T, alias: A) -> &mut SelectStatement where T: Into<SimpleExpr>, A: IntoIden,

pub fn expr_window<T>( &mut self, expr: T, window: WindowStatement) -> &mut SelectStatement where T: Into<SimpleExpr>,

pub fn expr_window_as<T, A>( &mut self, expr: T, window: WindowStatement, alias: A) -> &mut SelectStatement where T: Into<SimpleExpr>, A: IntoIden,

pub fn expr_window_name<T, W>( &mut self, expr: T, window: W) -> &mut SelectStatement where T: Into<SimpleExpr>, W: IntoIden,

pub fn expr_window_name_as<T, W, A>( &mut self, expr: T, window: W, alias: A) -> &mut SelectStatement where T: Into<SimpleExpr>, A: IntoIden, W: IntoIden,

pub fn from<R>(&mut self, tbl_ref: R) -> &mut SelectStatement where R: IntoTableRef,

pub fn from_values<I, V, A>( &mut self, value_tuples: I, alias: A) -> &mut SelectStatement where I: IntoIterator<Item = V>, V: IntoValueTuple, A: IntoIden,

pub fn from_schema<S, T>(&mut self, schema: S, table: T) -> &mut SelectStatement where S: 'static + IntoIden, T: 'static + IntoIden,

pub fn from_as<R, A>(&mut self, tbl_ref: R, alias: A) -> &mut SelectStatement where R: IntoTableRef, A: IntoIden,

pub fn from_alias<R, A>(&mut self, tbl_ref: R, alias: A) -> &mut SelectStatement where R: IntoTableRef, A: IntoIden,

pub fn from_schema_as<S, T, A>( &mut self, schema: S, table: T, alias: A) -> &mut SelectStatement where S: 'static + IntoIden, T: 'static + IntoIden, A: IntoIden,

pub fn from_subquery<T>( &mut self, query: SelectStatement, alias: T) -> &mut SelectStatement where T: IntoIden,

pub fn left_join<R, C>( &mut self, tbl_ref: R, condition: C) -> &mut SelectStatement where R: IntoTableRef, C: IntoCondition,

pub fn inner_join<R, C>( &mut self, tbl_ref: R, condition: C) -> &mut SelectStatement where R: IntoTableRef, C: IntoCondition,

pub fn join<R, C>( &mut self, join: JoinType, tbl_ref: R, condition: C) -> &mut SelectStatement where R: IntoTableRef, C: IntoCondition,

pub fn join_as<R, A, C>( &mut self, join: JoinType, tbl_ref: R, alias: A, condition: C) -> &mut SelectStatement where R: IntoTableRef, A: IntoIden, C: IntoCondition,

pub fn join_alias<R, A, C>( &mut self, join: JoinType, tbl_ref: R, alias: A, condition: C) -> &mut SelectStatement where R: IntoTableRef, A: IntoIden, C: IntoCondition,

pub fn join_subquery<T, C>( &mut self, join: JoinType, query: SelectStatement, alias: T, condition: C) -> &mut SelectStatement where T: IntoIden, C: IntoCondition,

pub fn join_lateral<T, C>( &mut self, join: JoinType, query: SelectStatement, alias: T, condition: C) -> &mut SelectStatement where T: IntoIden, C: IntoCondition,

pub fn group_by_columns<T, I>(&mut self, cols: I) -> &mut SelectStatement where T: IntoColumnRef, I: IntoIterator<Item = T>,

pub fn group_by_col<T>(&mut self, col: T) -> &mut SelectStatement where T: IntoColumnRef,

pub fn group_by_table_columns<T, C>( &mut self, cols: Vec<(T, C), Global>) -> &mut SelectStatement where T: IntoIden, C: IntoIden,

pub fn add_group_by<I>(&mut self, expr: I) -> &mut SelectStatement where I: IntoIterator<Item = SimpleExpr>,

pub fn cond_having<C>(&mut self, condition: C) -> &mut SelectStatement where C: IntoCondition,

pub fn and_having(&mut self, other: SimpleExpr) -> &mut SelectStatement

pub fn or_having(&mut self, other: SimpleExpr) -> &mut SelectStatement

pub fn limit(&mut self, limit: u64) -> &mut SelectStatement

pub fn reset_limit(&mut self) -> &mut SelectStatement

pub fn offset(&mut self, offset: u64) -> &mut SelectStatement

pub fn reset_offset(&mut self) -> &mut SelectStatement

pub fn lock(&mut self, type: LockType) -> &mut SelectStatement

pub fn lock_with_tables<T, I>( &mut self, type: LockType, tables: I) -> &mut SelectStatement where T: IntoTableRef, I: IntoIterator<Item = T>,

pub fn lock_with_behavior( &mut self, type: LockType, behavior: LockBehavior) -> &mut SelectStatement

pub fn lock_with_tables_behavior<T, I>( &mut self, type: LockType, tables: I, behavior: LockBehavior) -> &mut SelectStatement where T: IntoTableRef, I: IntoIterator<Item = T>,

pub fn lock_shared(&mut self) -> &mut SelectStatement

pub fn lock_exclusive(&mut self) -> &mut SelectStatement

pub fn union( &mut self, union_type: UnionType, query: SelectStatement) -> &mut SelectStatement

pub fn unions<T>(&mut self, unions: T) -> &mut SelectStatement where T: IntoIterator<Item = (UnionType, SelectStatement)>,

pub fn with(self, clause: WithClause) -> WithQuery

pub fn window<A>( &mut self, name: A, window: WindowStatement) -> &mut SelectStatement where A: IntoIden,

impl SelectStatement

pub fn to_string<T>(&self, query_builder: T) -> String where T: QueryBuilder,

pub fn build<T>(&self, query_builder: T) -> (String, Values) where T: QueryBuilder,

pub fn build_any(&self, query_builder: &dyn QueryBuilder) -> (String, Values)

impl SelectStatement

pub fn order_by<T>(&mut self, col: T, order: Order) -> &mut SelectStatement where T: IntoColumnRef,

pub fn order_by_tbl<T, C>( &mut self, table: T, col: C, order: Order) -> &mut SelectStatement where T: IntoIden, C: IntoIden,

pub fn order_by_expr( &mut self, expr: SimpleExpr, order: Order) -> &mut SelectStatement

pub fn order_by_customs<T>( &mut self, cols: Vec<(T, Order), Global>) -> &mut SelectStatement where T: ToString,

pub fn order_by_columns<T>( &mut self, cols: Vec<(T, Order), Global>) -> &mut SelectStatement where T: IntoColumnRef,

pub fn order_by_table_columns<T, C>( &mut self, cols: Vec<(T, C, Order), Global>) -> &mut SelectStatement where T: IntoIden, C: IntoIden,

impl SelectStatement

pub fn and_where(&mut self, other: SimpleExpr) -> &mut SelectStatement

pub fn and_where_option( &mut self, other: Option<SimpleExpr>) -> &mut SelectStatement

pub fn or_where(&mut self, other: SimpleExpr) -> &mut SelectStatement

pub fn cond_where<C>(&mut self, condition: C) -> &mut SelectStatement where C: IntoCondition,

Trait Implementations

impl Clone for SelectStatement

fn clone(&self) -> SelectStatement

fn clone_from(&mut self, source: &Self)

impl ConditionalStatement for SelectStatement

fn cond_where<C>(&mut self, condition: C) -> &mut SelectStatement where C: IntoCondition,

fn and_where(&mut self, other: SimpleExpr) -> &mut Self

pub fn conditions<T, F>(
&mut self,
b: bool,
if_true: T,
if_false: F
) -> &mut SelectStatement where
T: FnOnce(&mut SelectStatement),
F: FnOnce(&mut SelectStatement),

pub fn expr<T>(&mut self, expr: T) -> &mut SelectStatement where
T: Into<SelectExpr>,

pub fn exprs<T, I>(&mut self, exprs: I) -> &mut SelectStatement where
T: Into<SelectExpr>,
I: IntoIterator<Item = T>,

pub fn exprs_mut_for_each<F>(&mut self, func: F) where
F: FnMut(&mut SelectExpr),

pub fn distinct_on<T, I>(&mut self, cols: I) -> &mut SelectStatement where
T: IntoColumnRef,
I: IntoIterator<Item = T>,

pub fn column<C>(&mut self, col: C) -> &mut SelectStatement where
C: IntoColumnRef,

pub fn table_column<T, C>(&mut self, t: T, c: C) -> &mut SelectStatement where
T: IntoIden,
C: IntoIden,

pub fn columns<T, I>(&mut self, cols: I) -> &mut SelectStatement where
T: IntoColumnRef,
I: IntoIterator<Item = T>,

pub fn table_columns<T, C>(
&mut self,
cols: Vec<(T, C), Global>
) -> &mut SelectStatement where
T: IntoIden,
C: IntoIden,

pub fn expr_as<T, A>(&mut self, expr: T, alias: A) -> &mut SelectStatement where
T: Into<SimpleExpr>,
A: IntoIden,

pub fn expr_alias<T, A>(&mut self, expr: T, alias: A) -> &mut SelectStatement where
T: Into<SimpleExpr>,
A: IntoIden,

pub fn expr_window<T>(
&mut self,
expr: T,
window: WindowStatement
) -> &mut SelectStatement where
T: Into<SimpleExpr>,

pub fn expr_window_as<T, A>(
&mut self,
expr: T,
window: WindowStatement,
alias: A
) -> &mut SelectStatement where
T: Into<SimpleExpr>,
A: IntoIden,

pub fn expr_window_name<T, W>(
&mut self,
expr: T,
window: W
) -> &mut SelectStatement where
T: Into<SimpleExpr>,
W: IntoIden,

pub fn expr_window_name_as<T, W, A>(
&mut self,
expr: T,
window: W,
alias: A
) -> &mut SelectStatement where
T: Into<SimpleExpr>,
A: IntoIden,
W: IntoIden,

pub fn from<R>(&mut self, tbl_ref: R) -> &mut SelectStatement where
R: IntoTableRef,

pub fn from_values<I, V, A>(
&mut self,
value_tuples: I,
alias: A
) -> &mut SelectStatement where
I: IntoIterator<Item = V>,
V: IntoValueTuple,
A: IntoIden,

pub fn from_schema<S, T>(&mut self, schema: S, table: T) -> &mut SelectStatement where
S: 'static + IntoIden,
T: 'static + IntoIden,

pub fn from_as<R, A>(&mut self, tbl_ref: R, alias: A) -> &mut SelectStatement where
R: IntoTableRef,
A: IntoIden,

pub fn from_alias<R, A>(&mut self, tbl_ref: R, alias: A) -> &mut SelectStatement where
R: IntoTableRef,
A: IntoIden,

pub fn from_schema_as<S, T, A>(
&mut self,
schema: S,
table: T,
alias: A
) -> &mut SelectStatement where
S: 'static + IntoIden,
T: 'static + IntoIden,
A: IntoIden,

pub fn from_subquery<T>(
&mut self,
query: SelectStatement,
alias: T
) -> &mut SelectStatement where
T: IntoIden,

pub fn left_join<R, C>(
&mut self,
tbl_ref: R,
condition: C
) -> &mut SelectStatement where
R: IntoTableRef,
C: IntoCondition,

pub fn inner_join<R, C>(
&mut self,
tbl_ref: R,
condition: C
) -> &mut SelectStatement where
R: IntoTableRef,
C: IntoCondition,

pub fn join<R, C>(
&mut self,
join: JoinType,
tbl_ref: R,
condition: C
) -> &mut SelectStatement where
R: IntoTableRef,
C: IntoCondition,

pub fn join_as<R, A, C>(
&mut self,
join: JoinType,
tbl_ref: R,
alias: A,
condition: C
) -> &mut SelectStatement where
R: IntoTableRef,
A: IntoIden,
C: IntoCondition,

pub fn join_alias<R, A, C>(
&mut self,
join: JoinType,
tbl_ref: R,
alias: A,
condition: C
) -> &mut SelectStatement where
R: IntoTableRef,
A: IntoIden,
C: IntoCondition,

pub fn join_subquery<T, C>(
&mut self,
join: JoinType,
query: SelectStatement,
alias: T,
condition: C
) -> &mut SelectStatement where
T: IntoIden,
C: IntoCondition,

pub fn join_lateral<T, C>(
&mut self,
join: JoinType,
query: SelectStatement,
alias: T,
condition: C
) -> &mut SelectStatement where
T: IntoIden,
C: IntoCondition,

pub fn group_by_columns<T, I>(&mut self, cols: I) -> &mut SelectStatement where
T: IntoColumnRef,
I: IntoIterator<Item = T>,

pub fn group_by_col<T>(&mut self, col: T) -> &mut SelectStatement where
T: IntoColumnRef,

pub fn group_by_table_columns<T, C>(
&mut self,
cols: Vec<(T, C), Global>
) -> &mut SelectStatement where
T: IntoIden,
C: IntoIden,

pub fn add_group_by<I>(&mut self, expr: I) -> &mut SelectStatement where
I: IntoIterator<Item = SimpleExpr>,

pub fn cond_having<C>(&mut self, condition: C) -> &mut SelectStatement where
C: IntoCondition,

pub fn lock_with_tables<T, I>(
&mut self,
type: LockType,
tables: I
) -> &mut SelectStatement where
T: IntoTableRef,
I: IntoIterator<Item = T>,

pub fn lock_with_behavior(
&mut self,
type: LockType,
behavior: LockBehavior
) -> &mut SelectStatement

pub fn lock_with_tables_behavior<T, I>(
&mut self,
type: LockType,
tables: I,
behavior: LockBehavior
) -> &mut SelectStatement where
T: IntoTableRef,
I: IntoIterator<Item = T>,

pub fn union(
&mut self,
union_type: UnionType,
query: SelectStatement
) -> &mut SelectStatement

pub fn unions<T>(&mut self, unions: T) -> &mut SelectStatement where
T: IntoIterator<Item = (UnionType, SelectStatement)>,

pub fn window<A>(
&mut self,
name: A,
window: WindowStatement
) -> &mut SelectStatement where
A: IntoIden,

pub fn to_string<T>(&self, query_builder: T) -> String where
T: QueryBuilder,

pub fn build<T>(&self, query_builder: T) -> (String, Values) where
T: QueryBuilder,

pub fn order_by<T>(&mut self, col: T, order: Order) -> &mut SelectStatement where
T: IntoColumnRef,

pub fn order_by_tbl<T, C>(
&mut self,
table: T,
col: C,
order: Order
) -> &mut SelectStatement where
T: IntoIden,
C: IntoIden,

pub fn order_by_expr(
&mut self,
expr: SimpleExpr,
order: Order
) -> &mut SelectStatement

pub fn order_by_customs<T>(
&mut self,
cols: Vec<(T, Order), Global>
) -> &mut SelectStatement where
T: ToString,

pub fn order_by_columns<T>(
&mut self,
cols: Vec<(T, Order), Global>
) -> &mut SelectStatement where
T: IntoColumnRef,

pub fn order_by_table_columns<T, C>(
&mut self,
cols: Vec<(T, C, Order), Global>
) -> &mut SelectStatement where
T: IntoIden,
C: IntoIden,

pub fn and_where_option(
&mut self,
other: Option<SimpleExpr>
) -> &mut SelectStatement

pub fn cond_where<C>(&mut self, condition: C) -> &mut SelectStatement where
C: IntoCondition,

fn cond_where<C>(&mut self, condition: C) -> &mut SelectStatement where
C: IntoCondition,

fn order_by<T>(&mut self, col: T, order: Order) -> &mut Self where
T: IntoColumnRef,

fn order_by_tbl<T, C>(&mut self, table: T, col: C, order: Order) -> &mut Self where
T: IntoIden,
C: IntoIden,

fn order_by_customs<T>(&mut self, cols: Vec<(T, Order), Global>) -> &mut Self where
T: ToString,

fn order_by_columns<T>(&mut self, cols: Vec<(T, Order), Global>) -> &mut Self where
T: IntoColumnRef,

fn order_by_table_columns<T, C>(
&mut self,
cols: Vec<(T, C, Order), Global>
) -> &mut Self where
T: IntoIden,
C: IntoIden,

fn order_by_with_nulls<T>(
&mut self,
col: T,
order: Order,
nulls: NullOrdering
) -> &mut Self where
T: IntoColumnRef,

fn order_by_expr_with_nulls(
&mut self,
expr: SimpleExpr,
order: Order,
nulls: NullOrdering
) -> &mut Self

fn order_by_customs_with_nulls<T>(
&mut self,
cols: Vec<(T, Order, NullOrdering), Global>
) -> &mut Self where
T: ToString,

fn order_by_columns_with_nulls<T>(
&mut self,
cols: Vec<(T, Order, NullOrdering), Global>
) -> &mut Self where
T: IntoColumnRef,

fn build_collect_any_into(
&self,
query_builder: &dyn QueryBuilder,
sql: &mut SqlWriter,
collector: &mut dyn FnMut(Value)
)

fn build_collect_any(
&self,
query_builder: &dyn QueryBuilder,
collector: &mut dyn FnMut(Value)
) -> String