Enum Func 

#[non_exhaustive]
pub enum Func {
    Max,
    Min,
    Sum,
    Avg,
    Abs,
    Count,
    IfNull,
    Greatest,
    Least,
    CharLength,
    Cast,
    Custom(DynIden),
    Coalesce,
    Lower,
    Upper,
    BitAnd,
    BitOr,
    Random,
    Round,
    Md5,
    MsFunction(MsFunction),
    PgFunction(PgFunc),
}

Known SQL functions.

If something is not supported here, you can use Function::Custom.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Max

Min

Sum

Avg

Abs

Count

IfNull

Greatest

Least

CharLength

Cast

Custom(DynIden)

Coalesce

Lower

Upper

BitAnd

BitOr

Random

Round

Md5

MsFunction(MsFunction)

PgFunction(PgFunc)

Implementations

impl Func

pub fn cust<T>(func: T) -> FunctionCall

where T: IntoIden,

Call a custom function.

Examples

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

#[derive(Iden)]
#[iden = "MY_FUNCTION"]
struct MyFunction;

let query = Query::select()
    .expr(Func::cust(MyFunction).arg("hello"))
    .to_owned();

assert_eq!(
    query.to_string(MsSqlQueryBuilder),
    r#"SELECT MY_FUNCTION('hello')"#
);
assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT MY_FUNCTION('hello')"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT MY_FUNCTION('hello')"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT MY_FUNCTION('hello')"#
);

pub fn max<T>(expr: T) -> FunctionCall

where T: Into<Expr>,

Call MAX function.

Examples

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

let query = Query::select()
    .expr(Func::max(Expr::col((Char::Table, Char::SizeW))))
    .from(Char::Table)
    .to_owned();

assert_eq!(
    query.to_string(MsSqlQueryBuilder),
    r#"SELECT MAX([character].[size_w]) FROM [character]"#
);
assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT MAX(`character`.`size_w`) FROM `character`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT MAX("character"."size_w") FROM "character""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT MAX("character"."size_w") FROM "character""#
);

pub fn min<T>(expr: T) -> FunctionCall

where T: Into<Expr>,

Call MIN function.

Examples

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

let query = Query::select()
    .expr(Func::min(Expr::col((Char::Table, Char::SizeH))))
    .from(Char::Table)
    .to_owned();

assert_eq!(
    query.to_string(MsSqlQueryBuilder),
    r#"SELECT MIN([character].[size_h]) FROM [character]"#
);
assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT MIN(`character`.`size_h`) FROM `character`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT MIN("character"."size_h") FROM "character""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT MIN("character"."size_h") FROM "character""#
);

pub fn sum<T>(expr: T) -> FunctionCall

where T: Into<Expr>,

Call SUM function.

Examples

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

let query = Query::select()
    .expr(Func::sum(Expr::col((Char::Table, Char::SizeH))))
    .from(Char::Table)
    .to_owned();

assert_eq!(
    query.to_string(MsSqlQueryBuilder),
    r#"SELECT SUM([character].[size_h]) FROM [character]"#
);
assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT SUM(`character`.`size_h`) FROM `character`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT SUM("character"."size_h") FROM "character""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT SUM("character"."size_h") FROM "character""#
);

pub fn avg<T>(expr: T) -> FunctionCall

where T: Into<Expr>,

Call AVG function for average.

Examples

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

let query = Query::select()
    .expr(Func::avg(Expr::col((Char::Table, Char::SizeH))))
    .from(Char::Table)
    .to_owned();

assert_eq!(
    query.to_string(MsSqlQueryBuilder),
    r#"SELECT AVG([character].[size_h]) FROM [character]"#
);
assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT AVG(`character`.`size_h`) FROM `character`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT AVG("character"."size_h") FROM "character""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT AVG("character"."size_h") FROM "character""#
);

pub fn abs<T>(expr: T) -> FunctionCall

where T: Into<Expr>,

Call ABS function.

Examples

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

let query = Query::select()
    .expr(Func::abs(Expr::col((Char::Table, Char::SizeH))))
    .from(Char::Table)
    .to_owned();

assert_eq!(
    query.to_string(MsSqlQueryBuilder),
    r#"SELECT ABS([character].[size_h]) FROM [character]"#
);
assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT ABS(`character`.`size_h`) FROM `character`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT ABS("character"."size_h") FROM "character""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT ABS("character"."size_h") FROM "character""#
);

pub fn count<T>(expr: T) -> FunctionCall

where T: Into<Expr>,

Call COUNT function.

Examples

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

let query = Query::select()
    .expr(Func::count(Expr::col((Char::Table, Char::Id))))
    .from(Char::Table)
    .to_owned();

assert_eq!(
    query.to_string(MsSqlQueryBuilder),
    r#"SELECT COUNT([character].[id]) FROM [character]"#
);
assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT COUNT(`character`.`id`) FROM `character`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT COUNT("character"."id") FROM "character""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT COUNT("character"."id") FROM "character""#
);

pub fn count_distinct<T>(expr: T) -> FunctionCall

where T: Into<Expr>,

Call COUNT function with the DISTINCT modifier.

Examples

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

let query = Query::select()
    .expr(Func::count_distinct(Expr::col((Char::Table, Char::Id))))
    .from(Char::Table)
    .to_owned();

assert_eq!(
    query.to_string(MsSqlQueryBuilder),
    r#"SELECT COUNT(DISTINCT [character].[id]) FROM [character]"#
);
assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT COUNT(DISTINCT `character`.`id`) FROM `character`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT COUNT(DISTINCT "character"."id") FROM "character""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT COUNT(DISTINCT "character"."id") FROM "character""#
);

pub fn char_length<T>(expr: T) -> FunctionCall

where T: Into<Expr>,

Call CHAR_LENGTH function.

Examples

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

let query = Query::select()
    .expr(Func::char_length(Expr::col((Char::Table, Char::Character))))
    .from(Char::Table)
    .to_owned();

assert_eq!(
    query.to_string(MsSqlQueryBuilder),
    r#"SELECT CHAR_LENGTH([character].[character]) FROM [character]"#
);
assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT CHAR_LENGTH(`character`.`character`) FROM `character`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT CHAR_LENGTH("character"."character") FROM "character""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT LENGTH("character"."character") FROM "character""#
);

pub fn greatest<I>(args: I) -> FunctionCall

where I: IntoIterator<Item = Expr>,

Call GREATEST function.

Examples

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

let query = Query::select()
    .expr(Func::greatest([
        Expr::col(Char::SizeW).into(),
        Expr::col(Char::SizeH).into(),
    ]))
    .from(Char::Table)
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT GREATEST(`size_w`, `size_h`) FROM `character`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT GREATEST("size_w", "size_h") FROM "character""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT MAX("size_w", "size_h") FROM "character""#
);

pub fn least<I>(args: I) -> FunctionCall

where I: IntoIterator<Item = Expr>,

Call LEAST function.

Examples

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

let query = Query::select()
    .expr(Func::least([
        Expr::col(Char::SizeW).into(),
        Expr::col(Char::SizeH).into(),
    ]))
    .from(Char::Table)
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT LEAST(`size_w`, `size_h`) FROM `character`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT LEAST("size_w", "size_h") FROM "character""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT MIN("size_w", "size_h") FROM "character""#
);

pub fn if_null<A, B>(a: A, b: B) -> FunctionCall

where A: Into<Expr>, B: Into<Expr>,

Call IF NULL function.

Examples

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

let query = Query::select()
    .expr(Func::if_null(
        Expr::col(Char::SizeW),
        Expr::col(Char::SizeH),
    ))
    .from(Char::Table)
    .to_owned();

assert_eq!(
    query.to_string(MsSqlQueryBuilder),
    r#"SELECT ISNULL([size_w], [size_h]) FROM [character]"#
);
assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT IFNULL(`size_w`, `size_h`) FROM `character`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT COALESCE("size_w", "size_h") FROM "character""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT IFNULL("size_w", "size_h") FROM "character""#
);

pub fn cast_as<V, I>(expr: V, iden: I) -> FunctionCall

where V: Into<Expr>, I: IntoIden,

Call CAST function with a custom type.

Examples

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

let query = Query::select()
    .expr(Func::cast_as("hello", "MyType"))
    .to_owned();

assert_eq!(
    query.to_string(MsSqlQueryBuilder),
    r#"SELECT CAST('hello' AS MyType)"#
);
assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT CAST('hello' AS MyType)"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT CAST('hello' AS MyType)"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT CAST('hello' AS MyType)"#
);

pub fn cast_as_quoted<V, I>(expr: V, type: I) -> FunctionCall

where V: Into<Expr>, I: Into<TypeRef>,

Call CAST function with a case-sensitive custom type.

Type can be qualified with a schema name.

Examples

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

let query = Query::select()
    .expr(Func::cast_as_quoted("hello", "MyType"))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT CAST('hello' AS `MyType`)"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT CAST('hello' AS "MyType")"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT CAST('hello' AS "MyType")"#
);

// Also works with a schema-qualified type name:

let query = Query::select()
    .expr(Func::cast_as_quoted("hello", ("MySchema", "MyType")))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT CAST('hello' AS `MySchema`.`MyType`)"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT CAST('hello' AS "MySchema"."MyType")"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT CAST('hello' AS "MySchema"."MyType")"#
);

pub fn coalesce<I, T>(args: I) -> FunctionCall

where I: IntoIterator<Item = T>, T: Into<Expr>,

Call COALESCE function.

Examples

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

let query = Query::select()
    .expr(Func::coalesce([
        Query::select()
            .from(Char::Table)
            .expr(Func::max(Expr::col(Char::SizeW)))
            .take()
            .into(),
        Expr::col(Char::SizeH),
        Expr::val(12),
    ]))
    .from(Char::Table)
    .to_owned();

assert_eq!(
    query.to_string(MsSqlQueryBuilder),
    r#"SELECT COALESCE((SELECT MAX([size_w]) FROM [character]), [size_h], 12) FROM [character]"#
);
assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT COALESCE((SELECT MAX(`size_w`) FROM `character`), `size_h`, 12) FROM `character`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT COALESCE((SELECT MAX("size_w") FROM "character"), "size_h", 12) FROM "character""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT COALESCE((SELECT MAX("size_w") FROM "character"), "size_h", 12) FROM "character""#
);

pub fn lower<T>(expr: T) -> FunctionCall

where T: Into<Expr>,

Call LOWER function.

Examples

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

let query = Query::select()
    .expr(Func::lower(Expr::col(Char::Character)))
    .from(Char::Table)
    .to_owned();

assert_eq!(
    query.to_string(MsSqlQueryBuilder),
    r#"SELECT LOWER([character]) FROM [character]"#
);
assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT LOWER(`character`) FROM `character`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT LOWER("character") FROM "character""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT LOWER("character") FROM "character""#
);

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

let query = Query::select()
    .column(Font::Id)
    .from(Font::Table)
    .and_where(Func::lower(Expr::col(Font::Name)).eq("abc".trim().to_lowercase()))
    .take();

assert_eq!(
    query.to_string(MsSqlQueryBuilder),
    r#"SELECT [id] FROM [font] WHERE LOWER([name]) = 'abc'"#
);
assert_eq!(
    query.to_string(MysqlQueryBuilder),
    "SELECT `id` FROM `font` WHERE LOWER(`name`) = 'abc'"
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "id" FROM "font" WHERE LOWER("name") = 'abc'"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "id" FROM "font" WHERE LOWER("name") = 'abc'"#
);

pub fn upper<T>(expr: T) -> FunctionCall

where T: Into<Expr>,

Call UPPER function.

Examples

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

let query = Query::select()
    .expr(Func::upper(Expr::col(Char::Character)))
    .from(Char::Table)
    .to_owned();

assert_eq!(
    query.to_string(MsSqlQueryBuilder),
    r#"SELECT UPPER([character]) FROM [character]"#
);
assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT UPPER(`character`) FROM `character`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT UPPER("character") FROM "character""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT UPPER("character") FROM "character""#
);

pub fn bit_and<T>(expr: T) -> FunctionCall

where T: Into<Expr>,

Call BIT_AND function, this is not supported on SQLite.

Examples

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

let query = Query::select()
    .expr(Func::bit_and(Expr::col(Char::FontSize)))
    .from(Char::Table)
    .to_owned();

assert_eq!(
    query.to_string(MsSqlQueryBuilder),
    r#"SELECT BIT_AND([font_size]) FROM [character]"#
);
assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT BIT_AND(`font_size`) FROM `character`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT BIT_AND("font_size") FROM "character""#
);

pub fn bit_or<T>(expr: T) -> FunctionCall

where T: Into<Expr>,

Call BIT_OR function, this is not supported on SQLite.

Examples

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

let query = Query::select()
    .expr(Func::bit_or(Expr::col(Char::FontSize)))
    .from(Char::Table)
    .to_owned();

assert_eq!(
    query.to_string(MsSqlQueryBuilder),
    r#"SELECT BIT_OR([font_size]) FROM [character]"#
);
assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT BIT_OR(`font_size`) FROM `character`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT BIT_OR("font_size") FROM "character""#
);

pub fn round<A>(expr: A) -> FunctionCall

where A: Into<Expr>,

Call ROUND function.

Examples

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

let query = Query::select().expr(Func::round(5.654)).to_owned();

assert_eq!(query.to_string(MsSqlQueryBuilder), r#"SELECT ROUND(5.654)"#);
assert_eq!(query.to_string(MysqlQueryBuilder), r#"SELECT ROUND(5.654)"#);

assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT ROUND(5.654)"#
);

assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT ROUND(5.654)"#
);

pub fn round_with_precision<A, B>(a: A, b: B) -> FunctionCall

where A: Into<Expr>, B: Into<Expr>,

Call ROUND function with the precision.

Examples

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

let query = Query::select()
    .expr(Func::round_with_precision(5.654, 2))
    .to_owned();

assert_eq!(
    query.to_string(MsSqlQueryBuilder),
    r#"SELECT ROUND(5.654, 2)"#
);
assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT ROUND(5.654, 2)"#
);

assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT ROUND(5.654, 2)"#
);

assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT ROUND(5.654, 2)"#
);

pub fn random() -> FunctionCall

Call RANDOM function.

Examples

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

let query = Query::select().expr(Func::random()).to_owned();

assert_eq!(query.to_string(MsSqlQueryBuilder), r#"SELECT RANDOM()"#);

assert_eq!(query.to_string(MysqlQueryBuilder), r#"SELECT RAND()"#);

assert_eq!(query.to_string(PostgresQueryBuilder), r#"SELECT RANDOM()"#);

assert_eq!(query.to_string(SqliteQueryBuilder), r#"SELECT RANDOM()"#);

pub fn md5<T>(expr: T) -> FunctionCall

where T: Into<Expr>,

Call MD5 function, this is only available in Postgres and MySQL.

Examples

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

let query = Query::select()
    .expr(Func::md5(Expr::col((Char::Table, Char::Character))))
    .from(Char::Table)
    .to_owned();

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

assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT MD5("character"."character") FROM "character""#
);

Trait Implementations

impl Clone for Func

fn clone(&self) -> Func

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Func

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

Formats the value using the given formatter.

impl PartialEq for Func

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl StructuralPartialEq for Func