Encapsulate CreateTable

Author: philipcristiano

src/ast/dml.rs

@@ -11,18 +11,76 @@
 // limitations under the License.
 
 #[cfg(not(feature = "std"))]
-use alloc::{boxed::Box, vec::Vec};
+use alloc::{boxed::Box, string::String, vec::Vec};
 
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 #[cfg(feature = "visitor")]
 use sqlparser_derive::{Visit, VisitMut};
 
+pub use super::ddl::{ColumnDef, TableConstraint};
+
 use super::{
-    Expr, FromTable, Ident, InsertAliases, MysqlInsertPriority, ObjectName, OnInsert, OrderByExpr,
-    Query, SelectItem, SqliteOnConflict, TableWithJoins,
+    Expr, FileFormat, FromTable, HiveDistributionStyle, HiveFormat, Ident, InsertAliases,
+    MysqlInsertPriority, ObjectName, OnCommit, OnInsert, OrderByExpr, Query, SelectItem, SqlOption,
+    SqliteOnConflict, TableWithJoins,
 };
 
+/// CREATE TABLE statement.
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct CreateTable {
+    pub or_replace: bool,
+    pub temporary: bool,
+    pub external: bool,
+    pub global: Option<bool>,
+    pub if_not_exists: bool,
+    pub transient: bool,
+    /// Table name
+    #[cfg_attr(feature = "visitor", visit(with = "visit_relation"))]
+    pub name: ObjectName,
+    /// Optional schema
+    pub columns: Vec<ColumnDef>,
+    pub constraints: Vec<TableConstraint>,
+    pub hive_distribution: HiveDistributionStyle,
+    pub hive_formats: Option<HiveFormat>,
+    pub table_properties: Vec<SqlOption>,
+    pub with_options: Vec<SqlOption>,
+    pub file_format: Option<FileFormat>,
+    pub location: Option<String>,
+    pub query: Option<Box<Query>>,
+    pub without_rowid: bool,
+    pub like: Option<ObjectName>,
+    pub clone: Option<ObjectName>,
+    pub engine: Option<String>,
+    pub comment: Option<String>,
+    pub auto_increment_offset: Option<u32>,
+    pub default_charset: Option<String>,
+    pub collation: Option<String>,
+    pub on_commit: Option<OnCommit>,
+    /// ClickHouse "ON CLUSTER" clause:
+    /// <https://clickhouse.com/docs/en/sql-reference/distributed-ddl/>
+    pub on_cluster: Option<String>,
+    /// ClickHouse "ORDER BY " clause. Note that omitted ORDER BY is different
+    /// than empty (represented as ()), the latter meaning "no sorting".
+    /// <https://clickhouse.com/docs/en/sql-reference/statements/create/table/>
+    pub order_by: Option<Vec<Ident>>,
+    /// BigQuery: A partition expression for the table.
+    /// <https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#partition_expression>
+    pub partition_by: Option<Box<Expr>>,
+    /// BigQuery: Table clustering column list.
+    /// <https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#table_option_list>
+    pub cluster_by: Option<Vec<Ident>>,
+    /// BigQuery: Table options list.
+    /// <https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#table_option_list>
+    pub options: Option<Vec<SqlOption>>,
+    /// SQLite "STRICT" clause.
+    /// if the "STRICT" table-option keyword is added to the end, after the closing ")",
+    /// then strict typing rules apply to that table.
+    pub strict: bool,
+}
+
 /// INSERT statement.
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

src/ast/helpers/stmt_create_table.rs

@@ -7,6 +7,7 @@ use serde::{Deserialize, Serialize};
 #[cfg(feature = "visitor")]
 use sqlparser_derive::{Visit, VisitMut};
 
+use super::super::dml::CreateTable;
 use crate::ast::{
     ColumnDef, Expr, FileFormat, HiveDistributionStyle, HiveFormat, Ident, ObjectName, OnCommit,
     Query, SqlOption, Statement, TableConstraint,
@@ -263,7 +264,7 @@ impl CreateTableBuilder {
     }
 
     pub fn build(self) -> Statement {
-        Statement::CreateTable {
+        Statement::CreateTable(CreateTable {
             or_replace: self.or_replace,
             temporary: self.temporary,
             external: self.external,
@@ -295,7 +296,7 @@ impl CreateTableBuilder {
             cluster_by: self.cluster_by,
             options: self.options,
             strict: self.strict,
-        }
+        })
     }
 }
 
@@ -306,7 +307,7 @@ impl TryFrom<Statement> for CreateTableBuilder {
     // ownership.
     fn try_from(stmt: Statement) -> Result<Self, Self::Error> {
         match stmt {
-            Statement::CreateTable {
+            Statement::CreateTable(CreateTable {
                 or_replace,
                 temporary,
                 external,
@@ -338,7 +339,7 @@ impl TryFrom<Statement> for CreateTableBuilder {
                 cluster_by,
                 options,
                 strict,
-            } => Ok(Self {
+            }) => Ok(Self {
                 or_replace,
                 temporary,
                 external,

src/ast/mod.rs

@@ -38,7 +38,7 @@ pub use self::ddl::{
     ReferentialAction, TableConstraint, UserDefinedTypeCompositeAttributeDef,
     UserDefinedTypeRepresentation, ViewColumnDef,
 };
-pub use self::dml::{Delete, Insert};
+pub use self::dml::{CreateTable, Delete, Insert};
 pub use self::operator::{BinaryOperator, UnaryOperator};
 pub use self::query::{
     AfterMatchSkip, ConnectBy, Cte, CteAsMaterialized, Distinct, EmptyMatchesMode,
@@ -1968,56 +1968,7 @@ pub enum Statement {
     /// ```sql
     /// CREATE TABLE
     /// ```
-    CreateTable {
-        or_replace: bool,
-        temporary: bool,
-        external: bool,
-        global: Option<bool>,
-        if_not_exists: bool,
-        transient: bool,
-        /// Table name
-        #[cfg_attr(feature = "visitor", visit(with = "visit_relation"))]
-        name: ObjectName,
-        /// Optional schema
-        columns: Vec<ColumnDef>,
-        constraints: Vec<TableConstraint>,
-        hive_distribution: HiveDistributionStyle,
-        hive_formats: Option<HiveFormat>,
-        table_properties: Vec<SqlOption>,
-        with_options: Vec<SqlOption>,
-        file_format: Option<FileFormat>,
-        location: Option<String>,
-        query: Option<Box<Query>>,
-        without_rowid: bool,
-        like: Option<ObjectName>,
-        clone: Option<ObjectName>,
-        engine: Option<String>,
-        comment: Option<String>,
-        auto_increment_offset: Option<u32>,
-        default_charset: Option<String>,
-        collation: Option<String>,
-        on_commit: Option<OnCommit>,
-        /// ClickHouse "ON CLUSTER" clause:
-        /// <https://clickhouse.com/docs/en/sql-reference/distributed-ddl/>
-        on_cluster: Option<String>,
-        /// ClickHouse "ORDER BY " clause. Note that omitted ORDER BY is different
-        /// than empty (represented as ()), the latter meaning "no sorting".
-        /// <https://clickhouse.com/docs/en/sql-reference/statements/create/table/>
-        order_by: Option<Vec<Ident>>,
-        /// BigQuery: A partition expression for the table.
-        /// <https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#partition_expression>
-        partition_by: Option<Box<Expr>>,
-        /// BigQuery: Table clustering column list.
-        /// <https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#table_option_list>
-        cluster_by: Option<Vec<Ident>>,
-        /// BigQuery: Table options list.
-        /// <https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#table_option_list>
-        options: Option<Vec<SqlOption>>,
-        /// SQLite "STRICT" clause.
-        /// if the "STRICT" table-option keyword is added to the end, after the closing ")",
-        /// then strict typing rules apply to that table.
-        strict: bool,
-    },
+    CreateTable(CreateTable),
     /// ```sql
     /// CREATE VIRTUAL TABLE .. USING <module_name> (<module_args>)`
     /// ```
@@ -3257,39 +3208,40 @@ impl fmt::Display for Statement {
                 }
                 Ok(())
             }
-            Statement::CreateTable {
-                name,
-                columns,
-                constraints,
-                table_properties,
-                with_options,
-                or_replace,
-                if_not_exists,
-                transient,
-                hive_distribution,
-                hive_formats,
-                external,
-                global,
-                temporary,
-                file_format,
-                location,
-                query,
-                without_rowid,
-                like,
-                clone,
-                default_charset,
-                engine,
-                comment,
-                auto_increment_offset,
-                collation,
-                on_commit,
-                on_cluster,
-                order_by,
-                partition_by,
-                cluster_by,
-                options,
-                strict,
-            } => {
+            Statement::CreateTable(create_table) => {
+                let CreateTable {
+                    name,
+                    columns,
+                    constraints,
+                    table_properties,
+                    with_options,
+                    or_replace,
+                    if_not_exists,
+                    transient,
+                    hive_distribution,
+                    hive_formats,
+                    external,
+                    global,
+                    temporary,
+                    file_format,
+                    location,
+                    query,
+                    without_rowid,
+                    like,
+                    clone,
+                    default_charset,
+                    engine,
+                    comment,
+                    auto_increment_offset,
+                    collation,
+                    on_commit,
+                    on_cluster,
+                    order_by,
+                    partition_by,
+                    cluster_by,
+                    options,
+                    strict,
+                } = create_table;
                 // We want to allow the following options
                 // Empty column list, allowed by PostgreSQL:
                 //   `CREATE TABLE t ()`

tests/sqlparser_bigquery.rs

@@ -350,7 +350,7 @@ fn parse_create_view_with_unquoted_hyphen() {
 fn parse_create_table_with_unquoted_hyphen() {
     let sql = "CREATE TABLE my-pro-ject.mydataset.mytable (x INT64)";
     match bigquery().verified_stmt(sql) {
-        Statement::CreateTable { name, columns, .. } => {
+        Statement::CreateTable(CreateTable { name, columns, .. }) => {
             assert_eq!(
                 name,
                 ObjectName(vec![
@@ -384,14 +384,14 @@ fn parse_create_table_with_options() {
         r#"OPTIONS(partition_expiration_days = 1, description = "table option description")"#
     );
     match bigquery().verified_stmt(sql) {
-        Statement::CreateTable {
+        Statement::CreateTable(CreateTable {
             name,
             columns,
             partition_by,
             cluster_by,
             options,
             ..
-        } => {
+        }) => {
             assert_eq!(
                 name,
                 ObjectName(vec!["mydataset".into(), "newtable".into()])
@@ -473,7 +473,7 @@ fn parse_create_table_with_options() {
 fn parse_nested_data_types() {
     let sql = "CREATE TABLE table (x STRUCT<a ARRAY<INT64>, b BYTES(42)>, y ARRAY<STRUCT<INT64>>)";
     match bigquery_and_generic().one_statement_parses_to(sql, sql) {
-        Statement::CreateTable { name, columns, .. } => {
+        Statement::CreateTable(CreateTable { name, columns, .. }) => {
             assert_eq!(name, ObjectName(vec!["table".into()]));
             assert_eq!(
                 columns,