Trait ColumnTrait

pub trait ColumnTrait:
    IdenStatic
    + Iterable
    + FromStr {
    type EntityName: EntityName;

Show 44 methods    // Required method
    fn def(&self) -> ColumnDef;

    // Provided methods
    fn enum_type_name(&self) -> Option<&'static str> { ... }
    fn entity_name(&self) -> DynIden { ... }
    fn as_column_ref(&self) -> (DynIden, DynIden) { ... }
    fn eq<V>(&self, v: V) -> Expr
       where V: Into<Value> { ... }
    fn ne<V>(&self, v: V) -> Expr
       where V: Into<Value> { ... }
    fn gt<V>(&self, v: V) -> Expr
       where V: Into<Value> { ... }
    fn gte<V>(&self, v: V) -> Expr
       where V: Into<Value> { ... }
    fn lt<V>(&self, v: V) -> Expr
       where V: Into<Value> { ... }
    fn lte<V>(&self, v: V) -> Expr
       where V: Into<Value> { ... }
    fn between<V>(&self, a: V, b: V) -> Expr
       where V: Into<Value> { ... }
    fn not_between<V>(&self, a: V, b: V) -> Expr
       where V: Into<Value> { ... }
    fn like<T>(&self, s: T) -> Expr
       where T: IntoLikeExpr { ... }
    fn not_like<T>(&self, s: T) -> Expr
       where T: IntoLikeExpr { ... }
    fn ilike<T>(&self, s: T) -> Expr
       where T: IntoLikeExpr { ... }
    fn not_ilike<T>(&self, s: T) -> Expr
       where T: IntoLikeExpr { ... }
    fn starts_with<T>(&self, s: T) -> Expr
       where T: Into<String> { ... }
    fn ends_with<T>(&self, s: T) -> Expr
       where T: Into<String> { ... }
    fn contains<T>(&self, s: T) -> Expr
       where T: Into<String> { ... }
    fn max(&self) -> Expr { ... }
    fn min(&self) -> Expr { ... }
    fn sum(&self) -> Expr { ... }
    fn avg(&self) -> Expr { ... }
    fn count(&self) -> Expr { ... }
    fn is_null(&self) -> Expr { ... }
    fn is_not_null(&self) -> Expr { ... }
    fn if_null<V>(&self, v: V) -> Expr
       where V: Into<Value> { ... }
    fn is_in<V, I>(&self, v: I) -> Expr
       where V: Into<Value>,
             I: IntoIterator<Item = V> { ... }
    fn is_not_in<V, I>(&self, v: I) -> Expr
       where V: Into<Value>,
             I: IntoIterator<Item = V> { ... }
    fn eq_any<V, I>(&self, v: I) -> Expr
       where V: Into<Value> + NotU8,
             I: IntoIterator<Item = V> { ... }
    fn ne_all<V, I>(&self, v: I) -> Expr
       where V: Into<Value> + NotU8,
             I: IntoIterator<Item = V> { ... }
    fn in_subquery(&self, s: SelectStatement) -> Expr { ... }
    fn not_in_subquery(&self, s: SelectStatement) -> Expr { ... }
    fn array_contains<V, I>(&self, v: I) -> Expr
       where V: Into<Value> + ValueType + NotU8,
             I: IntoIterator<Item = V> { ... }
    fn array_contained<V, I>(&self, v: I) -> Expr
       where V: Into<Value> + ValueType + NotU8,
             I: IntoIterator<Item = V> { ... }
    fn array_overlap<V, I>(&self, v: I) -> Expr
       where V: Into<Value> + ValueType + NotU8,
             I: IntoIterator<Item = V> { ... }
    fn into_expr(self) -> Expr { ... }
    fn into_returning_insert_expr(self, db_backend: DbBackend) -> Expr { ... }
    fn into_returning_delete_expr(self, db_backend: DbBackend) -> Expr { ... }
    fn select_as(&self, expr: Expr) -> Expr { ... }
    fn select_enum_as(&self, expr: Expr) -> Expr { ... }
    fn save_as(&self, val: Expr) -> Expr { ... }
    fn save_enum_as(&self, val: Expr) -> Expr { ... }
    fn json_key(&self) -> &'static str { ... }
}

Expand description

API for working with a Column. Mostly a wrapper of the identically named methods in sea_query::Expr

Required Associated Types§

type EntityName: EntityName

Required Methods§

fn def(&self) -> ColumnDef

Get the column definition with SQL attributes

Provided Methods§

fn enum_type_name(&self) -> Option<&'static str>

Get the enum type name if this is a enum column

fn entity_name(&self) -> DynIden

Get the name of the entity the column belongs to

fn as_column_ref(&self) -> (DynIden, DynIden)

Get the table.column reference

fn eq<V>(&self, v: V) -> Expr
where V: Into<Value>,

Perform equality against a Value. None will be converted to IS NULL.

use sea_orm::{DbBackend, entity::*, query::*, tests_cfg::fruit};

assert_eq!(
    fruit::Entity::find()
        .filter(fruit::COLUMN.cake_id.eq(2))
        .build(DbBackend::MySql)
        .to_string(),
    "SELECT `fruit`.`id`, `fruit`.`name`, `fruit`.`cake_id` FROM `fruit` WHERE `fruit`.`cake_id` = 2"
);
assert_eq!(
    fruit::Entity::find()
        .filter(fruit::COLUMN.cake_id.eq(Option::<i32>::None))
        .build(DbBackend::MySql)
        .to_string(),
    "SELECT `fruit`.`id`, `fruit`.`name`, `fruit`.`cake_id` FROM `fruit` WHERE `fruit`.`cake_id` IS NULL"
);

fn ne<V>(&self, v: V) -> Expr
where V: Into<Value>,

Perform inequality against a Value. None will be converted to IS NOT NULL.

use sea_orm::{DbBackend, entity::*, query::*, tests_cfg::fruit};

assert_eq!(
    fruit::Entity::find()
        .filter(fruit::COLUMN.cake_id.ne(2))
        .build(DbBackend::MySql)
        .to_string(),
    "SELECT `fruit`.`id`, `fruit`.`name`, `fruit`.`cake_id` FROM `fruit` WHERE `fruit`.`cake_id` <> 2"
);
assert_eq!(
    fruit::Entity::find()
        .filter(fruit::COLUMN.cake_id.ne(Option::<i32>::None))
        .build(DbBackend::MySql)
        .to_string(),
    "SELECT `fruit`.`id`, `fruit`.`name`, `fruit`.`cake_id` FROM `fruit` WHERE `fruit`.`cake_id` IS NOT NULL"
);

fn gt<V>(&self, v: V) -> Expr
where V: Into<Value>,

fn gte<V>(&self, v: V) -> Expr
where V: Into<Value>,

fn lt<V>(&self, v: V) -> Expr
where V: Into<Value>,

fn lte<V>(&self, v: V) -> Expr
where V: Into<Value>,

fn between<V>(&self, a: V, b: V) -> Expr
where V: Into<Value>,

use sea_orm::{DbBackend, entity::*, query::*, tests_cfg::cake};

assert_eq!(
    cake::Entity::find()
        .filter(cake::Column::Id.between(2, 3))
        .build(DbBackend::MySql)
        .to_string(),
    "SELECT `cake`.`id`, `cake`.`name` FROM `cake` WHERE `cake`.`id` BETWEEN 2 AND 3"
);

fn not_between<V>(&self, a: V, b: V) -> Expr
where V: Into<Value>,

use sea_orm::{DbBackend, entity::*, query::*, tests_cfg::cake};

assert_eq!(
    cake::Entity::find()
        .filter(cake::Column::Id.not_between(2, 3))
        .build(DbBackend::MySql)
        .to_string(),
    "SELECT `cake`.`id`, `cake`.`name` FROM `cake` WHERE `cake`.`id` NOT BETWEEN 2 AND 3"
);

fn like<T>(&self, s: T) -> Expr
where T: IntoLikeExpr,

use sea_orm::{DbBackend, entity::*, query::*, tests_cfg::cake};

assert_eq!(
    cake::Entity::find()
        .filter(cake::Column::Name.like("cheese"))
        .build(DbBackend::MySql)
        .to_string(),
    "SELECT `cake`.`id`, `cake`.`name` FROM `cake` WHERE `cake`.`name` LIKE 'cheese'"
);

fn not_like<T>(&self, s: T) -> Expr
where T: IntoLikeExpr,

use sea_orm::{DbBackend, entity::*, query::*, tests_cfg::cake};

assert_eq!(
    cake::Entity::find()
        .filter(cake::Column::Name.not_like("cheese"))
        .build(DbBackend::MySql)
        .to_string(),
    "SELECT `cake`.`id`, `cake`.`name` FROM `cake` WHERE `cake`.`name` NOT LIKE 'cheese'"
);

fn ilike<T>(&self, s: T) -> Expr
where T: IntoLikeExpr,

Postgres Only.

use sea_orm::{DbBackend, entity::*, query::*, tests_cfg::cake};

assert_eq!(
    cake::Entity::find()
        .filter(cake::Column::Name.ilike("cheese"))
        .build(DbBackend::Postgres)
        .to_string(),
    r#"SELECT "cake"."id", "cake"."name" FROM "cake" WHERE "cake"."name" ILIKE 'cheese'"#
);

fn not_ilike<T>(&self, s: T) -> Expr
where T: IntoLikeExpr,

Postgres Only.

use sea_orm::{DbBackend, entity::*, query::*, tests_cfg::cake};

assert_eq!(
    cake::Entity::find()
        .filter(cake::Column::Name.not_ilike("cheese"))
        .build(DbBackend::Postgres)
        .to_string(),
    r#"SELECT "cake"."id", "cake"."name" FROM "cake" WHERE "cake"."name" NOT ILIKE 'cheese'"#
);

fn starts_with<T>(&self, s: T) -> Expr
where T: Into<String>,

This is a simplified shorthand for a more general like method. Use like if you need something more complex, like specifying an escape character.

§Examples

use sea_orm::{DbBackend, entity::*, query::*, tests_cfg::cake};

assert_eq!(
    cake::Entity::find()
        .filter(cake::Column::Name.starts_with("cheese"))
        .build(DbBackend::MySql)
        .to_string(),
    "SELECT `cake`.`id`, `cake`.`name` FROM `cake` WHERE `cake`.`name` LIKE 'cheese%'"
);

fn ends_with<T>(&self, s: T) -> Expr
where T: Into<String>,

This is a simplified shorthand for a more general like method. Use like if you need something more complex, like specifying an escape character.

§Examples

use sea_orm::{DbBackend, entity::*, query::*, tests_cfg::cake};

assert_eq!(
    cake::Entity::find()
        .filter(cake::Column::Name.ends_with("cheese"))
        .build(DbBackend::MySql)
        .to_string(),
    "SELECT `cake`.`id`, `cake`.`name` FROM `cake` WHERE `cake`.`name` LIKE '%cheese'"
);

fn contains<T>(&self, s: T) -> Expr
where T: Into<String>,

This is a simplified shorthand for a more general like method. Use like if you need something more complex, like specifying an escape character.