Struct CreateTableStatement 

pub struct CreateTableStatement { /* private fields */ }

Available on crate feature database and non-WebAssembly only.

CREATE TABLE statement builder

This struct provides a fluent API for constructing CREATE TABLE queries.

Examples

use reinhardt_query::prelude::*;
use reinhardt_query::types::ddl::ColumnType;

let query = Query::create_table()
    .table("users")
    .if_not_exists()
    .col(
        ColumnDef::new("id")
            .column_type(ColumnType::Integer)
            .primary_key(true)
            .auto_increment(true)
    )
    .col(
        ColumnDef::new("name")
            .column_type(ColumnType::String(Some(100)))
            .not_null(true)
    );

Implementations

impl CreateTableStatement

pub fn new() -> CreateTableStatement

Create a new CREATE TABLE statement

pub fn take(&mut self) -> CreateTableStatement

Take the ownership of data in the current CreateTableStatement

pub fn table<T>(&mut self, tbl: T) -> &mut CreateTableStatement

where T: IntoTableRef,

Set the table to create

Examples

use reinhardt_query::prelude::*;

let query = Query::create_table()
    .table("users");

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

Add IF NOT EXISTS clause

Examples

use reinhardt_query::prelude::*;

let query = Query::create_table()
    .table("users")
    .if_not_exists();

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

Add a column definition

Examples

use reinhardt_query::prelude::*;
use reinhardt_query::types::ddl::{ColumnDef, ColumnType};

let query = Query::create_table()
    .table("users")
    .col(
        ColumnDef::new("id")
            .column_type(ColumnType::Integer)
            .primary_key(true)
    );

pub fn cols<I>(&mut self, columns: I) -> &mut CreateTableStatement

where I: IntoIterator<Item = ColumnDef>,

Add multiple column definitions

Examples

use reinhardt_query::prelude::*;
use reinhardt_query::types::ddl::{ColumnDef, ColumnType};

let query = Query::create_table()
    .table("users")
    .cols(vec![
        ColumnDef::new("id").column_type(ColumnType::Integer),
        ColumnDef::new("name").column_type(ColumnType::String(Some(100))),
    ]);

pub fn constraint( &mut self, constraint: TableConstraint, ) -> &mut CreateTableStatement

Add a table constraint

Examples

use reinhardt_query::prelude::*;
use reinhardt_query::types::ddl::TableConstraint;

let query = Query::create_table()
    .table("users")
    .constraint(TableConstraint::PrimaryKey {
        name: Some("pk_users".into()),
        columns: vec!["id".into()],
    });

pub fn constraints<I>(&mut self, constraints: I) -> &mut CreateTableStatement

where I: IntoIterator<Item = TableConstraint>,

Add multiple table constraints

Examples

use reinhardt_query::prelude::*;
use reinhardt_query::types::ddl::TableConstraint;

let query = Query::create_table()
    .table("order_items")
    .constraints(vec![
        TableConstraint::PrimaryKey {
            name: None,
            columns: vec!["order_id".into(), "item_id".into()],
        },
        TableConstraint::ForeignKey {
            name: Some("fk_order".into()),
            columns: vec!["order_id".into()],
            ref_table: Box::new("orders".into()),
            ref_columns: vec!["id".into()],
            on_delete: None,
            on_update: None,
        },
    ]);

pub fn index(&mut self, index: IndexDef) -> &mut CreateTableStatement

Add an index definition

Examples

use reinhardt_query::prelude::*;
use reinhardt_query::types::ddl::IndexDef;

let query = Query::create_table()
    .table("users")
    .index(
        IndexDef::new("idx_email", "users")
            .column("email")
            .unique(true)
    );

pub fn indexes<I>(&mut self, indexes: I) -> &mut CreateTableStatement

where I: IntoIterator<Item = IndexDef>,

Add multiple index definitions

pub fn comment<S>(&mut self, comment: S) -> &mut CreateTableStatement

where S: Into<String>,

Set table comment

Examples

use reinhardt_query::prelude::*;

let query = Query::create_table()
    .table("users")
    .comment("User accounts table");

pub fn primary_key<I, C>(&mut self, columns: I) -> &mut CreateTableStatement

where I: IntoIterator<Item = C>, C: IntoIden,

Add a primary key constraint

This is a convenience method for adding a PRIMARY KEY constraint.

Examples

use reinhardt_query::prelude::*;

let query = Query::create_table()
    .table("users")
    .primary_key(vec!["id"]);

pub fn unique<I, C>(&mut self, columns: I) -> &mut CreateTableStatement

where I: IntoIterator<Item = C>, C: IntoIden,

Add a unique constraint

This is a convenience method for adding a UNIQUE constraint.

Examples

use reinhardt_query::prelude::*;

let query = Query::create_table()
    .table("users")
    .unique(vec!["email"]);

pub fn foreign_key<I1, C1, T, I2, C2>( &mut self, columns: I1, ref_table: T, ref_columns: I2, on_delete: Option<ForeignKeyAction>, on_update: Option<ForeignKeyAction>, ) -> &mut CreateTableStatement

where I1: IntoIterator<Item = C1>, C1: IntoIden, T: IntoTableRef, I2: IntoIterator<Item = C2>, C2: IntoIden,

Add a foreign key constraint

This is a convenience method for adding a FOREIGN KEY constraint.

Examples

use reinhardt_query::prelude::*;
use reinhardt_query::types::ddl::ForeignKeyAction;

let query = Query::create_table()
    .table("posts")
    .foreign_key(
        vec!["user_id"],
        "users",
        vec!["id"],
        Some(ForeignKeyAction::Cascade),
        None,
    );

pub fn foreign_key_from_builder( &mut self, fk: &mut ForeignKeyCreateStatement, ) -> &mut CreateTableStatement

Add a foreign key constraint from a ForeignKeyCreateStatement builder.

This method accepts the builder-pattern style used by ForeignKey::create().

Examples

use reinhardt_query::prelude::*;

let mut fk = ForeignKey::create();
fk.from_tbl(Alias::new("posts"))
    .from_col(Alias::new("user_id"))
    .to_tbl(Alias::new("users"))
    .to_col(Alias::new("id"));

let mut stmt = Query::create_table();
stmt.table("posts")
    .foreign_key_from_builder(&mut fk);

Trait Implementations

impl Clone for CreateTableStatement

fn clone(&self) -> CreateTableStatement

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CreateTableStatement

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

Formats the value using the given formatter.

impl Default for CreateTableStatement

fn default() -> CreateTableStatement

Returns the “default value” for a type.

impl QueryStatementBuilder for CreateTableStatement

fn build_any( &self, query_builder: &(dyn QueryBuilderTrait + 'static), ) -> (String, Values)

Build SQL statement for a database backend and collect query parameters

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

where T: QueryBuilderTrait,

Build SQL statement for a database backend and return SQL string with values inlined as SQL literals.

fn build<T>(&self, query_builder: T) -> (String, Values)

where T: QueryBuilderTrait,

Build SQL statement with parameter collection

impl QueryStatementWriter for CreateTableStatement