SelectStatement

netmito::migration

Struct SelectStatement 

Source 
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::col((Char::Table, Char::FontId)).equals((Font::Table, Font::Id)))
    .and_where(Expr::col(Char::SizeW).is_in([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§

Source§

impl SelectStatement

Source

pub fn new() -> SelectStatement

Construct a new SelectStatement

Source

pub fn take(&mut self) -> SelectStatement

Take the ownership of data in the current SelectStatement

Source

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

pub fn apply_if<T, F>( &mut self, val: Option<T>, if_some: F, ) -> &mut SelectStatement
where SelectStatement: Sized, F: FnOnce(&mut SelectStatement, T),

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)
    .apply_if(Some(5), |q, v| {
        q.and_where(Expr::col(Char::FontId).eq(v));
    })
    .to_owned();

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

pub fn apply<F>(&mut self, func: F) -> &mut SelectStatement
where F: FnOnce(&mut SelectStatement),

Construct part of the select statement in another function.

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

let common_expr = |q: &mut SelectStatement| {
    q.and_where(Expr::col(Char::FontId).eq(5));
};

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

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

Clear the select list

Source

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

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([
        Expr::col(Char::Id).max(),
        (1..10_i32).fold(Expr::value(0), |expr, i| expr.add(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""#
);
Source

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

Source

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

Select distinct

Source

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([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 query = Query::select()
    .from(Char::Table)
    .distinct_on(vec![(Char::Table, 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") "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""#
)
Source

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

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

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

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

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

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), "w")
    .window("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")"#
);
Source

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), "w", "C")
    .window("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")"#
);
Source

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(("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 = Query::select()
    .expr(Expr::asterisk())
    .from(Char::Table)
    .from(Font::Table)
    .and_where(Expr::col((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""#
);
Source

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 = Query::select()
    .expr(Expr::asterisk())
    .from_values([(1, "hello"), (2, "world")], "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""#
);
Source

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("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";

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

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

pub fn from_function<T>( &mut self, func: FunctionCall, alias: T, ) -> &mut SelectStatement
where T: IntoIden,

From function call.

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

let query = Query::select()
    .column(ColumnRef::Asterisk)
    .from_function(Func::random(), "func")
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT * FROM RAND() AS `func`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT * FROM RANDOM() AS "func""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT * FROM RANDOM() AS "func""#
);
Source

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

Clears all current from clauses.

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

let query = Query::select()
    .column(ColumnRef::Asterisk)
    .from(Char::Table)
    .from_clear()
    .from(Font::Table)
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT * FROM `font`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT * FROM "font""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT * FROM "font""#
);
Source

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

Cross join.

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

let query = Query::select()
    .column(Char::Character)
    .column((Font::Table, Font::Name))
    .from(Char::Table)
    .cross_join(Font::Table, Expr::col((Char::Table, Char::FontId)).equals((Font::Table, Font::Id)))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `font`.`name` FROM `character` CROSS JOIN `font` ON `character`.`font_id` = `font`.`id`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "font"."name" FROM "character" CROSS JOIN "font" ON "character"."font_id" = "font"."id""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "font"."name" FROM "character" CROSS JOIN "font" ON "character"."font_id" = "font"."id""#
);

// Constructing chained join conditions
let query = Query::select()
        .column(Char::Character)
        .column((Font::Table, Font::Name))
        .from(Char::Table)
        .cross_join(
            Font::Table,
            all![
                Expr::col((Char::Table, Char::FontId)).equals((Font::Table, Font::Id)),
                Expr::col((Char::Table, Char::FontId)).equals((Font::Table, Font::Id)),
            ]
        )
        .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `font`.`name` FROM `character` CROSS JOIN `font` ON `character`.`font_id` = `font`.`id` AND `character`.`font_id` = `font`.`id`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "font"."name" FROM "character" CROSS JOIN "font" ON "character"."font_id" = "font"."id" AND "character"."font_id" = "font"."id""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "font"."name" FROM "character" CROSS JOIN "font" ON "character"."font_id" = "font"."id" AND "character"."font_id" = "font"."id""#
);
Source

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::col((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
let query = Query::select()
        .column(Char::Character)
        .column((Font::Table, Font::Name))
        .from(Char::Table)
        .left_join(
            Font::Table,
            all![
                Expr::col((Char::Table, Char::FontId)).equals((Font::Table, Font::Id)),
                Expr::col((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` AND `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" AND "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" AND "character"."font_id" = "font"."id""#
);
Source

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

Right join.

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

let query = Query::select()
    .column(Char::Character)
    .column((Font::Table, Font::Name))
    .from(Char::Table)
    .right_join(Font::Table, Expr::col((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
let query = Query::select()
        .column(Char::Character)
        .column((Font::Table, Font::Name))
        .from(Char::Table)
        .right_join(
            Font::Table,
            all![
                Expr::col((Char::Table, Char::FontId)).equals((Font::Table, Font::Id)),
                Expr::col((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` AND `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" AND "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" AND "character"."font_id" = "font"."id""#
);
Source

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::col((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
let query = Query::select()
        .column(Char::Character)
        .column((Font::Table, Font::Name))
        .from(Char::Table)
        .inner_join(
            Font::Table,
            all![
                Expr::col((Char::Table, Char::FontId)).equals((Font::Table, Font::Id)),
                Expr::col((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` AND `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" AND "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" AND "character"."font_id" = "font"."id""#
);
Source

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

Full outer join.

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

let query = Query::select()
    .column(Char::Character)
    .column((Font::Table, Font::Name))
    .from(Char::Table)
    .full_outer_join(Font::Table, Expr::col((Char::Table, Char::FontId)).equals((Font::Table, Font::Id)))
    .to_owned();

assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "font"."name" FROM "character" FULL OUTER JOIN "font" ON "character"."font_id" = "font"."id""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "font"."name" FROM "character" FULL OUTER JOIN "font" ON "character"."font_id" = "font"."id""#
);

// Constructing chained join conditions
let query = Query::select()
        .column(Char::Character)
        .column((Font::Table, Font::Name))
        .from(Char::Table)
        .full_outer_join(
            Font::Table,
            all![
                Expr::col((Char::Table, Char::FontId)).equals((Font::Table, Font::Id)),
                Expr::col((Char::Table, Char::FontId)).equals((Font::Table, Font::Id)),
            ]
        )
        .to_owned();

assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "font"."name" FROM "character" FULL OUTER JOIN "font" ON "character"."font_id" = "font"."id" AND "character"."font_id" = "font"."id""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "font"."name" FROM "character" FULL OUTER JOIN "font" ON "character"."font_id" = "font"."id" AND "character"."font_id" = "font"."id""#
);
Source

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::col((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
let query = Query::select()
        .column(Char::Character)
        .column((Font::Table, Font::Name))
        .from(Char::Table)
        .join(
            JoinType::RightJoin,
            Font::Table,
            all![
                Expr::col((Char::Table, Char::FontId)).equals((Font::Table, Font::Id)),
                Expr::col((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` AND `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" AND "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" AND "character"."font_id" = "font"."id""#
);
Source

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,
        "f",
        Expr::col((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,
            "f",
            Condition::all()
                .add(Expr::col((Char::Table, Char::FontId)).equals((Font::Table, Font::Id)))
                .add(Expr::col((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`"#
);
Source

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("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::col((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::col((Font::Table, Font::Id)).equals((sub_glyph.clone(), Glyph::Id)))
                .add(Expr::col((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`"#
);
Source

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("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::col((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::col((Font::Table, Font::Id)).equals((sub_glyph.clone(), Glyph::Id)))
                .add(Expr::col((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`"#
);
Source

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::col((Char::Table, Char::FontId)).equals((Font::Table, Font::Id)))
    .group_by_columns([
        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::col((Char::Table, Char::FontId)).equals((Font::Table, Font::Id)))
    .group_by_columns([
        (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""#
);
Source

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::col((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""#
);
Source

pub fn add_group_by<I>(&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([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""#
);
Source

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([
        Glyph::Aspect,
    ])
    .cond_having(
        all![
            Expr::col((Glyph::Table, Glyph::Aspect)).is_in([3, 4]),
            any![
                Expr::col((Glyph::Table, Glyph::Image)).like("A%"),
                Expr::col((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%')"#
);
Source

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

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

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

Reset limit

Source

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

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

Reset offset

Source

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

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

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

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

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

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

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

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

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("id")
                    .expr(1i32)
                    .column("next")
                    .column("value")
                    .from("table")
                    .to_owned();

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

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

let select = SelectStatement::new()
        .column(ColumnRef::Asterisk)
        .from("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("id".into_iden())), "looped", "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""#
);
Source

pub fn with_cte<C>(&mut self, clause: C) -> &mut SelectStatement
where C: Into<WithClause>,

Create a Common Table Expression by specifying a [CommonTableExpression] or WithClause to execute this query with.

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

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

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

let common_table_expression = CommonTableExpression::new()
            .query(
                base_query.clone().union(UnionType::All, cte_referencing).to_owned()
            )
            .columns(["id", "depth", "next", "value"])
            .table_name("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("id".into_iden())), "looped", "traversal_path"))
        .to_owned();

let query = SelectStatement::new()
        .column(ColumnRef::Asterisk)
        .from("cte_traversal")
        .with_cte(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""#
);
Source

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), "w", "C")
    .window("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")"#
);
Source§

impl SelectStatement

Source

pub fn build_collect_any_into( &self, query_builder: &dyn QueryBuilder, sql: &mut dyn SqlWriter, )

See QueryStatementBuilder::build_collect_any_into

Source

pub fn into_sub_query_statement(self) -> SubQueryStatement

See QueryStatementBuilder::into_sub_query_statement

Source

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

See QueryStatementBuilder::build_any

Source

pub fn build_collect_any( &self, query_builder: &dyn QueryBuilder, sql: &mut dyn SqlWriter, ) -> String

See QueryStatementBuilder::build_collect_any

Source§

impl SelectStatement

Source

pub fn build_collect_into<T>(&self, query_builder: T, sql: &mut dyn SqlWriter)
where T: QueryBuilder,

See QueryStatementWriter::build_collect_into

Source

pub fn build_collect<T>( &self, query_builder: T, sql: &mut dyn SqlWriter, ) -> String
where T: QueryBuilder,

See QueryStatementWriter::build_collect

Source

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

See QueryStatementWriter::build

Source

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

See QueryStatementWriter::to_string

Source§

impl SelectStatement

Source

pub fn add_order_by(&mut self, order: OrderExpr) -> &mut SelectStatement

See OrderedStatement::add_order_by

Source

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

See OrderedStatement::clear_order_by

Source

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

See OrderedStatement::order_by

Source

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

See OrderedStatement::order_by_expr

Source

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

See OrderedStatement::order_by_customs

Source

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

See OrderedStatement::order_by_columns

Source

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

See OrderedStatement::order_by_with_nulls

Source

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

See OrderedStatement::order_by_expr_with_nulls

Source

pub fn order_by_customs_with_nulls<I, T>( &mut self, cols: I, ) -> &mut SelectStatement
where T: ToString, I: IntoIterator<Item = (T, Order, NullOrdering)>,

See OrderedStatement::order_by_customs_with_nulls

Source

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

See OrderedStatement::order_by_columns_with_nulls

Source§

impl SelectStatement

Source

pub fn and_or_where( &mut self, condition: LogicalChainOper, ) -> &mut SelectStatement

See ConditionalStatement::and_or_where

Source

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

See ConditionalStatement::cond_where

Source

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

See ConditionalStatement::and_where_option

Source

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

See ConditionalStatement::and_where

Trait Implementations§

Source§

impl Clone for SelectStatement

Source§

fn clone(&self) -> SelectStatement

Returns a duplicate of the value. Read more
1.0.0 · Source§

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

Performs copy-assignment from source. Read more
Source§

impl ConditionalStatement for SelectStatement

Source§

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
Source§

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

And where condition. Calling or_where after and_where will panic. Read more
Source§

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
Source§

impl Debug for SelectStatement

Source§

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

Formats the value using the given formatter. Read more
Source§

impl Default for SelectStatement

Source§

fn default() -> SelectStatement

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

impl MySqlSelectStatementExt for SelectStatement

Source§

fn use_index<I>( &mut self, index: I, scope: IndexHintScope, ) -> &mut SelectStatement
where I: IntoIden,

Use index hint for MySQL

Give the optimizer information about how to choose indexes during query processing. See MySQL reference manual for Index Hints

§Examples
use sea_query::{extension::mysql::*, tests_cfg::*, *};

let query = Query::select()
    .from(Char::Table)
    .use_index(IndexName::new("IDX_123456"), IndexHintScope::All)
    .column(Char::SizeW)
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `size_w` FROM `character` USE INDEX (`IDX_123456`)"#
);
Source§

fn force_index<I>( &mut self, index: I, scope: IndexHintScope, ) -> &mut SelectStatement
where I: IntoIden,

Force index hint for MySQL

Give the optimizer information about how to choose indexes during query processing. See MySQL reference manual for Index Hints

§Examples
use sea_query::{extension::mysql::*, tests_cfg::*, *};

let query = Query::select()
    .from(Char::Table)
    .force_index(IndexName::new("IDX_123456"), IndexHintScope::All)
    .column(Char::SizeW)
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `size_w` FROM `character` FORCE INDEX (`IDX_123456`)"#
);
Source§

fn ignore_index<I>( &mut self, index: I, scope: IndexHintScope, ) -> &mut SelectStatement
where I: IntoIden,

Ignore index hint for MySQL

Give the optimizer information about how to choose indexes during query processing. See MySQL reference manual for Index Hints

§Examples
use sea_query::{extension::mysql::*, tests_cfg::*, *};

let query = Query::select()
    .from(Char::Table)
    .ignore_index(IndexName::new("IDX_123456"), IndexHintScope::All)
    .column(Char::SizeW)
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `size_w` FROM `character` IGNORE INDEX (`IDX_123456`)"#
)
Source§

impl OrderedStatement for SelectStatement

Source§

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

Clear order expressions
Source§

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

Order by column. Read more
Source§

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

Order by SimpleExpr.
Source§

fn order_by_customs<I, T>(&mut self, cols: I) -> &mut Self
where T: ToString, I: IntoIterator<Item = (T, Order)>,

Order by custom string.
Source§

fn order_by_columns<I, T>(&mut self, cols: I) -> &mut Self
where T: IntoColumnRef, I: IntoIterator<Item = (T, Order)>,

Order by vector of columns.
Source§

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
Source§

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

Order by SimpleExpr with nulls order option.
Source§

fn order_by_customs_with_nulls<I, T>(&mut self, cols: I) -> &mut Self
where T: ToString, I: IntoIterator<Item = (T, Order, NullOrdering)>,

Order by custom string with nulls order option.
Source§

fn order_by_columns_with_nulls<I, T>(&mut self, cols: I) -> &mut Self
where T: IntoColumnRef, I: IntoIterator<Item = (T, Order, NullOrdering)>,

Order by vector of columns with nulls order option.
Source§

impl PartialEq for SelectStatement

Source§

fn eq(&self, other: &SelectStatement) -> bool

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Source§

impl PostgresSelectStatementExt for SelectStatement

Source§

fn table_sample( &mut self, method: SampleMethod, percentage: f64, repeatable: Option<f64>, ) -> &mut SelectStatement

TABLESAMPLE

§Examples
use sea_query::{extension::postgres::*, tests_cfg::*, *};

let query = Query::select()
    .columns([Glyph::Image])
    .from(Glyph::Table)
    .table_sample(SampleMethod::SYSTEM, 50.0, None)
    .to_owned();

assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "image" FROM "glyph" TABLESAMPLE SYSTEM (50)"#
);

let query = Query::select()
    .columns([Glyph::Image])
    .from(Glyph::Table)
    .table_sample(SampleMethod::SYSTEM, 50.0, Some(3.14))
    .to_owned();

assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "image" FROM "glyph" TABLESAMPLE SYSTEM (50) REPEATABLE (3.14)"#
);
Source§

impl QueryStatementBuilder for SelectStatement

Source§

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

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

fn into_sub_query_statement(self) -> SubQueryStatement

Source§

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
Source§

fn build_collect_any( &self, query_builder: &dyn QueryBuilder, sql: &mut dyn SqlWriter, ) -> String

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

impl QueryStatementWriter for SelectStatement

Source§

fn build_collect_into<T>(&self, query_builder: T, sql: &mut dyn SqlWriter)
where T: QueryBuilder,

Source§

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
Source§

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§

fn build_collect<T>(&self, query_builder: T, sql: &mut dyn SqlWriter) -> String
where T: QueryBuilder,

Build corresponding SQL statement for certain database backend and collect query parameters Read more
Source§

impl SqlxBinder for SelectStatement

Source§

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

Source§

fn build_any_sqlx( &self, query_builder: &dyn QueryBuilder, ) -> (String, SqlxValues)

Source§

impl StatementBuilder for SelectStatement

Source§

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

Method to call in order to build a Statement
Source§

impl StructuralPartialEq for SelectStatement

Auto Trait Implementations§

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,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

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

Source§

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

Mutably borrows from an owned value. Read more
Source§

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

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

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

Source§

fn from_ref(input: &T) -> T

Converts to this type from a reference to the input type.
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<U> for T
where U: From<T>,

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> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<Unshared, Shared> IntoShared<Shared> for Unshared
where Shared: FromUnshared<Unshared>,

Source§

fn into_shared(self) -> Shared

Creates a shared type from an unshared type.
Source§

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

Source§

fn fg(&self, value: Color) -> Painted<&T>

Returns a styled value derived from self with the foreground set to value.

This method should be used rarely. Instead, prefer to use color-specific builder methods like red() and green(), which have the same functionality but are pithier.

§Example

Set foreground color to white using fg():

use yansi::{Paint, Color};

painted.fg(Color::White);

Set foreground color to white using white().

use yansi::Paint;

painted.white();
Source§

fn primary(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Primary].

§Example
println!("{}", value.primary());
Source§

fn fixed(&self, color: u8) -> Painted<&T>

Returns self with the fg() set to [Color :: Fixed].

§Example
println!("{}", value.fixed(color));
Source§

fn rgb(&self, r: u8, g: u8, b: u8) -> Painted<&T>

Returns self with the fg() set to [Color :: Rgb].

§Example
println!("{}", value.rgb(r, g, b));
Source§

fn black(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Black].

§Example
println!("{}", value.black());
Source§

fn red(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Red].

§Example
println!("{}", value.red());
Source§

fn green(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Green].

§Example
println!("{}", value.green());
Source§

fn yellow(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Yellow].

§Example
println!("{}", value.yellow());
Source§

fn blue(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Blue].

§Example
println!("{}", value.blue());
Source§

fn magenta(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Magenta].

§Example
println!("{}", value.magenta());
Source§

fn cyan(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Cyan].

§Example
println!("{}", value.cyan());
Source§

fn white(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: White].

§Example
println!("{}", value.white());
Source§

fn bright_black(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightBlack].

§Example
println!("{}", value.bright_black());
Source§

fn bright_red(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightRed].

§Example
println!("{}", value.bright_red());
Source§

fn bright_green(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightGreen].

§Example
println!("{}", value.bright_green());
Source§

fn bright_yellow(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightYellow].

§Example
println!("{}", value.bright_yellow());
Source§

fn bright_blue(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightBlue].

§Example
println!("{}", value.bright_blue());
Source§

fn bright_magenta(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightMagenta].

§Example
println!("{}", value.bright_magenta());
Source§

fn bright_cyan(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightCyan].

§Example
println!("{}", value.bright_cyan());
Source§

fn bright_white(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightWhite].

§Example
println!("{}", value.bright_white());
Source§

fn bg(&self, value: Color) -> Painted<&T>

Returns a styled value derived from self with the background set to value.

This method should be used rarely. Instead, prefer to use color-specific builder methods like on_red() and on_green(), which have the same functionality but are pithier.

§Example

Set background color to red using fg():

use yansi::{Paint, Color};

painted.bg(Color::Red);

Set background color to red using on_red().

use yansi::Paint;

painted.on_red();
Source§

fn on_primary(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Primary].

§Example
println!("{}", value.on_primary());
Source§

fn on_fixed(&self, color: u8) -> Painted<&T>

Returns self with the bg() set to [Color :: Fixed].

§Example
println!("{}", value.on_fixed(color));
Source§

fn on_rgb(&self, r: u8, g: u8, b: u8) -> Painted<&T>

Returns self with the bg() set to [Color :: Rgb].

§Example
println!("{}", value.on_rgb(r, g, b));
Source§

fn on_black(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Black].

§Example
println!("{}", value.on_black());
Source§

fn on_red(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Red].

§Example
println!("{}", value.on_red());
Source§

fn on_green(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Green].

§Example
println!("{}", value.on_green());
Source§

fn on_yellow(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Yellow].

§Example
println!("{}", value.on_yellow());
Source§

fn on_blue(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Blue].

§Example
println!("{}", value.on_blue());
Source§

fn on_magenta(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Magenta].

§Example
println!("{}", value.on_magenta());
Source§

fn on_cyan(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Cyan].

§Example
println!("{}", value.on_cyan());
Source§

fn on_white(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: White].

§Example
println!("{}", value.on_white());
Source§

fn on_bright_black(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightBlack].

§Example
println!("{}", value.on_bright_black());
Source§

fn on_bright_red(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightRed].

§Example
println!("{}", value.on_bright_red());
Source§

fn on_bright_green(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightGreen].

§Example
println!("{}", value.on_bright_green());
Source§

fn on_bright_yellow(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightYellow].

§Example
println!("{}", value.on_bright_yellow());
Source§

fn on_bright_blue(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightBlue].

§Example
println!("{}", value.on_bright_blue());
Source§

fn on_bright_magenta(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightMagenta].

§Example
println!("{}", value.on_bright_magenta());
Source§

fn on_bright_cyan(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightCyan].

§Example
println!("{}", value.on_bright_cyan());
Source§

fn on_bright_white(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightWhite].

§Example
println!("{}", value.on_bright_white());
Source§

fn attr(&self, value: Attribute) -> Painted<&T>

Enables the styling Attribute value.

This method should be used rarely. Instead, prefer to use attribute-specific builder methods like bold() and underline(), which have the same functionality but are pithier.

§Example

Make text bold using attr():

use yansi::{Paint, Attribute};

painted.attr(Attribute::Bold);

Make text bold using using bold().

use yansi::Paint;

painted.bold();
Source§

fn bold(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Bold].

§Example
println!("{}", value.bold());
Source§

fn dim(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Dim].

§Example
println!("{}", value.dim());
Source§

fn italic(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Italic].

§Example
println!("{}", value.italic());
Source§

fn underline(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Underline].

§Example
println!("{}", value.underline());

Returns self with the attr() set to [Attribute :: Blink].

§Example
println!("{}", value.blink());

Returns self with the attr() set to [Attribute :: RapidBlink].

§Example
println!("{}", value.rapid_blink());
Source§

fn invert(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Invert].

§Example
println!("{}", value.invert());
Source§

fn conceal(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Conceal].

§Example
println!("{}", value.conceal());
Source§

fn strike(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Strike].

§Example
println!("{}", value.strike());
Source§

fn quirk(&self, value: Quirk) -> Painted<&T>

Enables the yansi Quirk value.

This method should be used rarely. Instead, prefer to use quirk-specific builder methods like mask() and wrap(), which have the same functionality but are pithier.

§Example

Enable wrapping using .quirk():

use yansi::{Paint, Quirk};

painted.quirk(Quirk::Wrap);

Enable wrapping using wrap().

use yansi::Paint;

painted.wrap();
Source§

fn mask(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk :: Mask].

§Example
println!("{}", value.mask());
Source§

fn wrap(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk :: Wrap].

§Example
println!("{}", value.wrap());
Source§

fn linger(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk :: Linger].

§Example
println!("{}", value.linger());
Source§

fn clear(&self) -> Painted<&T>

👎Deprecated since 1.0.1: renamed to resetting() due to conflicts with Vec::clear(). The clear() method will be removed in a future release.

Returns self with the quirk() set to [Quirk :: Clear].

§Example
println!("{}", value.clear());
Source§

fn resetting(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk :: Resetting].

§Example
println!("{}", value.resetting());
Source§

fn bright(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk :: Bright].

§Example
println!("{}", value.bright());
Source§

fn on_bright(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk :: OnBright].

§Example
println!("{}", value.on_bright());
Source§

fn whenever(&self, value: Condition) -> Painted<&T>

Conditionally enable styling based on whether the Condition value applies. Replaces any previous condition.

See the crate level docs for more details.

§Example

Enable styling painted only when both stdout and stderr are TTYs:

use yansi::{Paint, Condition};

painted.red().on_yellow().whenever(Condition::STDOUTERR_ARE_TTY);
Source§

fn new(self) -> Painted<Self>
where Self: Sized,

Create a new Painted with a default Style. Read more
Source§

fn paint<S>(&self, style: S) -> Painted<&Self>
where S: Into<Style>,

Apply a style wholesale to self. Any previous style is replaced. Read more
Source§

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

Source§

fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns Action::Follow only if self and other return Action::Follow. Read more
Source§

fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns Action::Follow if either self or other returns Action::Follow. Read more
Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

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

Source§

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<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

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

Performs the conversion.
Source§

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

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

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

Performs the conversion.
Source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V

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
Source§

impl<T> ErasedDestructor for T
where T: 'static,