generalize struct support and add databricks

Author: ayman-sigma

src/ast/mod.rs

@@ -931,16 +931,16 @@ pub enum Expr {
     Rollup(Vec<Vec<Expr>>),
     /// ROW / TUPLE a single value, such as `SELECT (1, 2)`
     Tuple(Vec<Expr>),
-    /// `BigQuery` specific `Struct` literal expression [1]
+    /// `Struct` literal expression
     /// Syntax:
     /// ```sql
     /// STRUCT<[field_name] field_type, ...>( expr1 [, ... ])
     /// ```
-    /// [1]: https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#struct_type
     Struct {
         /// Struct values.
         values: Vec<Expr>,
-        /// Struct field definitions.
+        /// BigQuery specific: Struct field definitions.
+        /// see https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#struct_type
         fields: Vec<StructField>,
     },
     /// `BigQuery` specific: An named expression in a typeless struct [1]

src/dialect/bigquery.rs

@@ -72,4 +72,14 @@ impl Dialect for BigQueryDialect {
     fn require_interval_qualifier(&self) -> bool {
         true
     }
+
+    // See https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#constructing_a_struct
+    fn supports_struct_literal(&self) -> bool {
+        true
+    }
+
+    // See https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#typed_struct_syntax
+    fn supports_typed_struct_syntax(&self) -> bool {
+        true
+    }
 }

src/dialect/databricks.rs

@@ -59,4 +59,9 @@ impl Dialect for DatabricksDialect {
     fn require_interval_qualifier(&self) -> bool {
         true
     }
+
+    // See https://docs.databricks.com/en/sql/language-manual/functions/struct.html
+    fn supports_struct_literal(&self) -> bool {
+        true
+    }
 }

src/dialect/generic.rs

@@ -123,4 +123,12 @@ impl Dialect for GenericDialect {
     fn supports_named_fn_args_with_assignment_operator(&self) -> bool {
         true
     }
+
+    fn supports_struct_literal(&self) -> bool {
+        true
+    }
+
+    fn supports_typed_struct_syntax(&self) -> bool {
+        true
+    }
 }

src/dialect/mod.rs

@@ -375,6 +375,26 @@ pub trait Dialect: Debug + Any {
         false
     }
 
+    /// Return true if the dialect supports the STRUCT literal
+    ///
+    /// Example
+    /// ```sql
+    /// SELECT STRUCT(1 as one, 'foo' as foo, false)
+    /// ```
+    fn supports_struct_literal(&self) -> bool {
+        false
+    }
+
+    /// Return true if the dialect supports typed struct syntax
+    ///
+    /// Example for bigquery
+    /// ```sql
+    /// SELECT STRUCT<x int64, y string>(1, 'foo')
+    /// ```
+    fn supports_typed_struct_syntax(&self) -> bool {
+        false
+    }
+
     /// Dialect-specific infix parser override
     ///
     /// This method is called to parse the next infix expression.

src/parser/mod.rs

@@ -1123,9 +1123,8 @@ impl<'a> Parser<'a> {
             Keyword::MATCH if dialect_of!(self is MySqlDialect | GenericDialect) => {
                 Ok(Some(self.parse_match_against()?))
             }
-            Keyword::STRUCT if dialect_of!(self is BigQueryDialect | GenericDialect) => {
-                self.prev_token();
-                Ok(Some(self.parse_bigquery_struct_literal()?))
+            Keyword::STRUCT if self.dialect.supports_struct_literal() => {
+                Ok(Some(self.parse_struct_literal()?))
             }
             Keyword::PRIOR if matches!(self.state, ParserState::ConnectBy) => {
                 let expr = self.parse_subexpr(self.dialect.prec_value(Precedence::PlusMinus))?;
@@ -2383,22 +2382,28 @@ impl<'a> Parser<'a> {
         }
     }
 
-    /// Bigquery specific: Parse a struct literal
     /// Syntax
     /// ```sql
-    /// -- typed
+    /// -- typed, specific to bigquery
     /// STRUCT<[field_name] field_type, ...>( expr1 [, ... ])
     /// -- typeless
     /// STRUCT( expr1 [AS field_name] [, ... ])
     /// ```
-    fn parse_bigquery_struct_literal(&mut self) -> Result<Expr, ParserError> {
-        let (fields, trailing_bracket) =
-            self.parse_struct_type_def(Self::parse_struct_field_def)?;
-        if trailing_bracket.0 {
-            return parser_err!(
+    fn parse_struct_literal(&mut self) -> Result<Expr, ParserError> {
+        let mut fields = vec![];
+        // Typed struct syntax is only supported by BigQuery
+        // https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#typed_struct_syntax
+        if self.dialect.supports_typed_struct_syntax() {
+            self.prev_token();
+            let trailing_bracket;
+            (fields, trailing_bracket) =
+                self.parse_struct_type_def(Self::parse_struct_field_def)?;
+            if trailing_bracket.0 {
+                return parser_err!(
                 "unmatched > in STRUCT literal",
                 self.peek_token().span.start
             );
+            }
         }
 
         self.expect_token(&Token::LParen)?;
@@ -2409,13 +2414,13 @@ impl<'a> Parser<'a> {
         Ok(Expr::Struct { values, fields })
     }
 
-    /// Parse an expression value for a bigquery struct [1]
+    /// Parse an expression value for a struct literal
     /// Syntax
     /// ```sql
     /// expr [AS name]
     /// ```
     ///
-    /// Parameter typed_syntax is set to true if the expression
+    /// For biquery [1], Parameter typed_syntax is set to true if the expression
     /// is to be parsed as a field expression declared using typed
     /// struct syntax [2], and false if using typeless struct syntax [3].
     ///

tests/sqlparser_databricks.rs

@@ -278,3 +278,48 @@ fn parse_use() {
         );
     }
 }
+
+#[test]
+fn parse_databricks_struct_function() {
+    assert_eq!(
+        databricks()
+            .verified_only_select("SELECT STRUCT(1, 'foo')")
+            .projection[0],
+        SelectItem::UnnamedExpr(Expr::Struct {
+            values: vec![
+                Expr::Value(number("1")),
+                Expr::Value(Value::SingleQuotedString("foo".to_string()))
+            ],
+            fields: vec![]
+        })
+    );
+    assert_eq!(
+        databricks()
+            .verified_only_select("SELECT STRUCT(1 AS one, 'foo' AS foo, false)")
+            .projection[0],
+        SelectItem::UnnamedExpr(Expr::Struct {
+            values: vec![
+                Expr::Named {
+                    expr: Expr::Value(number("1")).into(),
+                    name: Ident::new("one")
+                },
+                Expr::Named {
+                    expr: Expr::Value(Value::SingleQuotedString("foo".to_string())).into(),
+                    name: Ident::new("foo")
+                },
+                Expr::Value(Value::Boolean(false))
+            ],
+            fields: vec![]
+        })
+    );
+}
+
+#[test]
+fn parse_invalid_struct_function() {
+    assert_eq!(
+        databricks()
+            .parse_sql_statements("SELECT STRUCT<INT64>(1)") // This works only in BigQuery
+            .unwrap_err(),
+        ParserError::ParserError("Expected: (, found: <".to_string())
+    );
+}