Enum ColumnEvolution 

#[non_exhaustive]
pub enum ColumnEvolution<'a> {
    AddColumn {
        schema: Option<&'a str>,
        table: &'a str,
        column: &'a str,
        data_type: &'a DataType,
    },
    WidenColumn {
        schema: Option<&'a str>,
        table: &'a str,
        column: &'a str,
        data_type: &'a DataType,
    },
    AddNestedField {
        schema: Option<&'a str>,
        table: &'a str,
        column: &'a str,
        field: &'a str,
        data_type: &'a DataType,
    },
    RequireColumn {
        schema: Option<&'a str>,
        table: &'a str,
        column: &'a str,
        data_type: &'a DataType,
    },
}

One change to a table that already holds rows, handed to the dialect to spell.

The schema and table arrive unqualified and unquoted, because the dialect knows how it qualifies and quotes them. The type arrives as a DataType — Razeri’s own, so the dialect renders it the way it renders every other column of that type, and the statement cannot disagree with the CREATE that would have built the same column.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

AddColumn

A column the table does not have yet, which accepts no value today.

Fields

schema: Option<&'a str>

The table’s schema, absent on engines that have none.

table: &'a str

The table.

column: &'a str

The new column.

data_type: &'a DataType

The type it is declared with.

WidenColumn

A column whose declared type now holds more than it held.

Fields

schema: Option<&'a str>

The table’s schema, absent on engines that have none.

table: &'a str

The table.

column: &'a str

The column.

data_type: &'a DataType

The type it is declared with now.

AddNestedField

A record column that gained a field, and gained nothing else.

Fields

schema: Option<&'a str>

The table’s schema, absent on engines that have none.

table: &'a str

The table.

column: &'a str

The column whose record grew.

field: &'a str

The path from the column to the new field, dotted through the records that contain it — for a dialect whose engine names the field rather than restating the column.

data_type: &'a DataType

The column’s whole type, with the new field in it. An engine that makes this change by restating the column’s shape needs all of it; an engine that names the field alone reads field instead.

RequireColumn

A column that may no longer be left empty, asked once every row the table holds has a value in it.

A new column a design requires is added without its NOT NULL, because the rows a table already holds have no value to give it. Once they do, this is the step that requires it: ALTER TABLE … ALTER COLUMN … SET NOT NULL on some engines, MODIFY … NOT NULL with the type restated on others. data_type is the column’s type, for an engine that restates it.

Fields

schema: Option<&'a str>

The table’s schema, absent on engines that have none.

table: &'a str

The table.

column: &'a str

The column.

data_type: &'a DataType

The type it is declared with.

Implementations

impl ColumnEvolution<'_>

pub const fn schema(&self) -> Option<&str>

The table’s schema, whichever change this is.

pub const fn table(&self) -> &str

The table, whichever change this is.

pub const fn column(&self) -> &str

The column, whichever change this is.

pub const fn data_type(&self) -> &DataType

The type the column is declared with after the change.

Trait Implementations

impl<'a> Clone for ColumnEvolution<'a>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for ColumnEvolution<'a>

impl<'a> Debug for ColumnEvolution<'a>

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

Formats the value using the given formatter.