Struct TableChanges 

pub struct TableChanges { /* private fields */ }

A change to a table that already exists — Laravel’s Schema::table.

TableChanges::to("posts", |table| {
    table.string("subtitle").nullable();
    table.index(["author_id", "published"]);
    table.rename_column("body", "content");
});

Reversal

Each change knows its own opposite, so the migration’s down is derived rather than written twice: an added column is dropped, a created index is dropped, a rename is renamed back.

Two are not reversible, and say so rather than pretending: drop_column, because the type and the data are gone; and raw, because nothing here knows what it did.

Implementations

impl TableChanges

pub fn new(table: impl Into<String>) -> TableChanges

Changes to table.

pub fn to( table: impl Into<String>, build: impl FnOnce(&mut TableChanges), ) -> TableChanges

Describe changes to table with build.

pub fn table(&self) -> &str

The table being changed.

pub fn is_empty(&self) -> bool

Whether anything was asked for.

pub fn column( &mut self, name: impl Into<String>, kind: ColumnKind, ) -> &mut Column

Add a column of any kind.

A column added to a table that already has rows must either be nullable or carry a default — otherwise the existing rows have no value for it and the engine refuses the change.

pub fn string(&mut self, name: impl Into<String>) -> &mut Column

Add a VARCHAR(255).

pub fn string_len(&mut self, name: impl Into<String>, len: u32) -> &mut Column

Add a VARCHAR(len).

pub fn text(&mut self, name: impl Into<String>) -> &mut Column

Add an unbounded text column.

pub fn integer(&mut self, name: impl Into<String>) -> &mut Column

Add a 32-bit signed integer.

pub fn big_integer(&mut self, name: impl Into<String>) -> &mut Column

Add a 64-bit signed integer.

pub fn unsigned_big_integer(&mut self, name: impl Into<String>) -> &mut Column

Add a 64-bit unsigned integer.

pub fn foreign_id(&mut self, name: impl Into<String>) -> &mut Column

Add a foreign key column.

The constraint is not added: no engine adds one to an existing table portably (SQLite cannot at all), and a column that silently gained no constraint would be worse than one that never claimed to. Declare it in the CREATE TABLE, or accept the index this gives you.

pub fn boolean(&mut self, name: impl Into<String>) -> &mut Column

Add a boolean.

pub fn timestamp(&mut self, name: impl Into<String>) -> &mut Column

Add a timestamp.

pub fn json(&mut self, name: impl Into<String>) -> &mut Column

Add a JSON document column.

pub fn drop_column(&mut self, name: impl Into<String>) -> &mut TableChanges

Drop a column.

Makes the whole step irreversible: the type and the data are gone, and a down that recreated the column empty would report success while having restored nothing.

pub fn rename_column( &mut self, from: impl Into<String>, to: impl Into<String>, ) -> &mut TableChanges

Rename a column. Reverses by renaming it back.

pub fn index<I, S>(&mut self, columns: I) -> &mut IndexDef

where I: IntoIterator<Item = S>, S: Into<String>,

Create an index, named by the same convention a CREATE TABLE uses.

pub fn unique<I, S>(&mut self, columns: I) -> &mut IndexDef

where I: IntoIterator<Item = S>, S: Into<String>,

Create a UNIQUE index.

pub fn drop_index<I, S>(&mut self, columns: I) -> &mut IndexDef

where I: IntoIterator<Item = S>, S: Into<String>,

Drop an index over columns.

The columns rather than the name, so the reversal can recreate it — and because the name is derivable from them anyway. Use IndexDef::named on the returned value if it was named by hand.

pub fn drop_unique<I, S>(&mut self, columns: I) -> &mut IndexDef

where I: IntoIterator<Item = S>, S: Into<String>,

Drop a UNIQUE index over columns.

pub fn raw( &mut self, dialect: Option<Dialect>, up: impl Into<String>, down: Option<String>, ) -> &mut TableChanges

Raw SQL, for one dialect or all of them.

The escape hatch for what no portable form covers — a MODIFY COLUMN, a generated column, a partial index. Pass down when you can undo it; None makes the step irreversible and says why.

Reach for a typed change first. This one is the reason a schema stops being portable.

pub fn to_sql(&self, dialect: Dialect) -> Vec<String>

Every statement that applies these changes on dialect, in order.

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

Why these changes cannot be undone, or None if they can.

Checked before a rollback runs, so a batch that contains one irreversible step refuses up front rather than half-unwinding.

pub fn to_reverse_sql(&self, dialect: Dialect) -> Vec<String>

The statements that undo these changes on dialect, in reverse order.

Empty when irreversible_because has an answer — ask that first.

Trait Implementations

impl Clone for TableChanges

fn clone(&self) -> TableChanges

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TableChanges

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

Formats the value using the given formatter.