Enum Operation 

pub enum Operation {
    CreateTable {
        table: String,
        columns: Vec<Column>,
        unique_together: Vec<Vec<String>>,
        indexes: Vec<Vec<String>>,
    },
    DropTable {
        table: String,
    },
    CreateView {
        name: String,
        sql: String,
        materialized: bool,
    },
    DropView {
        name: String,
        materialized: bool,
    },
    AddColumn {
        table: String,
        column: Column,
    },
    DropColumn {
        table: String,
        column: String,
    },
    AlterColumn {
        table: String,
        column: String,
        new_columns: Vec<Column>,
        unique_together: Vec<Vec<String>>,
        indexes: Vec<Vec<String>>,
        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>,
    },
    SetColumnComment {
        table: String,
        column: String,
        comment: String,
    },
    RunSql {
        sql: String,
        reverse_sql: Option<String>,
    },
    AddIndex {
        table: String,
        columns: Vec<String>,
        unique: bool,
    },
    DropIndex {
        table: String,
        columns: Vec<String>,
        unique: bool,
    },
}

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.

Shipped: table-level ops (CreateTable / DropTable), AddColumn / DropColumn, AlterColumn (nullable flips), index / constraint ops (AddIndex / DropIndex), rename detection (RenameTable / RenameColumn), database views (CreateView / DropView), M2M junction tables (CreateM2MTable / DropM2MTable), column comments (SetColumnComment), and the RunSql data-migration escape hatch. Still deferred: AlterColumn type changes, primary-key flips, and the RunCode Rust data-migration op. 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

CreateView

features #73 — create a database VIEW from #[umbral(view = "...")].

There is no AlterView, and there never will be: a view holds no rows, so changing one is a drop and a recreate. That is why views escape every hard problem the table side of this engine spent its life on — no data-preserving ALTER, no rename-vs-drop disambiguation, nothing to back up.

Fields

name: String

The view’s name in the database (the model’s TABLE).

sql: String

The SELECT body, verbatim from the attribute. Opaque to the engine.

materialized: bool

CREATE MATERIALIZED VIEW (Postgres-only) rather than CREATE VIEW.

DropView

features #73 — drop a database VIEW.

Fields

name: String

The view’s name in the database.

materialized: bool

Whether it was created as MATERIALIZED — the DROP statement differs.

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>

unique_together: Vec<Vec<String>>

The table’s composite UNIQUE groups (audit_2 core-migrate #10). The SQLite recreation dance rebuilds the table from scratch, so it must re-emit these — otherwise a nullable-flip / safe-cast alter silently DROPS every composite UNIQUE constraint (duplicates become insertable — integrity loss). Postgres alters in place and ignores this. serde(default) keeps older on-disk migrations deserialising.

indexes: Vec<Vec<String>>

The table’s composite (multi-column) index groups (audit_2 core-migrate #10). Re-created by the SQLite dance after the rebuild, for the same reason as unique_together. Single-column / FK / soft-delete indexes are re-derived from new_columns.

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>

SetColumnComment

gaps3 #43: set (or clear) a column’s database comment from #[umbral(help = "...")]. Renders as COMMENT ON COLUMN "<t>"."<c>" IS '<comment>' on Postgres, and to nothing on SQLite, which has no comment facility. An empty comment clears it with IS NULL — Postgres distinguishes “no comment” from “the empty comment”.

CreateTable and AddColumn emit their own comments inline, so this op exists for the case they can’t cover: the help text on an existing column changed. It touches no rows and takes no lock worth naming, so it classifies as OpSafety::Safe.

Fields

table: String

column: String

comment: String

Empty string means “remove the comment”.

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>

AddIndex

Create a composite index, or a composite UNIQUE constraint, on an EXISTING table. Emitted by diff when a model gains a unique_together group or a multi-column indexes entry with no accompanying column change — a case that previously produced NO migration at all, so the constraint was silently never created.

unique selects CREATE UNIQUE INDEX (a unique_together group) vs a plain CREATE INDEX (an indexes group). The index NAME is deterministic — uniq_<table>_<cols> when unique, idx_<table>_<cols> otherwise — so the matching DropIndex can name it. Rendered IF NOT EXISTS on both backends, so it is a safe no-op when a same-migration AlterColumn already rebuilt the table with the constraint (the SQLite dance) — the two never conflict.

Fields

table: String

columns: Vec<String>

unique: bool

DropIndex

Drop a composite index / UNIQUE constraint previously created by an AddIndex, or by a CreateTable that renders its unique_together/indexes as the same deterministically-named indexes. Emitted by diff when a model LOSES a unique_together group or indexes entry. Rendered DROP INDEX IF EXISTS <name> on both backends (the name is recomputed from table + columns + unique, matching AddIndex).

Fields

table: String

columns: Vec<String>

unique: bool

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

Equality operator ==.

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

Inequality operator !=.

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