Support the ARRAY type of Snowflake

src/ast/data_type.rs

@@ -11,7 +11,7 @@
 // limitations under the License.
 
 #[cfg(not(feature = "std"))]
-use alloc::{boxed::Box, string::String, vec::Vec};
+use alloc::{boxed::Box, string::String, vec, vec::Vec};
 use core::fmt;
 
 #[cfg(feature = "serde")]
@@ -232,7 +232,13 @@ impl fmt::Display for DataType {
             DataType::Text => write!(f, "TEXT"),
             DataType::String => write!(f, "STRING"),
             DataType::Bytea => write!(f, "BYTEA"),
-            DataType::Array(ty) => write!(f, "{}[]", ty),
+            DataType::Array(ty) => {
+                if ty == &Box::new(DataType::Custom(ObjectName(vec!["VARAINT".into()]), vec![])) {
+                    write!(f, "ARRAY")
+                } else {
+                    write!(f, "{}[]", ty)
+                }
+            }
             DataType::Custom(ty, modifiers) => {
                 if modifiers.is_empty() {
                     write!(f, "{}", ty)

src/parser.rs

@@ -3672,13 +3672,20 @@ impl<'a> Parser<'a> {
                 Keyword::ENUM => Ok(DataType::Enum(self.parse_string_values()?)),
                 Keyword::SET => Ok(DataType::Set(self.parse_string_values()?)),
                 Keyword::ARRAY => {
-                    // Hive array syntax. Note that nesting arrays - or other Hive syntax
-                    // that ends with > will fail due to "C++" problem - >> is parsed as
-                    // Token::ShiftRight
-                    self.expect_token(&Token::Lt)?;
-                    let inside_type = self.parse_data_type()?;
-                    self.expect_token(&Token::Gt)?;
-                    Ok(DataType::Array(Box::new(inside_type)))
+                    if dialect_of!(self is SnowflakeDialect) {
+                        Ok(DataType::Array(Box::new(DataType::Custom(
+                            ObjectName(vec!["VARAINT".into()]),
+                            vec![],
+                        ))))
+                    } else {
+                        // Hive array syntax. Note that nesting arrays - or other Hive syntax
+                        // that ends with > will fail due to "C++" problem - >> is parsed as
+                        // Token::ShiftRight
+                        self.expect_token(&Token::Lt)?;
+                        let inside_type = self.parse_data_type()?;
+                        self.expect_token(&Token::Gt)?;
+                        Ok(DataType::Array(Box::new(inside_type)))
+                    }
                 }
                 _ => {
                     self.prev_token();

tests/sqlparser_common.rs

@@ -24,7 +24,7 @@ use sqlparser::ast::SelectItem::UnnamedExpr;
 use sqlparser::ast::*;
 use sqlparser::dialect::{
     AnsiDialect, BigQueryDialect, ClickHouseDialect, GenericDialect, HiveDialect, MsSqlDialect,
-    PostgreSqlDialect, SQLiteDialect, SnowflakeDialect,
+    MySqlDialect, PostgreSqlDialect, SQLiteDialect, SnowflakeDialect,
 };
 use sqlparser::keywords::ALL_KEYWORDS;
 use sqlparser::parser::{Parser, ParserError};
@@ -2109,12 +2109,20 @@ fn parse_create_table_hive_array() {
         _ => unreachable!(),
     }
 
-    let res =
-        parse_sql_statements("CREATE TABLE IF NOT EXISTS something (name int, val array<int)");
-    assert!(res
-        .unwrap_err()
-        .to_string()
-        .contains("Expected >, found: )"));
+    // SnowflakeDialect using array diffrent
+    let dialects = TestedDialects {
+        dialects: vec![
+            Box::new(PostgreSqlDialect {}),
+            Box::new(HiveDialect {}),
+            Box::new(MySqlDialect {}),
+        ],
+    };
+    let sql = "CREATE TABLE IF NOT EXISTS something (name int, val array<int)";
+
+    assert_eq!(
+        dialects.parse_sql_statements(sql).unwrap_err(),
+        ParserError::ParserError("Expected >, found: )".to_string())
+    );
 }
 
 #[test]

tests/sqlparser_snowflake.rs

@@ -143,6 +143,22 @@ fn test_single_table_in_parenthesis_with_alias() {
     );
 }
 
+#[test]
+fn parse_array() {
+    let sql = "SELECT CAST(a AS ARRAY) FROM customer";
+    let select = snowflake().verified_only_select(sql);
+    assert_eq!(
+        &Expr::Cast {
+            expr: Box::new(Expr::Identifier(Ident::new("a"))),
+            data_type: DataType::Array(Box::new(DataType::Custom(
+                ObjectName(vec!["VARAINT".into()]),
+                vec![]
+            ))),
+        },
+        expr_from_projection(only(&select.projection))
+    );
+}
+
 #[test]
 fn parse_json_using_colon() {
     let sql = "SELECT a:b FROM t";