Struct sea_orm_migration::prelude::Func

pub struct Func;

Function call helper.

Implementations

impl Func

pub fn cust<T>(func: T) -> FunctionCallwhere T: IntoIden,

Call a custom function.

Examples

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

struct MyFunction;

impl Iden for MyFunction {
    fn unquoted(&self, s: &mut dyn Write) {
        write!(s, "MY_FUNCTION").unwrap();
    }
}

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

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) -> FunctionCallwhere T: Into<SimpleExpr>,

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(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) -> FunctionCallwhere T: Into<SimpleExpr>,

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(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) -> FunctionCallwhere T: Into<SimpleExpr>,

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(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) -> FunctionCallwhere T: Into<SimpleExpr>,

Call AVG function.

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(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) -> FunctionCallwhere T: Into<SimpleExpr>,

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(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) -> FunctionCallwhere T: Into<SimpleExpr>,

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(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 char_length<T>(expr: T) -> FunctionCallwhere T: Into<SimpleExpr>,

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(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 if_null<A, B>(a: A, b: B) -> FunctionCallwhere A: Into<SimpleExpr>, B: Into<SimpleExpr>,

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(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) -> FunctionCallwhere V: Into<SimpleExpr>, I: IntoIden,

Call CAST function with a custom type.

Examples

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

let query = Query::select()
    .expr(Func::cast_as("hello", Alias::new("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)"#
);

pub fn coalesce<I>(args: I) -> FunctionCallwhere I: IntoIterator<Item = SimpleExpr>,

Call COALESCE function.

Examples

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

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

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

pub fn lower<T>(expr: T) -> FunctionCallwhere T: Into<SimpleExpr>,

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

pub fn upper<T>(expr: T) -> FunctionCallwhere T: Into<SimpleExpr>,

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(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 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(MysqlQueryBuilder), r#"SELECT RAND()"#);

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

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

Trait Implementations

impl Clone for Func

fn clone(&self) -> Func

Returns a copy 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<(), Error>

Formats the value using the given formatter.