Struct AlterTableStatement 

pub struct AlterTableStatement { /* private fields */ }

ALTER TABLE statement builder

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

Examples

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

let query = Query::alter_table()
    .table("users")
    .add_column(
        ColumnDef::new("age")
            .column_type(ColumnType::Integer)
    );

Implementations

impl AlterTableStatement

pub fn new() -> Self

Create a new ALTER TABLE statement

pub fn take(&mut self) -> Self

Take the ownership of data in the current AlterTableStatement

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

where T: IntoTableRef,

Set the table to alter

Examples

use reinhardt_query::prelude::*;

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

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

Add a column

Examples

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

let query = Query::alter_table()
    .table("users")
    .add_column(
        ColumnDef::new("age")
            .column_type(ColumnType::Integer)
            .not_null(false)
    );

pub fn drop_column<C>(&mut self, column: C) -> &mut Self

where C: IntoIden,

Drop a column

Examples

use reinhardt_query::prelude::*;

let query = Query::alter_table()
    .table("users")
    .drop_column("age");

pub fn drop_column_if_exists<C>(&mut self, column: C) -> &mut Self

where C: IntoIden,

Drop a column with IF EXISTS

Examples

use reinhardt_query::prelude::*;

let query = Query::alter_table()
    .table("users")
    .drop_column_if_exists("age");

pub fn rename_column<C1, C2>(&mut self, old: C1, new: C2) -> &mut Self

where C1: IntoIden, C2: IntoIden,

Rename a column

Examples

use reinhardt_query::prelude::*;

let query = Query::alter_table()
    .table("users")
    .rename_column("old_name", "new_name");

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

Modify a column (type or constraints)

Examples

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

let query = Query::alter_table()
    .table("users")
    .modify_column(
        ColumnDef::new("age")
            .column_type(ColumnType::BigInteger)
    );

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

Add a constraint

Examples

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

let query = Query::alter_table()
    .table("users")
    .add_constraint(TableConstraint::Unique {
        name: Some("uq_email".into()),
        columns: vec!["email".into()],
    });

pub fn drop_constraint<C>(&mut self, constraint: C) -> &mut Self

where C: IntoIden,

Drop a constraint

Examples

use reinhardt_query::prelude::*;

let query = Query::alter_table()
    .table("users")
    .drop_constraint("uq_email");

pub fn drop_constraint_if_exists<C>(&mut self, constraint: C) -> &mut Self

where C: IntoIden,

Drop a constraint with IF EXISTS

Examples

use reinhardt_query::prelude::*;

let query = Query::alter_table()
    .table("users")
    .drop_constraint_if_exists("uq_email");

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

where T: IntoIden,

Rename table

Examples

use reinhardt_query::prelude::*;

let query = Query::alter_table()
    .table("users")
    .rename_table("accounts");

pub fn add_primary_key<I, C>(&mut self, columns: I) -> &mut Self

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::alter_table()
    .table("users")
    .add_primary_key(vec!["id"]);

pub fn add_unique<I, C>(&mut self, columns: I) -> &mut Self

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::alter_table()
    .table("users")
    .add_unique(vec!["email"]);

pub fn add_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 Self

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::alter_table()
    .table("posts")
    .add_foreign_key(
        vec!["user_id"],
        "users",
        vec!["id"],
        Some(ForeignKeyAction::Cascade),
        None,
    );

Trait Implementations

impl Clone for AlterTableStatement

fn clone(&self) -> AlterTableStatement

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AlterTableStatement

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

Formats the value using the given formatter.

impl Default for AlterTableStatement

fn default() -> Self

Returns the “default value” for a type.

impl QueryStatementBuilder for AlterTableStatement

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

Build SQL statement for a database backend and collect query parameters

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

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

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

Build SQL statement with parameter collection

impl QueryStatementWriter for AlterTableStatement