Redshift: CREATE TABLE ... (LIKE ..) (#1967)

src/ast/ddl.rs

@@ -31,12 +31,12 @@ use sqlparser_derive::{Visit, VisitMut};
 use crate::ast::value::escape_single_quote_string;
 use crate::ast::{
     display_comma_separated, display_separated, ArgMode, CommentDef, CreateFunctionBody,
-    CreateFunctionUsing, CreateTableOptions, DataType, Expr, FileFormat, FunctionBehavior,
+    CreateFunctionUsing, CreateTableLikeKind, CreateTableOptions, DataType, Expr, FileFormat,
-    FunctionCalledOnNull, FunctionDeterminismSpecifier, FunctionParallel, HiveDistributionStyle,
+    FunctionBehavior, FunctionCalledOnNull, FunctionDeterminismSpecifier, FunctionParallel,
-    HiveFormat, HiveIOFormat, HiveRowFormat, Ident, MySQLColumnPosition, ObjectName, OnCommit,
+    HiveDistributionStyle, HiveFormat, HiveIOFormat, HiveRowFormat, Ident, MySQLColumnPosition,
-    OneOrManyWithParens, OperateFunctionArg, OrderByExpr, ProjectionSelect, Query, RowAccessPolicy,
+    ObjectName, OnCommit, OneOrManyWithParens, OperateFunctionArg, OrderByExpr, ProjectionSelect,
-    SequenceOptions, Spanned, SqlOption, StorageSerializationPolicy, Tag, Value, ValueWithSpan,
+    Query, RowAccessPolicy, SequenceOptions, Spanned, SqlOption, StorageSerializationPolicy, Tag,
-    WrappedCollection,
+    Value, ValueWithSpan, WrappedCollection,
 };
 use crate::display_utils::{DisplayCommaSeparated, Indent, NewLine, SpaceOrNewline};
 use crate::keywords::Keyword;
@@ -2430,7 +2430,7 @@ pub struct CreateTable {
     pub location: Option<String>,
     pub query: Option<Box<Query>>,
     pub without_rowid: bool,
-    pub like: Option<ObjectName>,
+    pub like: Option<CreateTableLikeKind>,
     pub clone: Option<ObjectName>,
     // For Hive dialect, the table comment is after the column definitions without `=`,
     // so the `comment` field is optional and different than the comment field in the general options list.
@@ -2559,6 +2559,8 @@ impl fmt::Display for CreateTable {
         } else if self.query.is_none() && self.like.is_none() && self.clone.is_none() {
             // PostgreSQL allows `CREATE TABLE t ();`, but requires empty parens
             f.write_str(" ()")?;
+        } else if let Some(CreateTableLikeKind::Parenthesized(like_in_columns_list)) = &self.like {
+            write!(f, " ({like_in_columns_list})")?;
         }
 
         // Hive table comment should be after column definitions, please refer to:
@@ -2572,9 +2574,8 @@ impl fmt::Display for CreateTable {
             write!(f, " WITHOUT ROWID")?;
         }
 
-        // Only for Hive
+        if let Some(CreateTableLikeKind::Plain(like)) = &self.like {
-        if let Some(l) = &self.like {
+            write!(f, " {like}")?;
-            write!(f, " LIKE {l}")?;
         }
 
         if let Some(c) = &self.clone {

src/ast/helpers/stmt_create_table.rs

@@ -25,10 +25,10 @@ use serde::{Deserialize, Serialize};
 use sqlparser_derive::{Visit, VisitMut};
 
 use crate::ast::{
-    ClusteredBy, ColumnDef, CommentDef, CreateTable, CreateTableOptions, Expr, FileFormat,
+    ClusteredBy, ColumnDef, CommentDef, CreateTable, CreateTableLikeKind, CreateTableOptions, Expr,
-    HiveDistributionStyle, HiveFormat, Ident, ObjectName, OnCommit, OneOrManyWithParens, Query,
+    FileFormat, HiveDistributionStyle, HiveFormat, Ident, ObjectName, OnCommit,
-    RowAccessPolicy, Statement, StorageSerializationPolicy, TableConstraint, Tag,
+    OneOrManyWithParens, Query, RowAccessPolicy, Statement, StorageSerializationPolicy,
-    WrappedCollection,
+    TableConstraint, Tag, WrappedCollection,
 };
 
 use crate::parser::ParserError;
@@ -81,7 +81,7 @@ pub struct CreateTableBuilder {
     pub location: Option<String>,
     pub query: Option<Box<Query>>,
     pub without_rowid: bool,
-    pub like: Option<ObjectName>,
+    pub like: Option<CreateTableLikeKind>,
     pub clone: Option<ObjectName>,
     pub comment: Option<CommentDef>,
     pub on_commit: Option<OnCommit>,
@@ -237,7 +237,7 @@ impl CreateTableBuilder {
         self
     }
 
-    pub fn like(mut self, like: Option<ObjectName>) -> Self {
+    pub fn like(mut self, like: Option<CreateTableLikeKind>) -> Self {
         self.like = like;
         self
     }

src/ast/mod.rs

@@ -10465,6 +10465,62 @@ impl fmt::Display for CreateUser {
     }
 }
 
+/// Specifies how to create a new table based on an existing table's schema.
+/// '''sql
+/// CREATE TABLE new LIKE old ...
+/// '''
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum CreateTableLikeKind {
+    /// '''sql
+    /// CREATE TABLE new (LIKE old ...)
+    /// '''
+    /// [Redshift](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_TABLE_NEW.html)
+    Parenthesized(CreateTableLike),
+    /// '''sql
+    /// CREATE TABLE new LIKE old ...
+    /// '''
+    /// [Snowflake](https://docs.snowflake.com/en/sql-reference/sql/create-table#label-create-table-like)
+    /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#create_table_like)
+    Plain(CreateTableLike),
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum CreateTableLikeDefaults {
+    Including,
+    Excluding,
+}
+
+impl fmt::Display for CreateTableLikeDefaults {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            CreateTableLikeDefaults::Including => write!(f, "INCLUDING DEFAULTS"),
+            CreateTableLikeDefaults::Excluding => write!(f, "EXCLUDING DEFAULTS"),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct CreateTableLike {
+    pub name: ObjectName,
+    pub defaults: Option<CreateTableLikeDefaults>,
+}
+
+impl fmt::Display for CreateTableLike {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "LIKE {}", self.name)?;
+        if let Some(defaults) = &self.defaults {
+            write!(f, " {defaults}")?;
+        }
+        Ok(())
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::tokenizer::Location;

src/ast/spans.rs

@@ -592,7 +592,7 @@ impl Spanned for CreateTable {
             location: _,          // string, no span
             query,
             without_rowid: _, // bool
-            like,
+            like: _,
             clone,
             comment: _, // todo, no span
             on_commit: _,
@@ -627,7 +627,6 @@ impl Spanned for CreateTable {
                 .chain(columns.iter().map(|i| i.span()))
                 .chain(constraints.iter().map(|i| i.span()))
                 .chain(query.iter().map(|i| i.span()))
-                .chain(like.iter().map(|i| i.span()))
                 .chain(clone.iter().map(|i| i.span())),
         )
     }

src/dialect/mod.rs

@@ -1163,6 +1163,25 @@ pub trait Dialect: Debug + Any {
     fn supports_interval_options(&self) -> bool {
         false
     }
+
+    /// Returns true if the dialect supports specifying which table to copy
+    /// the schema from inside parenthesis.
+    ///
+    /// Not parenthesized:
+    /// '''sql
+    /// CREATE TABLE new LIKE old ...
+    /// '''
+    /// [Snowflake](https://docs.snowflake.com/en/sql-reference/sql/create-table#label-create-table-like)
+    /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#create_table_like)
+    ///
+    /// Parenthesized:
+    /// '''sql
+    /// CREATE TABLE new (LIKE old ...)
+    /// '''
+    /// [Redshift](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_TABLE_NEW.html)
+    fn supports_create_table_like_parenthesized(&self) -> bool {
+        false
+    }
 }
 
 /// This represents the operators for which precedence must be defined

src/dialect/redshift.rs

@@ -139,4 +139,8 @@ impl Dialect for RedshiftSqlDialect {
     fn supports_select_exclude(&self) -> bool {
         true
     }
+
+    fn supports_create_table_like_parenthesized(&self) -> bool {
+        true
+    }
 }

src/dialect/snowflake.rs

@@ -27,10 +27,10 @@ use crate::ast::helpers::stmt_data_loading::{
 };
 use crate::ast::{
     CatalogSyncNamespaceMode, ColumnOption, ColumnPolicy, ColumnPolicyProperty, ContactEntry,
-    CopyIntoSnowflakeKind, DollarQuotedString, Ident, IdentityParameters, IdentityProperty,
+    CopyIntoSnowflakeKind, CreateTableLikeKind, DollarQuotedString, Ident, IdentityParameters,
-    IdentityPropertyFormatKind, IdentityPropertyKind, IdentityPropertyOrder, ObjectName,
+    IdentityProperty, IdentityPropertyFormatKind, IdentityPropertyKind, IdentityPropertyOrder,
-    ObjectNamePart, RowAccessPolicy, ShowObjects, SqlOption, Statement, StorageSerializationPolicy,
+    ObjectName, ObjectNamePart, RowAccessPolicy, ShowObjects, SqlOption, Statement,
-    TagsColumnOption, WrappedCollection,
+    StorageSerializationPolicy, TagsColumnOption, WrappedCollection,
 };
 use crate::dialect::{Dialect, Precedence};
 use crate::keywords::Keyword;
@@ -668,8 +668,13 @@ pub fn parse_create_table(
                     builder = builder.clone_clause(clone);
                 }
                 Keyword::LIKE => {
-                    let like = parser.parse_object_name(false).ok();
+                    let name = parser.parse_object_name(false)?;
-                    builder = builder.like(like);
+                    builder = builder.like(Some(CreateTableLikeKind::Plain(
+                        crate::ast::CreateTableLike {
+                            name,
+                            defaults: None,
+                        },
+                    )));
                 }
                 Keyword::CLUSTER => {
                     parser.expect_keyword_is(Keyword::BY)?;

src/keywords.rs

@@ -268,6 +268,7 @@ define_keywords!(
     DECLARE,
     DEDUPLICATE,
     DEFAULT,
+    DEFAULTS,
     DEFAULT_DDL_COLLATION,
     DEFERRABLE,
     DEFERRED,
@@ -339,6 +340,7 @@ define_keywords!(
     EXCEPTION,
     EXCHANGE,
     EXCLUDE,
+    EXCLUDING,
     EXCLUSIVE,
     EXEC,
     EXECUTE,
@@ -441,6 +443,7 @@ define_keywords!(
     IN,
     INCLUDE,
     INCLUDE_NULL_VALUES,
+    INCLUDING,
     INCREMENT,
     INDEX,
     INDICATOR,

src/parser/mod.rs

@@ -7347,11 +7347,7 @@ impl<'a> Parser<'a> {
         // Clickhouse has `ON CLUSTER 'cluster'` syntax for DDLs
         let on_cluster = self.parse_optional_on_cluster()?;
 
-        let like = if self.parse_keyword(Keyword::LIKE) || self.parse_keyword(Keyword::ILIKE) {
+        let like = self.maybe_parse_create_table_like(allow_unquoted_hyphen)?;
-            self.parse_object_name(allow_unquoted_hyphen).ok()
-        } else {
-            None
-        };
 
         let clone = if self.parse_keyword(Keyword::CLONE) {
             self.parse_object_name(allow_unquoted_hyphen).ok()
@@ -7455,6 +7451,44 @@ impl<'a> Parser<'a> {
             .build())
     }
 
+    fn maybe_parse_create_table_like(
+        &mut self,
+        allow_unquoted_hyphen: bool,
+    ) -> Result<Option<CreateTableLikeKind>, ParserError> {
+        let like = if self.dialect.supports_create_table_like_parenthesized()
+            && self.consume_token(&Token::LParen)
+        {
+            if self.parse_keyword(Keyword::LIKE) {
+                let name = self.parse_object_name(allow_unquoted_hyphen)?;
+                let defaults = if self.parse_keywords(&[Keyword::INCLUDING, Keyword::DEFAULTS]) {
+                    Some(CreateTableLikeDefaults::Including)
+                } else if self.parse_keywords(&[Keyword::EXCLUDING, Keyword::DEFAULTS]) {
+                    Some(CreateTableLikeDefaults::Excluding)
+                } else {
+                    None
+                };
+                self.expect_token(&Token::RParen)?;
+                Some(CreateTableLikeKind::Parenthesized(CreateTableLike {
+                    name,
+                    defaults,
+                }))
+            } else {
+                // Rollback the '(' it's probably the columns list
+                self.prev_token();
+                None
+            }
+        } else if self.parse_keyword(Keyword::LIKE) || self.parse_keyword(Keyword::ILIKE) {
+            let name = self.parse_object_name(allow_unquoted_hyphen)?;
+            Some(CreateTableLikeKind::Plain(CreateTableLike {
+                name,
+                defaults: None,
+            }))
+        } else {
+            None
+        };
+        Ok(like)
+    }
+
     pub(crate) fn parse_create_table_on_commit(&mut self) -> Result<OnCommit, ParserError> {
         if self.parse_keywords(&[Keyword::DELETE, Keyword::ROWS]) {
             Ok(OnCommit::DeleteRows)

tests/sqlparser_common.rs

@@ -16655,3 +16655,77 @@ fn test_parse_default_with_collate_column_option() {
         panic!("Expected create table statement");
     }
 }
+
+#[test]
+fn parse_create_table_like() {
+    let dialects = all_dialects_except(|d| d.supports_create_table_like_parenthesized());
+    let sql = "CREATE TABLE new LIKE old";
+    match dialects.verified_stmt(sql) {
+        Statement::CreateTable(stmt) => {
+            assert_eq!(
+                stmt.name,
+                ObjectName::from(vec![Ident::new("new".to_string())])
+            );
+            assert_eq!(
+                stmt.like,
+                Some(CreateTableLikeKind::Plain(CreateTableLike {
+                    name: ObjectName::from(vec![Ident::new("old".to_string())]),
+                    defaults: None,
+                }))
+            )
+        }
+        _ => unreachable!(),
+    }
+    let dialects = all_dialects_where(|d| d.supports_create_table_like_parenthesized());
+    let sql = "CREATE TABLE new (LIKE old)";
+    match dialects.verified_stmt(sql) {
+        Statement::CreateTable(stmt) => {
+            assert_eq!(
+                stmt.name,
+                ObjectName::from(vec![Ident::new("new".to_string())])
+            );
+            assert_eq!(
+                stmt.like,
+                Some(CreateTableLikeKind::Parenthesized(CreateTableLike {
+                    name: ObjectName::from(vec![Ident::new("old".to_string())]),
+                    defaults: None,
+                }))
+            )
+        }
+        _ => unreachable!(),
+    }
+    let sql = "CREATE TABLE new (LIKE old INCLUDING DEFAULTS)";
+    match dialects.verified_stmt(sql) {
+        Statement::CreateTable(stmt) => {
+            assert_eq!(
+                stmt.name,
+                ObjectName::from(vec![Ident::new("new".to_string())])
+            );
+            assert_eq!(
+                stmt.like,
+                Some(CreateTableLikeKind::Parenthesized(CreateTableLike {
+                    name: ObjectName::from(vec![Ident::new("old".to_string())]),
+                    defaults: Some(CreateTableLikeDefaults::Including),
+                }))
+            )
+        }
+        _ => unreachable!(),
+    }
+    let sql = "CREATE TABLE new (LIKE old EXCLUDING DEFAULTS)";
+    match dialects.verified_stmt(sql) {
+        Statement::CreateTable(stmt) => {
+            assert_eq!(
+                stmt.name,
+                ObjectName::from(vec![Ident::new("new".to_string())])
+            );
+            assert_eq!(
+                stmt.like,
+                Some(CreateTableLikeKind::Parenthesized(CreateTableLike {
+                    name: ObjectName::from(vec![Ident::new("old".to_string())]),
+                    defaults: Some(CreateTableLikeDefaults::Excluding),
+                }))
+            )
+        }
+        _ => unreachable!(),
+    }
+}