Struct sql_parse::AlterTable

pub struct AlterTable<'a> {
    pub alter_span: Span,
    pub online: Option<Span>,
    pub ignore: Option<Span>,
    pub table_span: Span,
    pub if_exists: Option<Span>,
    pub table: Identifier<'a>,
    pub alter_specifications: Vec<AlterSpecification<'a>>,
}

Represent an alter table statement

let sql = "ALTER TABLE `t1`
    MODIFY `id` int(11) NOT NULL AUTO_INCREMENT,
    ADD CONSTRAINT `t1_t2` FOREIGN KEY (`two`) REFERENCES `t2` (`id`);";

let mut stmts = parse_statements(sql, &mut issues, &options);

let alter: AlterTable = match stmts.pop() {
    Some(Statement::AlterTable(a)) => a,
    _ => panic!("We should get an alter table statement")
};

assert!(alter.table.as_str() == "t1");
println!("{:#?}", alter.alter_specifications)

Fields

alter_span: Span

Span of “ALTER”

online: Option<Span>

Span of “ONLINE” if specified

ignore: Option<Span>

Span of “IGNORE” if specified

table_span: Span

Span of “TABLE”

if_exists: Option<Span>

Span of “IF EXISTS” if specified

table: Identifier<'a>

The identifier of the table to alter

alter_specifications: Vec<AlterSpecification<'a>>

List of alterations to do

Trait Implementations

impl<'a> Clone for AlterTable<'a>

fn clone(&self) -> AlterTable<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for AlterTable<'a>

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

Formats the value using the given formatter.

impl<'a> Spanned for AlterTable<'a>

fn span(&self) -> Span

Compute byte span of an ast fragment

fn join_span(&self, other: &impl OptSpanned) -> Span

Compute the minimal span containing both self and other