Enum Operation 

pub enum Operation {
    CreateTable {
        table: String,
        columns: Vec<Column>,
        unique_together: Vec<Vec<String>>,
        indexes: Vec<Vec<String>>,
    },
    DropTable {
        table: String,
    },
    AddColumn {
        table: String,
        column: Column,
    },
    DropColumn {
        table: String,
        column: String,
    },
    AlterColumn {
        table: String,
        column: String,
        new_columns: Vec<Column>,
        prev_columns: Option<Vec<Column>>,
    },
    RenameTable {
        from: String,
        to: String,
    },
    CreateM2MTable {
        junction_table: String,
        parent_table: String,
        parent_col: String,
        child_table: String,
        child_col: String,
        parent_ty: SqlType,
        child_ty: SqlType,
    },
    DropM2MTable {
        junction_table: String,
    },
    RenameColumn {
        table: String,
        from: String,
        to: String,
        column: Option<Column>,
    },
    RunSql {
        sql: String,
        reverse_sql: Option<String>,
    },
}

One operation inside a migration. The migration engine renders each operation to SQL via the active backend (M4 DatabaseBackend:: map_type) and runs them in declaration order inside one transaction per migration file.

M5 v1 shipped table-level ops; M8 v1 adds AddColumn and DropColumn. AlterColumn, index / constraint ops, and RunSql / RunCode are deferred (see docs/specs/06-migration- engine.md).

Variants

CreateTable

Create a new table. columns is in declaration order; the engine builds a sea-query Table::create() over them and runs the rendered DDL. unique_together lowers to inline UNIQUE (col1, col2) clauses; indexes lowers to follow-up CREATE INDEX statements after the table is created. Both default to empty for backward-compat with older snapshots.

Fields

table: String

columns: Vec<Column>

unique_together: Vec<Vec<String>>

indexes: Vec<Vec<String>>

DropTable

Drop an existing table.

Fields

table: String

AddColumn

Add a new column to an existing table. Rendered as ALTER TABLE x ADD COLUMN y TYPE [NOT NULL]. SQLite refuses a non-nullable add against a populated table without a default; the engine surfaces that as a sqlx error at apply time (M8 v1). A future op AddColumnWithDefault lifts the restriction once the #[umbral(default = ...)] attribute lands.

Fields

table: String

column: Column

DropColumn

Drop a column from an existing table. Rendered as ALTER TABLE x DROP COLUMN y. SQLite 3.35+ and Postgres support this natively; older SQLite would need a table- recreation dance the engine doesn’t implement.

Fields

table: String

column: String

AlterColumn

Alter a column’s nullable flag (the only safe in-place change the engine ships at M5.1). Self-contained: carries the full new column list so the SQLite table-recreation dance can rebuild the schema without re-reading the snapshot. The column field names the specific column that triggered the alter (used for the filename suffix and diagnostics); the new_columns list is the post-change schema.

Fields

table: String

column: String

new_columns: Vec<Column>

prev_columns: Option<Vec<Column>>

Snapshot of the table’s columns before this alter. Carried so the Postgres renderer can decide per-column whether it needs a TYPE/USING clause vs a SET/DROP NOT NULL — without re-walking the snapshot file. Option + serde(default) keeps older on-disk migrations deserialising cleanly; ops produced before this field existed get None and fall back to the legacy nullable-only Postgres path.

RenameTable

Rename an existing table. Emitted by diff when a model’s table name changes but its Model::NAME (the Rust struct name) stays the same (first-pass detection), or when the column shapes are bit-identical and the struct name changed too (second-pass heuristic detection). Both SQLite and Postgres render as ALTER TABLE "<from>" RENAME TO "<to>".

The migration tracking table records (plugin, name) of each applied migration — it is not affected by a table rename inside the migration.

Fields

from: String

to: String

CreateM2MTable

Create a many-to-many junction table. Auto-emitted when a model gains an M2M<T> field. Closes BUG-16 phase 2.

The junction table name is parent_table_field_name. Columns: parent_id (FK to parent), child_id (FK to target), both with ON DELETE CASCADE. Composite PK (parent_id, child_id).

parent_ty and child_ty carry the SQL types of the referenced PK columns — BigInt for an i64 PK, Text for a String slug, Uuid for a uuid::Uuid. The renderer maps these to the right column type per backend; without them the junction’s child_id INTEGER would reject a string codename at insert time. #[serde(default)] keeps older snapshot files (pre-phase-2) round-tripping — they default to BigInt, matching the original i64-only behaviour.

Fields

junction_table: String

parent_table: String

parent_col: String

child_table: String

child_col: String

parent_ty: SqlType

child_ty: SqlType

DropM2MTable

Drop a many-to-many junction table. Auto-emitted when an M2M<T> field is removed from a model.

Fields

junction_table: String

RenameColumn

Gap 88: rename a column on an existing table. Emitted by the diff engine when a single column with one shape was dropped and one with the same shape was added in the same diff — the heuristic match for “the user renamed title to headline.” Both SQLite (3.25+) and Postgres render as ALTER TABLE "<t>" RENAME COLUMN "<from>" TO "<to>".

column carries the post-rename column shape so the snapshot stays in sync. The migration only renames; never alters other column attributes — a rename combined with a type change emits a RenameColumn AND a follow-on AlterColumn against the new name.

Fields

table: String

from: String

to: String

column: Option<Column>

RunSql

Gap #69: a raw-SQL data migration. Unlike every other variant it changes rows, not the schema model — so the autodetector NEVER emits it (it has no model-state effect), and a migration carrying only RunSql ops has snapshot_after == snapshot_before. It is always hand-authored: generate an empty migration with makemigrations --empty <plugin>, then add the RunSql op by editing the file.

sql is the forward statement(s), executed verbatim on the per-migration transaction — same string on both backends (raw SQL the renderer passes through untouched), so the author owns portability. reverse_sql is the optional un-apply statement (used by a future migrate --reverse); None means irreversible.

Under schema-per-tenant the op runs per tenant schema (the schema-migrate loop applies every op under the <schema>, public search_path), so a tenant-app RunSql writes tenant rows while reading shared public lookup tables — the boundary-spanning data migration. A shared-app RunSql runs once in public via the normal migrate.

Fields

sql: String

reverse_sql: Option<String>

Implementations

impl Operation

pub fn table_name(&self) -> &str

The primary table this operation targets. For RenameTable, returns the source name (the post-rename to lives in the new snapshot, but routing decisions look up the model meta by its pre-rename from).

Used by run_in’s per-DB dispatch loop to route each op to the pool where its table actually lives.

Trait Implementations

impl Clone for Operation

fn clone(&self) -> Operation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Operation

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Operation

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Operation

impl PartialEq for Operation

fn eq(&self, other: &Operation) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Operation

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Operation