Struct ColumnDef

pub struct ColumnDef {
    pub(crate) table: Option<TableRef>,
    pub(crate) name: DynIden,
    pub(crate) types: Option<ColumnType>,
    pub(crate) spec: Vec<ColumnSpec>,
}

Specification of a table column

Fields

table: Option<TableRef>

name: DynIden

types: Option<ColumnType>

spec: Vec<ColumnSpec>

Implementations

impl ColumnDef

pub fn new<T>(name: T) -> Self

where T: IntoIden,

Construct a table column

pub fn new_with_type<T>(name: T, types: ColumnType) -> Self

where T: IntoIden,

Construct a table column with column type

pub fn not_null(&mut self) -> &mut Self

Set column not null

pub fn null(&mut self) -> &mut Self

Set column null

pub fn default<T>(&mut self, value: T) -> &mut Self

where T: Into<Expr>,

Set default expression of a column

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

let table = Table::create()
    .table(Char::Table)
    .col(ColumnDef::new(Char::FontId).integer().default(12i32))
    .col(
        ColumnDef::new(Char::CreatedAt)
            .timestamp()
            .default(Expr::current_timestamp())
            .not_null(),
    )
    .to_owned();

assert_eq!(
    table.to_string(MysqlQueryBuilder),
    [
        "CREATE TABLE `character` (",
        "`font_id` int DEFAULT 12,",
        "`created_at` timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL",
        ")",
    ]
    .join(" ")
);

assert_eq!(
    table.to_string(PostgresQueryBuilder),
    [
        r#"CREATE TABLE "character" ("#,
        r#""font_id" integer DEFAULT 12,"#,
        r#""created_at" timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL"#,
        r#")"#,
    ]
    .join(" ")
);

pub fn auto_increment(&mut self) -> &mut Self

Set column auto increment

pub fn unique_key(&mut self) -> &mut Self

Set column unique constraint

pub fn primary_key(&mut self) -> &mut Self

Set column as primary key

pub fn char_len(&mut self, length: u32) -> &mut Self

Set column type as char with custom length

pub fn char(&mut self) -> &mut Self

Set column type as char

pub fn string_len(&mut self, length: u32) -> &mut Self

Set column type as string with custom length

pub fn string(&mut self) -> &mut Self

Set column type as string

pub fn text(&mut self) -> &mut Self

Set column type as text

pub fn tiny_integer(&mut self) -> &mut Self

Set column type as tiny_integer

pub fn small_integer(&mut self) -> &mut Self

Set column type as small_integer

pub fn integer(&mut self) -> &mut Self

Set column type as integer

pub fn big_integer(&mut self) -> &mut Self

Set column type as big_integer

pub fn tiny_unsigned(&mut self) -> &mut Self

Set column type as tiny_unsigned

pub fn small_unsigned(&mut self) -> &mut Self

Set column type as small_unsigned

pub fn unsigned(&mut self) -> &mut Self

Set column type as unsigned

pub fn big_unsigned(&mut self) -> &mut Self

Set column type as big_unsigned

pub fn float(&mut self) -> &mut Self

Set column type as float

pub fn double(&mut self) -> &mut Self

Set column type as double

pub fn decimal_len(&mut self, precision: u32, scale: u32) -> &mut Self

Set column type as decimal with custom precision and scale

pub fn decimal(&mut self) -> &mut Self

Set column type as decimal

pub fn date_time(&mut self) -> &mut Self

Set column type as date_time

pub fn timestamp(&mut self) -> &mut Self

Set column type as timestamp

pub fn timestamp_with_time_zone(&mut self) -> &mut Self

Set column type as timestamp with time zone. Postgres only

pub fn time(&mut self) -> &mut Self

Set column type as time

pub fn date(&mut self) -> &mut Self

Set column type as date

pub fn year(&mut self) -> &mut Self

Set column type as year Only MySQL supports year

pub fn binary_len(&mut self, length: u32) -> &mut Self

Set column type as binary with custom length

pub fn binary(&mut self) -> &mut Self

Set column type as binary with default length of 1

pub fn var_binary(&mut self, length: u32) -> &mut Self

Set column type as binary with variable length

pub fn bit(&mut self, length: Option<u32>) -> &mut Self

Set column type as bit with variable length

pub fn varbit(&mut self, length: u32) -> &mut Self

Set column type as varbit with variable length

pub fn blob(&mut self) -> &mut Self

Set column type as blob

pub fn boolean(&mut self) -> &mut Self

Set column type as boolean

pub fn money_len(&mut self, precision: u32, scale: u32) -> &mut Self

Set column type as money with custom precision and scale

pub fn money(&mut self) -> &mut Self

Set column type as money

pub fn json(&mut self) -> &mut Self

Set column type as json.

pub fn json_binary(&mut self) -> &mut Self

Set column type as json binary.

pub fn uuid(&mut self) -> &mut Self

Set column type as uuid

pub fn custom<T>(&mut self, name: T) -> &mut Self

where T: IntoIden,

Use a custom type on this column.

Example

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

let table = Table::create()
    .table(Char::Table)
    .col(
        ColumnDef::new(Char::Id)
            .custom("new_type")
            .not_null()
            .primary_key(),
    )
    .to_owned();

assert_eq!(
    table.to_string(MysqlQueryBuilder),
    [
        r#"CREATE TABLE `character` ("#,
        r#"`id` new_type NOT NULL PRIMARY KEY"#,
        r#")"#,
    ]
    .join(" ")
);
assert_eq!(
    table.to_string(PostgresQueryBuilder),
    [
        r#"CREATE TABLE "character" ("#,
        r#""id" new_type NOT NULL PRIMARY KEY"#,
        r#")"#,
    ]
    .join(" ")
);
assert_eq!(
    table.to_string(SqliteQueryBuilder),
    [
        r#"CREATE TABLE "character" ("#,
        r#""id" new_type NOT NULL PRIMARY KEY"#,
        r#")"#,
    ]
    .join(" ")
);

pub fn enumeration<N, S, V>(&mut self, name: N, variants: V) -> &mut Self

where N: IntoIden, S: IntoIden, V: IntoIterator<Item = S>,

Set column type as enum.

pub fn array(&mut self, elem_type: ColumnType) -> &mut Self

Set column type as an array with a specified element type. This is only supported on Postgres.

pub fn cidr(&mut self) -> &mut Self

Set columnt type as cidr. This is only supported on Postgres.

pub fn inet(&mut self) -> &mut Self

Set columnt type as inet. This is only supported on Postgres.

pub fn mac_address(&mut self) -> &mut Self

Set columnt type as macaddr. This is only supported on Postgres.

pub fn ltree(&mut self) -> &mut Self

Set column type as ltree This is only supported on Postgres.

use sea_query::{tests_cfg::*, *};
assert_eq!(
    Table::create()
        .table(Glyph::Table)
        .col(
            ColumnDef::new(Glyph::Id)
                .integer()
                .not_null()
                .auto_increment()
                .primary_key()
        )
        .col(ColumnDef::new(Glyph::Tokens).ltree())
        .to_string(PostgresQueryBuilder),
    [
        r#"CREATE TABLE "glyph" ("#,
        r#""id" integer GENERATED BY DEFAULT AS IDENTITY NOT NULL PRIMARY KEY,"#,
        r#""tokens" ltree"#,
        r#")"#,
    ]
    .join(" ")
);

pub fn check<T>(&mut self, check: T) -> &mut Self

where T: Into<Check>,

Set constraints as Expr

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

assert_eq!(
    Table::create()
        .table(Glyph::Table)
        .col(
            ColumnDef::new(Glyph::Id)
                .integer()
                .not_null()
                .check(Expr::col(Glyph::Id).gt(10))
        )
        .to_string(MysqlQueryBuilder),
    r#"CREATE TABLE `glyph` ( `id` int NOT NULL CHECK (`id` > 10) )"#,
);

assert_eq!(
    Table::create()
        .table(Glyph::Table)
        .col(
            ColumnDef::new(Glyph::Id)
                .integer()
                .not_null()
                .check(("positive_id", Expr::col(Glyph::Id).gt(10)))
        )
        .to_string(MysqlQueryBuilder),
    r#"CREATE TABLE `glyph` ( `id` int NOT NULL CONSTRAINT `positive_id` CHECK (`id` > 10) )"#,
);

pub fn generated<T>(&mut self, expr: T, stored: bool) -> &mut Self

where T: Into<Expr>,

Sets the column as generated with Expr

pub fn extra<T>(&mut self, string: T) -> &mut Self

where T: Into<String>,

Some extra options in custom string

use sea_query::{tests_cfg::*, *};
let table = Table::create()
    .table(Char::Table)
    .col(
        ColumnDef::new(Char::Id)
            .uuid()
            .extra("DEFAULT gen_random_uuid()")
            .primary_key()
            .not_null(),
    )
    .col(
        ColumnDef::new(Char::CreatedAt)
            .timestamp_with_time_zone()
            .extra("DEFAULT NOW()")
            .not_null(),
    )
    .to_owned();
assert_eq!(
    table.to_string(PostgresQueryBuilder),
    [
        r#"CREATE TABLE "character" ("#,
        r#""id" uuid DEFAULT gen_random_uuid() PRIMARY KEY NOT NULL,"#,
        r#""created_at" timestamp with time zone DEFAULT NOW() NOT NULL"#,
        r#")"#,
    ]
    .join(" ")
);

pub fn using<T>(&mut self, value: T) -> &mut Self

where T: Into<Expr>,

Some extra options in custom string

use sea_query::{tests_cfg::*, *};
let table = Table::alter()
    .table(Char::Table)
    .modify_column(
        ColumnDef::new(Char::Id)
            .integer()
            .using(Expr::col(Char::Id).cast_as("integer")),
    )
    .to_owned();
assert_eq!(
    table.to_string(PostgresQueryBuilder),
    [
        r#"ALTER TABLE "character""#,
        r#"ALTER COLUMN "id" TYPE integer USING CAST("id" AS integer)"#,
    ]
    .join(" ")
);

pub fn comment<T>(&mut self, string: T) -> &mut Self

where T: Into<String>,

MySQL only.

pub fn get_column_name(&self) -> String

pub fn get_column_type(&self) -> Option<&ColumnType>

pub fn get_column_spec(&self) -> &Vec<ColumnSpec>

pub fn take(&mut self) -> Self

Trait Implementations

impl Clone for ColumnDef

fn clone(&self) -> ColumnDef

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ColumnDef

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

Formats the value using the given formatter.

impl From<&mut ColumnDef> for ColumnDef

fn from(col: &mut ColumnDef) -> Self

Converts to this type from the input type.