Struct sea_orm_migration::prelude::extension::postgres::TypeAlterStatement

pub struct TypeAlterStatement { /* private fields */ }

Implementations

impl TypeAlterStatement

pub fn new() -> TypeAlterStatement

pub fn name<T>(self, name: T) -> TypeAlterStatement where
    T: IntoIden, 

Change the definition of a type

use sea_query::{extension::postgres::Type, *};

enum FontFamily {
    Type,
    Serif,
    Sans,
    Monospace,
}

impl Iden for FontFamily {
    fn unquoted(&self, s: &mut dyn std::fmt::Write) {
        write!(
            s,
            "{}",
            match self {
                Self::Type => "font_family",
                Self::Serif => "serif",
                Self::Sans => "sans",
                Self::Monospace => "monospace",
            }
        )
        .unwrap();
    }
}

assert_eq!(
    Type::alter()
        .name(FontFamily::Type)
        .add_value(Alias::new("cursive"))
        .to_string(PostgresQueryBuilder),
    r#"ALTER TYPE "font_family" ADD VALUE 'cursive'"#
);

pub fn add_value<T>(self, value: T) -> TypeAlterStatement where
    T: IntoIden, 

pub fn before<T>(self, value: T) -> TypeAlterStatement where
    T: IntoIden, 

Add a enum value before an existing value

use sea_query::{extension::postgres::Type, tests_cfg::*, *};

assert_eq!(
    Type::alter()
        .name(Font::Table)
        .add_value(Alias::new("weight"))
        .before(Font::Variant)
        .to_string(PostgresQueryBuilder),
    r#"ALTER TYPE "font" ADD VALUE 'weight' BEFORE 'variant'"#
)

pub fn after<T>(self, value: T) -> TypeAlterStatement where
    T: IntoIden, 

pub fn rename_to<T>(self, name: T) -> TypeAlterStatement where
    T: IntoIden, 

pub fn rename_value<T, V>(self, existing: T, new_name: V) -> TypeAlterStatement where
    T: IntoIden,
    V: IntoIden, 

Rename a enum value

use sea_query::{extension::postgres::Type, tests_cfg::*, *};

assert_eq!(
    Type::alter()
        .name(Font::Table)
        .rename_value(Alias::new("variant"), Alias::new("language"))
        .to_string(PostgresQueryBuilder),
    r#"ALTER TYPE "font" RENAME VALUE 'variant' TO 'language'"#
)

pub fn build<T>(&self, type_builder: T) -> (String, Vec<Value, Global>) where
    T: TypeBuilder, 

pub fn build_ref<T>(&self, type_builder: &T) -> (String, Vec<Value, Global>) where
    T: TypeBuilder, 

pub fn build_collect<T>(
    &self,
    type_builder: T,
    collector: &mut dyn FnMut(Value)
) -> String where
    T: TypeBuilder, 

pub fn build_collect_ref<T>(
    &self,
    type_builder: &T,
    collector: &mut dyn FnMut(Value)
) -> String where
    T: TypeBuilder, 

pub fn to_string<T>(&self, type_builder: T) -> String where
    T: TypeBuilder + QueryBuilder, 

Build corresponding SQL statement and return SQL string

Trait Implementations

impl Clone for TypeAlterStatement

fn clone(&self) -> TypeAlterStatement

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TypeAlterStatement

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

Formats the value using the given formatter.

impl Default for TypeAlterStatement

fn default() -> TypeAlterStatement

Returns the “default value” for a type.

impl StatementBuilder for TypeAlterStatement

fn build(&self, db_backend: &DatabaseBackend) -> Statement

Method to call in order to build a Statement