Merge branch 'main' into sqlite-pragma-boolean-values

Author: LucaCappelletti94

.github/workflows/rust.yml

@@ -81,6 +81,7 @@ jobs:
         uses: ./.github/actions/setup-builder
         with:
           targets: 'thumbv6m-none-eabi'
+      - run: cargo test --release --no-default-features --test no_std_recursion
       - run: cargo check --no-default-features --target thumbv6m-none-eabi
       - run: cargo check --no-default-features --features visitor --target thumbv6m-none-eabi
 

src/ast/ddl.rs

@@ -4386,6 +4386,7 @@ pub struct CreateView {
     /// <https://docs.snowflake.com/en/sql-reference/sql/create-view#syntax>
     pub secure: bool,
     /// View name
+    #[cfg_attr(feature = "visitor", visit(with = "visit_relation"))]
     pub name: ObjectName,
     /// If `if_not_exists` is true, this flag is set to true if the view name comes before the `IF NOT EXISTS` clause.
     /// Example:

src/ast/dml.rs

@@ -608,6 +608,13 @@ pub enum MergeAction {
         /// The `DELETE` token that starts the sub-expression.
         delete_token: AttachedToken,
     },
+    /// A `DO NOTHING` clause.
+    DoNothing {
+        /// The `DO` token that starts the sub-expression.
+        do_token: AttachedToken,
+        /// The `NOTHING` token that ends the sub-expression.
+        nothing_token: AttachedToken,
+    },
 }
 
 impl Display for MergeAction {
@@ -622,6 +629,9 @@ impl Display for MergeAction {
             MergeAction::Delete { .. } => {
                 write!(f, "DELETE")
             }
+            MergeAction::DoNothing { .. } => {
+                write!(f, "DO NOTHING")
+            }
         }
     }
 }

src/ast/mod.rs

@@ -1027,7 +1027,7 @@ pub enum Expr {
         /// Pattern expression.
         pattern: Box<Expr>,
         /// Optional escape character.
-        escape_char: Option<ValueWithSpan>,
+        escape_char: Option<Box<Expr>>,
     },
     /// `ILIKE` (case-insensitive `LIKE`)
     ILike {
@@ -1041,7 +1041,7 @@ pub enum Expr {
         /// Pattern expression.
         pattern: Box<Expr>,
         /// Optional escape character.
-        escape_char: Option<ValueWithSpan>,
+        escape_char: Option<Box<Expr>>,
     },
     /// `SIMILAR TO` regex
     SimilarTo {
@@ -1052,7 +1052,7 @@ pub enum Expr {
         /// Pattern expression.
         pattern: Box<Expr>,
         /// Optional escape character.
-        escape_char: Option<ValueWithSpan>,
+        escape_char: Option<Box<Expr>>,
     },
     /// MySQL: `RLIKE` regex or `REGEXP` regex
     RLike {
@@ -1487,6 +1487,9 @@ pub enum AccessExpr {
 impl fmt::Display for AccessExpr {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
+            AccessExpr::Dot(Expr::Value(value)) if matches!(value.value, Value::Number(_, _)) => {
+                write!(f, " . {value}")
+            }
             AccessExpr::Dot(expr) => write!(f, ".{expr}"),
             AccessExpr::Subscript(subscript) => write!(f, "[{subscript}]"),
         }
@@ -7544,34 +7547,22 @@ pub struct Grantee {
 
 impl fmt::Display for Grantee {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self.grantee_type {
-            GranteesType::Role => {
-                write!(f, "ROLE ")?;
-            }
-            GranteesType::Share => {
-                write!(f, "SHARE ")?;
-            }
-            GranteesType::User => {
-                write!(f, "USER ")?;
-            }
-            GranteesType::Group => {
-                write!(f, "GROUP ")?;
-            }
-            GranteesType::Public => {
-                write!(f, "PUBLIC ")?;
-            }
-            GranteesType::DatabaseRole => {
-                write!(f, "DATABASE ROLE ")?;
-            }
-            GranteesType::Application => {
-                write!(f, "APPLICATION ")?;
-            }
-            GranteesType::ApplicationRole => {
-                write!(f, "APPLICATION ROLE ")?;
+        let keyword = match self.grantee_type {
+            GranteesType::Role => "ROLE",
+            GranteesType::Share => "SHARE",
+            GranteesType::User => "USER",
+            GranteesType::Group => "GROUP",
+            GranteesType::Public => "PUBLIC",
+            GranteesType::DatabaseRole => "DATABASE ROLE",
+            GranteesType::Application => "APPLICATION",
+            GranteesType::ApplicationRole => "APPLICATION ROLE",
+            GranteesType::None => "",
+        };
+        f.write_str(keyword)?;
+        if let Some(name) = &self.name {
+            if !keyword.is_empty() {
+                f.write_str(" ")?;
             }
-            GranteesType::None => (),
-        }
-        if let Some(ref name) = self.name {
             name.fmt(f)?;
         }
         Ok(())

src/ast/query.rs

@@ -2231,7 +2231,7 @@ impl fmt::Display for TableFactor {
                     json_path.fmt(f)?;
                 }
                 if !partitions.is_empty() {
-                    write!(f, "PARTITION ({})", display_comma_separated(partitions))?;
+                    write!(f, " PARTITION ({})", display_comma_separated(partitions))?;
                 }
                 if let Some(args) = args {
                     write!(f, "(")?;

src/ast/spans.rs

@@ -2557,6 +2557,10 @@ impl Spanned for MergeAction {
             MergeAction::Insert(expr) => expr.span(),
             MergeAction::Update(expr) => expr.span(),
             MergeAction::Delete { delete_token } => delete_token.0.span,
+            MergeAction::DoNothing {
+                do_token,
+                nothing_token,
+            } => do_token.0.span.union(&nothing_token.0.span),
         }
     }
 }
@@ -2909,6 +2913,7 @@ WHERE id = 1
 
               WHEN MATCHED AND target_table.x != 'X' THEN   DELETE
         WHEN NOT MATCHED AND 1 THEN INSERT (product, quantity) ROW
+        WHEN MATCHED THEN DO NOTHING
         "#;
 
         let r = Parser::parse_sql(&crate::dialect::GenericDialect, sql).unwrap();
@@ -2917,7 +2922,7 @@ WHERE id = 1
         // ~ assert the span of the whole statement
         let stmt_span = r[0].span();
         assert_eq!(stmt_span.start, (4, 9).into());
-        assert_eq!(stmt_span.end, (16, 67).into());
+        assert_eq!(stmt_span.end, (17, 37).into());
 
         // ~ individual tokens within the statement
         let Statement::Merge(Merge {
@@ -2937,7 +2942,7 @@ WHERE id = 1
             merge_token.0.span,
             Span::new(Location::new(4, 9), Location::new(4, 14))
         );
-        assert_eq!(clauses.len(), 4);
+        assert_eq!(clauses.len(), 5);
 
         // ~ the INSERT clause's TOKENs
         assert_eq!(
@@ -3019,6 +3024,31 @@ WHERE id = 1
             panic!("not a MERGE INSERT clause");
         }
 
+        assert_eq!(
+            clauses[4].when_token.0.span,
+            Span::new(Location::new(17, 9), Location::new(17, 13))
+        );
+        if let MergeAction::DoNothing {
+            do_token,
+            nothing_token,
+        } = &clauses[4].action
+        {
+            assert_eq!(
+                do_token.0.span,
+                Span::new(Location::new(17, 27), Location::new(17, 29))
+            );
+            assert_eq!(
+                nothing_token.0.span,
+                Span::new(Location::new(17, 30), Location::new(17, 37))
+            );
+            assert_eq!(
+                clauses[4].action.span(),
+                Span::new(Location::new(17, 27), Location::new(17, 37))
+            );
+        } else {
+            panic!("not a MERGE DO NOTHING clause");
+        }
+
         assert!(output.is_none());
     }
 

src/ast/visitor.rs

@@ -1242,6 +1242,27 @@ mod tests {
         do_visit("SELECT a, b FROM t", &mut visitor);
         assert_eq!(visitor.idents, vec!["a", "b", "t"]);
     }
+
+    #[derive(Default)]
+    struct RelationVisitor {
+        relations: Vec<String>,
+    }
+
+    impl Visitor for RelationVisitor {
+        type Break = ();
+
+        fn pre_visit_relation(&mut self, relation: &ObjectName) -> ControlFlow<Self::Break> {
+            self.relations.push(relation.to_string());
+            ControlFlow::Continue(())
+        }
+    }
+
+    #[test]
+    fn test_visit_create_view_name_as_relation() {
+        let mut visitor = RelationVisitor::default();
+        do_visit("CREATE VIEW db1.v AS SELECT * FROM t", &mut visitor);
+        assert_eq!(visitor.relations, vec!["db1.v", "t"]);
+    }
 }
 
 #[cfg(test)]

src/dialect/databricks.rs

@@ -113,4 +113,24 @@ impl Dialect for DatabricksDialect {
     fn supports_select_item_multi_column_alias(&self) -> bool {
         true
     }
+
+    fn supports_map_literal_with_angle_brackets(&self) -> bool {
+        true
+    }
+
+    fn supports_string_literal_backslash_escape(&self) -> bool {
+        true
+    }
+
+    fn supports_select_wildcard_replace(&self) -> bool {
+        true
+    }
+
+    fn supports_from_first_select(&self) -> bool {
+        true
+    }
+
+    fn supports_pipe_operator(&self) -> bool {
+        true
+    }
 }

src/dialect/mysql.rs

@@ -98,12 +98,12 @@ impl Dialect for MySqlDialect {
         &self,
         parser: &mut crate::parser::Parser,
         expr: &crate::ast::Expr,
-        _precedence: u8,
+        precedence: u8,
     ) -> Option<Result<crate::ast::Expr, ParserError>> {
         // Parse DIV as an operator
         if parser.parse_keyword(Keyword::DIV) {
             let left = Box::new(expr.clone());
-            let right = Box::new(match parser.parse_expr() {
+            let right = Box::new(match parser.parse_subexpr(precedence) {
                 Ok(expr) => expr,
                 Err(e) => return Some(Err(e)),
             });

src/dialect/postgresql.rs

@@ -33,7 +33,21 @@ use crate::keywords::Keyword;
 use crate::parser::{Parser, ParserError};
 use crate::tokenizer::Token;
 
-use super::keywords::RESERVED_FOR_IDENTIFIER;
+use super::keywords::{self, RESERVED_FOR_IDENTIFIER};
+
+/// Keywords in [`keywords::RESERVED_FOR_TABLE_ALIAS`] because of other dialects, yet are safe for aliasing in PostgreSQL.
+/// See <https://www.postgresql.org/docs/current/sql-keywords-appendix.html>.
+const RESERVED_EXCLUSIONS_FOR_TABLE_ALIAS: &[Keyword] = &[
+    Keyword::CLUSTER,
+    Keyword::DISTRIBUTE,
+    Keyword::EXPLAIN,
+    Keyword::MINUS,
+    Keyword::SAMPLE,
+    Keyword::SORT,
+    Keyword::START,
+    Keyword::TOP,
+    Keyword::VIEW,
+];
 
 /// A [`Dialect`] for [PostgreSQL](https://www.postgresql.org/)
 #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
@@ -91,6 +105,11 @@ impl Dialect for PostgreSqlDialect {
         }
     }
 
+    fn is_table_alias(&self, kw: &Keyword, _parser: &mut Parser) -> bool {
+        !keywords::RESERVED_FOR_TABLE_ALIAS.contains(kw)
+            || RESERVED_EXCLUSIONS_FOR_TABLE_ALIAS.contains(kw)
+    }
+
     /// See <https://www.postgresql.org/docs/current/sql-createoperator.html>
     fn is_custom_operator_part(&self, ch: char) -> bool {
         matches!(