Fix: Generic supports CREATE TYPE AS ENUM

Author: jvatic

src/dialect/generic.rs

@@ -156,6 +156,10 @@ impl Dialect for GenericDialect {
         true
     }
 
+    fn supports_create_type_as_enum(&self) -> bool {
+        true
+    }
+
     fn supports_alter_type(&self) -> bool {
         true
     }

src/dialect/mod.rs

@@ -490,6 +490,16 @@ pub trait Dialect: Debug + Any {
         false
     }
 
+    /// Return true if the dialect supports creating enum types
+    ///
+    /// Example:
+    /// ```sql
+    /// CREATE TYPE some_enum AS ENUM('one', 'two', 'three');
+    /// ```
+    fn supports_create_type_as_enum(&self) -> bool {
+        false
+    }
+
     /// Return true if the dialect supports ALTER TYPE statements
     ///
     /// Example:

src/dialect/postgresql.rs

@@ -28,7 +28,6 @@
 // limitations under the License.
 use log::debug;
 
-use crate::ast::{ObjectName, Statement, UserDefinedTypeRepresentation};
 use crate::dialect::{Dialect, Precedence};
 use crate::keywords::Keyword;
 use crate::parser::{Parser, ParserError};
@@ -135,15 +134,6 @@ impl Dialect for PostgreSqlDialect {
         }
     }
 
-    fn parse_statement(&self, parser: &mut Parser) -> Option<Result<Statement, ParserError>> {
-        if parser.parse_keyword(Keyword::CREATE) {
-            parser.prev_token(); // unconsume the CREATE in case we don't end up parsing anything
-            parse_create(parser)
-        } else {
-            None
-        }
-    }
-
     fn supports_filter_during_aggregation(&self) -> bool {
         true
     }
@@ -259,41 +249,11 @@ impl Dialect for PostgreSqlDialect {
         true
     }
 
-    fn supports_alter_type(&self) -> bool {
+    fn supports_create_type_as_enum(&self) -> bool {
         true
     }
-}
-
-pub fn parse_create(parser: &mut Parser) -> Option<Result<Statement, ParserError>> {
-    let name = parser.maybe_parse(|parser| -> Result<ObjectName, ParserError> {
-        parser.expect_keyword_is(Keyword::CREATE)?;
-        parser.expect_keyword_is(Keyword::TYPE)?;
-        let name = parser.parse_object_name(false)?;
-        parser.expect_keyword_is(Keyword::AS)?;
-        parser.expect_keyword_is(Keyword::ENUM)?;
-        Ok(name)
-    });
-
-    match name {
-        Ok(name) => name.map(|name| parse_create_type_as_enum(parser, name)),
-        Err(e) => Some(Err(e)),
-    }
-}
 
-// https://www.postgresql.org/docs/current/sql-createtype.html
-pub fn parse_create_type_as_enum(
-    parser: &mut Parser,
-    name: ObjectName,
-) -> Result<Statement, ParserError> {
-    if !parser.consume_token(&Token::LParen) {
-        return parser.expected("'(' after CREATE TYPE AS ENUM", parser.peek_token());
+    fn supports_alter_type(&self) -> bool {
+        true
     }
-
-    let labels = parser.parse_comma_separated0(|p| p.parse_identifier(), Token::RParen)?;
-    parser.expect_token(&Token::RParen)?;
-
-    Ok(Statement::CreateType {
-        name,
-        representation: UserDefinedTypeRepresentation::Enum { labels },
-    })
 }

src/parser/mod.rs

@@ -14276,6 +14276,10 @@ impl<'a> Parser<'a> {
         let name = self.parse_object_name(false)?;
         self.expect_keyword_is(Keyword::AS)?;
 
+        if self.dialect.supports_create_type_as_enum() && self.parse_keyword(Keyword::ENUM) {
+            return self.parse_create_type_enum(name);
+        }
+
         let mut attributes = vec![];
         if !self.consume_token(&Token::LParen) || self.consume_token(&Token::RParen) {
             return Ok(Statement::CreateType {
@@ -14312,6 +14316,21 @@ impl<'a> Parser<'a> {
         })
     }
 
+    // See [PostgreSQL](https://www.postgresql.org/docs/current/sql-createtype.html)
+    pub fn parse_create_type_enum(&mut self, name: ObjectName) -> Result<Statement, ParserError> {
+        if !self.consume_token(&Token::LParen) {
+            return self.expected("'(' after CREATE TYPE AS ENUM", self.peek_token());
+        }
+
+        let labels = self.parse_comma_separated0(|p| p.parse_identifier(), Token::RParen)?;
+        self.expect_token(&Token::RParen)?;
+
+        Ok(Statement::CreateType {
+            name,
+            representation: UserDefinedTypeRepresentation::Enum { labels },
+        })
+    }
+
     fn parse_parenthesized_identifiers(&mut self) -> Result<Vec<Ident>, ParserError> {
         self.expect_token(&Token::LParen)?;
         let partitions = self.parse_comma_separated(|p| p.parse_identifier())?;

tests/sqlparser_postgres.rs

@@ -5293,7 +5293,7 @@ fn arrow_cast_precedence() {
 
 #[test]
 fn parse_create_type_as_enum() {
-    let statement = pg().one_statement_parses_to(
+    let statement = pg_and_generic().one_statement_parses_to(
         r#"CREATE TYPE public.my_type AS ENUM (
             'label1',
             'label2',