Struct sea_query::table::TableCreateStatement

pub struct TableCreateStatement { /* fields omitted */ }

Create a table

Examples

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

let table = Table::create()
    .table(Char::Table)
    .if_not_exists()
    .col(ColumnDef::new(Char::Id).integer().not_null().auto_increment().primary_key())
    .col(ColumnDef::new(Char::FontSize).integer().not_null())
    .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),
    vec![
        r#"CREATE TABLE IF NOT EXISTS `character` ("#,
            r#"`id` int NOT NULL AUTO_INCREMENT PRIMARY KEY,"#,
            r#"`font_size` int NOT NULL,"#,
            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#")"#,
    ].join(" ")
);
assert_eq!(
    table.to_string(PostgresQueryBuilder),
    vec![
        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),
    vec![
       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 create_if_not_exists(&mut self) -> &mut Self

👎 Deprecated since 0.9.6:

Please use the [TableCreateStatement::if_not_exists]

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

Create table if table not exists

pub fn table<T: 'static>(&mut self, table: T) -> &mut Self where
    T: Iden, 

Set table name

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

Add a new table column

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),
    vec![
        "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),
    vec![
        "CREATE TABLE `glyph` (",
            "`id` int NOT NULL,",
            "`image` varchar(255) NOT NULL,",
            "PRIMARY KEY (`id`, `image`)",
        ")",
    ].join(" ")
);
assert_eq!(statement.to_string(PostgresQueryBuilder),
    vec![
        "CREATE TABLE \"glyph\" (",
            "\"id\" integer NOT NULL,",
            "\"image\" varchar NOT NULL,",
            "PRIMARY KEY (\"id\", \"image\")",
        ")",
    ].join(" ")
);
assert_eq!(statement.to_string(SqliteQueryBuilder),
    vec![
        "CREATE TABLE `glyph` (",
            "`id` integer NOT NULL,",
            "`image` text NOT NULL,",
            "PRIMARY KEY (`id`, `image`)",
        ")",
    ].join(" ")
);

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

Add a foreign key

pub fn engine(&mut self, string: &str) -> &mut Self

Set database engine. MySQL only.

pub fn collate(&mut self, string: &str) -> &mut Self

Set database collate. MySQL only.

pub fn character_set(&mut self, string: &str) -> &mut Self

Set database character set. MySQL only.

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

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

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

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

pub fn take(&mut self) -> Self

impl TableCreateStatement

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

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

pub fn build_any(&self, schema_builder: &dyn SchemaBuilder) -> 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() -> Self

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