Struct sea_query::table::TableCreateStatement

pub struct TableCreateStatement { /* private fields */ }

Create a table

Examples

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

let table = Table::create()
    .table(Char::Table)
    .if_not_exists()
    .comment("table's comment")
    .col(ColumnDef::new(Char::Id).integer().not_null().auto_increment().primary_key())
    .col(ColumnDef::new(Char::FontSize).integer().not_null().comment("font's size"))
    .col(ColumnDef::new(Char::Character).string().not_null())
    .col(ColumnDef::new(Char::SizeW).integer().not_null())
    .col(ColumnDef::new(Char::SizeH).integer().not_null())
    .col(ColumnDef::new(Char::FontId).integer().default(Value::Int(None)))
    .foreign_key(
        ForeignKey::create()
            .name("FK_2e303c3a712662f1fc2a4d0aad6")
            .from(Char::Table, Char::FontId)
            .to(Font::Table, Font::Id)
            .on_delete(ForeignKeyAction::Cascade)
            .on_update(ForeignKeyAction::Cascade)
    )
    .to_owned();

assert_eq!(
    table.to_string(MysqlQueryBuilder),
    [
        r#"CREATE TABLE IF NOT EXISTS `character` ("#,
            r#"`id` int NOT NULL AUTO_INCREMENT PRIMARY KEY,"#,
            r#"`font_size` int NOT NULL COMMENT 'font\'s size',"#,
            r#"`character` varchar(255) NOT NULL,"#,
            r#"`size_w` int NOT NULL,"#,
            r#"`size_h` int NOT NULL,"#,
            r#"`font_id` int DEFAULT NULL,"#,
            r#"CONSTRAINT `FK_2e303c3a712662f1fc2a4d0aad6`"#,
                r#"FOREIGN KEY (`font_id`) REFERENCES `font` (`id`)"#,
                r#"ON DELETE CASCADE ON UPDATE CASCADE"#,
        r#") COMMENT 'table\'s comment'"#,
    ].join(" ")
);
assert_eq!(
    table.to_string(PostgresQueryBuilder),
    [
        r#"CREATE TABLE IF NOT EXISTS "character" ("#,
            r#""id" serial NOT NULL PRIMARY KEY,"#,
            r#""font_size" integer NOT NULL,"#,
            r#""character" varchar NOT NULL,"#,
            r#""size_w" integer NOT NULL,"#,
            r#""size_h" integer NOT NULL,"#,
            r#""font_id" integer DEFAULT NULL,"#,
            r#"CONSTRAINT "FK_2e303c3a712662f1fc2a4d0aad6""#,
                r#"FOREIGN KEY ("font_id") REFERENCES "font" ("id")"#,
                r#"ON DELETE CASCADE ON UPDATE CASCADE"#,
        r#")"#,
    ].join(" ")
);
assert_eq!(
    table.to_string(SqliteQueryBuilder),
    [
       r#"CREATE TABLE IF NOT EXISTS "character" ("#,
           r#""id" integer NOT NULL PRIMARY KEY AUTOINCREMENT,"#,
           r#""font_size" integer NOT NULL,"#,
           r#""character" text NOT NULL,"#,
           r#""size_w" integer NOT NULL,"#,
           r#""size_h" integer NOT NULL,"#,
           r#""font_id" integer DEFAULT NULL,"#,
           r#"FOREIGN KEY ("font_id") REFERENCES "font" ("id") ON DELETE CASCADE ON UPDATE CASCADE"#,
       r#")"#,
    ].join(" ")
);

Implementations

impl TableCreateStatement

pub fn new() -> Self

Construct create table statement

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

Create table if table not exists

pub fn table<T>(&mut self, table: T) -> &mut Selfwhere T: IntoTableRef,

Set table name

pub fn comment<T>(&mut self, comment: T) -> &mut Selfwhere T: Into<String>,

Set table comment

pub fn col(&mut self, column: &mut ColumnDef) -> &mut Self

Add a new table column

pub fn check(&mut self, value: SimpleExpr) -> &mut Self

pub fn index(&mut self, index: &mut IndexCreateStatement) -> &mut Self

Add an index. MySQL only.

Examples

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

assert_eq!(
    Table::create()
        .table(Glyph::Table)
        .col(ColumnDef::new(Glyph::Id).integer().not_null())
        .index(Index::create().unique().name("idx-glyph-id").col(Glyph::Id))
        .to_string(MysqlQueryBuilder),
    [
        "CREATE TABLE `glyph` (",
        "`id` int NOT NULL,",
        "UNIQUE KEY `idx-glyph-id` (`id`)",
        ")",
    ]
    .join(" ")
);

pub fn primary_key(&mut self, index: &mut IndexCreateStatement) -> &mut Self

Add an primary key.

Examples

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

let mut statement = Table::create();
statement
    .table(Glyph::Table)
    .col(ColumnDef::new(Glyph::Id).integer().not_null())
    .col(ColumnDef::new(Glyph::Image).string().not_null())
    .primary_key(Index::create().col(Glyph::Id).col(Glyph::Image));
assert_eq!(
    statement.to_string(MysqlQueryBuilder),
    [
        "CREATE TABLE `glyph` (",
        "`id` int NOT NULL,",
        "`image` varchar(255) NOT NULL,",
        "PRIMARY KEY (`id`, `image`)",
        ")",
    ]
    .join(" ")
);
assert_eq!(
    statement.to_string(PostgresQueryBuilder),
    [
        "CREATE TABLE \"glyph\" (",
        "\"id\" integer NOT NULL,",
        "\"image\" varchar NOT NULL,",
        "PRIMARY KEY (\"id\", \"image\")",
        ")",
    ]
    .join(" ")
);
assert_eq!(
    statement.to_string(SqliteQueryBuilder),
    [
        r#"CREATE TABLE "glyph" ("#,
        r#""id" integer NOT NULL,"#,
        r#""image" text NOT NULL,"#,
        r#"PRIMARY KEY ("id", "image")"#,
        r#")"#,
    ]
    .join(" ")
);

pub fn foreign_key( &mut self, foreign_key: &mut ForeignKeyCreateStatement ) -> &mut Self

Add a foreign key

pub fn engine<T>(&mut self, string: T) -> &mut Selfwhere T: Into<String>,

Set database engine. MySQL only.

pub fn collate<T>(&mut self, string: T) -> &mut Selfwhere T: Into<String>,

Set database collate. MySQL only.

pub fn character_set<T>(&mut self, name: T) -> &mut Selfwhere T: Into<String>,

Set database character set. MySQL only.

pub fn get_table_name(&self) -> Option<&TableRef>

pub fn get_columns(&self) -> &Vec<ColumnDef>

pub fn get_comment(&self) -> Option<&String>

pub fn get_foreign_key_create_stmts(&self) -> &Vec<ForeignKeyCreateStatement>

pub fn get_indexes(&self) -> &Vec<IndexCreateStatement>

pub fn extra<T>(&mut self, extra: T) -> &mut Selfwhere T: Into<String>,

Rewriting extra param. You should take care self about concat extra params. Add extra after options. Example for PostgresSQL Citus extension:

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

pub fn get_extra(&self) -> Option<&String>

pub fn take(&mut self) -> Self

impl TableCreateStatement

pub fn build<T: SchemaBuilder>(&self, schema_builder: T) -> String

See SchemaStatementBuilder::build

pub fn build_any(&self, schema_builder: &dyn SchemaBuilder) -> String

See SchemaStatementBuilder::build_any

pub fn to_string<T: SchemaBuilder>(&self, schema_builder: T) -> String

See SchemaStatementBuilder::to_string

Trait Implementations

impl Clone for TableCreateStatement

fn clone(&self) -> TableCreateStatement

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TableCreateStatement

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

Formats the value using the given formatter.

impl Default for TableCreateStatement

fn default() -> TableCreateStatement

Returns the “default value” for a type.

impl SchemaStatementBuilder for TableCreateStatement

fn build<T: SchemaBuilder>(&self, schema_builder: T) -> String

Build corresponding SQL statement for certain database backend and return SQL string

fn build_any(&self, schema_builder: &dyn SchemaBuilder) -> String

Build corresponding SQL statement for certain database backend and return SQL string

fn to_string<T: SchemaBuilder>(&self, schema_builder: T) -> String

Build corresponding SQL statement for certain database backend and return SQL string