Struct sql_parse::CreateTable

pub struct CreateTable<'a> {
    pub create_span: Span,
    pub create_options: Vec<CreateOption<'a>>,
    pub table_span: Span,
    pub identifier: QualifiedName<'a>,
    pub if_not_exists: Option<Span>,
    pub create_definitions: Vec<CreateDefinition<'a>>,
    pub options: Vec<TableOption<'a>>,
}

Represent a create table statement

let sql = "CREATE TABLE `parts` (
        `id` int(11) NOT NULL COMMENT 'THIS IS THE ID FIELD',
        `hash` varchar(64) COLLATE utf8_bin NOT NULL,
        `destination` varchar(64) COLLATE utf8_bin NOT NULL,
        `part` varchar(64) COLLATE utf8_bin NOT NULL,
        `success` tinyint(1) NOT NULL
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin;";

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

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

assert!(create.identifier.identifier.as_str() == "parts");
println!("{:#?}", create.create_definitions)

Fields

create_span: Span

Span of “CREATE”

create_options: Vec<CreateOption<'a>>

Options specified after “CREATE”

table_span: Span

Span of “TABLE”

identifier: QualifiedName<'a>

Name of the table

if_not_exists: Option<Span>

Span of “IF NOT EXISTS” if specified

create_definitions: Vec<CreateDefinition<'a>>

Definitions of table members

options: Vec<TableOption<'a>>

Options specified after the table creation

Trait Implementations

impl<'a> Clone for CreateTable<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for CreateTable<'a>

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

Formats the value using the given formatter.

impl<'a> Spanned for CreateTable<'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