Struct sea_query::func::Func

pub struct Func;

Function call helper.

Implementations

impl Func

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

Call a custom function.

Examples

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

struct MyFunction;

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

let query = Query::select()
    .expr(Func::cust(MyFunction).args(vec![Expr::val("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) -> SimpleExpr where
    T: Into<SimpleExpr>, 

Call MAX function.

Examples

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

let query = Query::select()
    .expr(Func::max(Expr::tbl(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) -> SimpleExpr where
    T: Into<SimpleExpr>, 

Call MIN function.

Examples

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

let query = Query::select()
    .expr(Func::min(Expr::tbl(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) -> SimpleExpr where
    T: Into<SimpleExpr>, 

Call SUM function.

Examples

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

let query = Query::select()
    .expr(Func::sum(Expr::tbl(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) -> SimpleExpr where
    T: Into<SimpleExpr>, 

Call AVG function.

Examples

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

let query = Query::select()
    .expr(Func::avg(Expr::tbl(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) -> SimpleExpr where
    T: Into<SimpleExpr>, 

Call ABS function.

Examples

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

let query = Query::select()
    .expr(Func::abs(Expr::tbl(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) -> SimpleExpr where
    T: Into<SimpleExpr>, 

Call COUNT function.

Examples

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

let query = Query::select()
    .expr(Func::count(Expr::tbl(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) -> SimpleExpr where
    T: Into<SimpleExpr>, 

Call CHAR_LENGTH function.

Examples

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

let query = Query::select()
    .expr(Func::char_length(Expr::tbl(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) -> SimpleExpr where
    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>(value: V, iden: I) -> SimpleExpr where
    V: Into<Value>,
    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, T>(args: I) -> SimpleExpr where
    T: Into<SimpleExpr>,
    I: IntoIterator<Item = T>, 

Call COALESCE function.

Examples

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

let query = Query::select()
    .expr(Func::coalesce([
        Expr::col(Char::SizeW),
        Expr::col(Char::SizeH),
        Expr::val(12),
    ]))
    .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) -> SimpleExpr where
    T: Into<SimpleExpr>, 

Call LOWER function.

Examples

use sea_query::tests_cfg::Character::Character;
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) -> SimpleExpr where
    T: Into<SimpleExpr>, 

Call UPPER function.

Examples

use sea_query::tests_cfg::Character::Character;
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 current_timestamp() -> SimpleExpr

Call CURRENT_TIMESTAMP function.

Examples

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

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

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT CURRENT_TIMESTAMP"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT CURRENT_TIMESTAMP"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT CURRENT_TIMESTAMP"#
);

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

Formats the value using the given formatter.