Correct handling of enum8 and enum16

Author: lustefaniak

src/ast/data_type.rs

@@ -294,7 +294,12 @@ pub enum DataType {
     /// [clickhouse]: https://clickhouse.com/docs/en/sql-reference/data-types/nested-data-structures/nested
     Nested(Vec<ColumnDef>),
     /// Enums
-    Enum(Vec<String>),
+    Enum(Vec<EnumTypeValue>),
+    /// Enum8
+    ///
+    /// [clickhouse]: https://clickhouse.com/docs/en/sql-reference/data-types/enum
+    Enum8(Vec<EnumTypeValue>),
+    Enum16(Vec<EnumTypeValue>),
     /// Set
     Set(Vec<String>),
     /// Struct
@@ -497,15 +502,15 @@ impl fmt::Display for DataType {
                 }
             }
             DataType::Enum(vals) => {
-                write!(f, "ENUM(")?;
-                for (i, v) in vals.iter().enumerate() {
-                    if i != 0 {
-                        write!(f, ", ")?;
-                    }
-                    write!(f, "'{}'", escape_single_quote_string(v))?;
-                }
-                write!(f, ")")
+                write!(f, "ENUM({})", display_comma_separated(vals))
+            }
+            DataType::Enum8(vals) => {
+                write!(f, "ENUM8({})", display_comma_separated(vals))
+            }
+            DataType::Enum16(vals) => {
+                write!(f, "ENUM16({})", display_comma_separated(vals))
             }
+
             DataType::Set(vals) => {
                 write!(f, "SET(")?;
                 for (i, v) in vals.iter().enumerate() {
@@ -786,3 +791,30 @@ pub enum ArrayElemTypeDef {
     /// `Array(Int64)`
     Parenthesis(Box<DataType>),
 }
+
+
+/// String enum values with optional integer value.
+///
+/// [1]: https://clickhouse.com/docs/en/sql-reference/data-types/enum
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum EnumTypeValue {
+    /// 'world'
+    Name(String),
+    /// 'hello'=1
+    NameWithValue(String, i64),
+}
+
+impl fmt::Display for EnumTypeValue {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Name(n) => {
+                write!(f, "'{}'", escape_single_quote_string(n))
+            }
+            Self::NameWithValue(n,v) => {
+                write!(f, "'{}' = {}", escape_single_quote_string(n),v)
+            }
+        }
+    }
+}

src/ast/mod.rs

@@ -29,7 +29,7 @@ use serde::{Deserialize, Serialize};
 use sqlparser_derive::{Visit, VisitMut};
 
 pub use self::data_type::{
-    ArrayElemTypeDef, CharLengthUnits, CharacterLength, DataType, ExactNumberInfo, TimezoneInfo,
+    ArrayElemTypeDef, CharLengthUnits, CharacterLength, DataType, ExactNumberInfo, TimezoneInfo, EnumTypeValue,
 };
 pub use self::dcl::{AlterRoleOperation, ResetConfig, RoleOption, SetConfigValue};
 pub use self::ddl::{

src/keywords.rs

@@ -259,6 +259,8 @@ define_keywords!(
     ENFORCED,
     ENGINE,
     ENUM,
+    ENUM16,
+    ENUM8,
     EPHEMERAL,
     EPOCH,
     EQUALS,

src/parser/mod.rs

@@ -5900,6 +5900,18 @@ impl<'a> Parser<'a> {
         }
     }
 
+    /// Parse an literal integer/long
+    pub fn parse_literal_int(&mut self) -> Result<i64, ParserError> {
+        let neg = if self.consume_token(&Token::Minus) { -1 } else { 1 };
+        let next_token = self.next_token();
+        match next_token.token {
+            Token::Number(s, _) => s.parse::<i64>().map(|n| n*neg).map_err(|e| {
+                ParserError::ParserError(format!("Could not parse '{s}' as i64: {e}"))
+            }),
+            _ => self.expected("literal int", next_token),
+        }
+    }
+
     pub fn parse_function_definition(&mut self) -> Result<FunctionDefinition, ParserError> {
         let peek_token = self.peek_token();
         match peek_token.token {
@@ -6184,7 +6196,9 @@ impl<'a> Parser<'a> {
                 Keyword::BIGDECIMAL => Ok(DataType::BigDecimal(
                     self.parse_exact_number_optional_precision_scale()?,
                 )),
-                Keyword::ENUM => Ok(DataType::Enum(self.parse_string_values()?)),
+                Keyword::ENUM => Ok(DataType::Enum(self.parse_enum_values()?)),
+                Keyword::ENUM8 => Ok(DataType::Enum8(self.parse_enum_values()?)),
+                Keyword::ENUM16 => Ok(DataType::Enum16(self.parse_enum_values()?)),
                 Keyword::SET => Ok(DataType::Set(self.parse_string_values()?)),
                 Keyword::ARRAY => {
                     if dialect_of!(self is SnowflakeDialect) {
@@ -6291,6 +6305,37 @@ impl<'a> Parser<'a> {
         Ok(values)
     }
 
+    pub fn parse_enum_values(&mut self) -> Result<Vec<EnumTypeValue>, ParserError> {
+        self.expect_token(&Token::LParen)?;
+        let mut values:Vec<EnumTypeValue> = Vec::new();
+        loop {
+            let next_token = self.next_token();
+            let name = match next_token.token {
+                Token::SingleQuotedString(value) => value,
+                _ => self.expected("a string", next_token)?,
+            };
+            let next_token = self.next_token();
+            match next_token.token {
+                Token::Eq => {
+                    values.push(EnumTypeValue::NameWithValue(name, self.parse_literal_int()?));
+                    if self.consume_token(&Token::RParen) {
+                        break;
+                    }
+                    if self.consume_token(&Token::Comma) {
+                        continue;
+                    }
+                }
+                Token::Comma => values.push(EnumTypeValue::Name(name)),
+                Token::RParen => {
+                    values.push(EnumTypeValue::Name(name));
+                    break
+                },
+                _ => self.expected(", or }", next_token)?,
+            }
+        }
+        Ok(values)
+    }
+
     /// Strictly parse `identifier AS identifier`
     pub fn parse_identifier_with_alias(&mut self) -> Result<IdentWithAlias, ParserError> {
         let ident = self.parse_identifier(false)?.unwrap();

tests/sqlparser_clickhouse.rs

@@ -603,7 +603,8 @@ fn parse_create_table_with_variant_default_expressions() {
         "a DATETIME MATERIALIZED now(),",
         " b DATETIME EPHEMERAL now(),",
         " c DATETIME EPHEMERAL,",
-        " d STRING ALIAS toString(c)",
+        " d STRING ALIAS toString(c),",
+        " x ENUM8('hello' = 1, 'world', 'foo' = -3)",
         ") ENGINE=MergeTree"
     );
     match clickhouse().verified_stmt(sql) {
@@ -697,6 +698,16 @@ fn parse_create_table_with_variant_default_expressions() {
                         column_options: vec![],
                         mask: None,
                         column_location: None,
+                    },
+                    ColumnDef {
+                        name: Ident::new("x").empty_span(),
+                        data_type: DataType::Enum8(vec![EnumTypeValue::NameWithValue("hello".to_string(), 1), EnumTypeValue::Name("world".to_string()), EnumTypeValue::NameWithValue("foo".to_string(), -3)]),
+                        collation: None,
+                        codec: None,
+                        options: vec![],
+                        column_options: vec![],
+                        mask: None,
+                        column_location: None,
                     }
                 ]
             )

tests/sqlparser_mysql.rs

@@ -433,7 +433,7 @@ fn parse_create_table_set_enum() {
                     },
                     ColumnDef {
                         name: Ident::new("baz").empty_span(),
-                        data_type: DataType::Enum(vec!["a".to_string(), "b".to_string()]),
+                        data_type: DataType::Enum(vec![EnumTypeValue::Name("a".to_string()), EnumTypeValue::Name("b".to_string())]),
                         collation: None,
                         codec: None,
                         options: vec![],