Struct 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: QualifiedName<'a>,
    pub alter_specifications: Vec<AlterSpecification<'a>>,
}

Represent an alter table statement

let options = ParseOptions::new().dialect(SQLDialect::MariaDB);

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 issues = Issues::new(sql);
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.identifier.as_str() == "t1");
println!("{:#?}", alter.alter_specifications);

let options = ParseOptions::new().dialect(SQLDialect::PostgreSQL);
let sql = "ALTER TABLE t1
    ALTER COLUMN id DROP NOT NULL,
    ALTER COLUMN id SET NOT NULL,
    ALTER COLUMN id SET DEFAULT 47,
    ALTER COLUMN id DROP DEFAULT,
    ALTER COLUMN id TYPE int;";

let mut issues = Issues::new(sql);
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")
};

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: QualifiedName<'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 duplicate 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