Merge remote-tracking branch 'origin/main'

Author: xitep

src/ast/dml.rs

@@ -43,11 +43,11 @@ use super::{
 pub struct Insert {
     /// Token for the `INSERT` keyword (or its substitutes)
     pub insert_token: AttachedToken,
-    /// A query optimizer hint
+    /// Query optimizer hints
     ///
     /// [MySQL](https://dev.mysql.com/doc/refman/8.4/en/optimizer-hints.html)
     /// [Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/Comments.html#GUID-D316D545-89E2-4D54-977F-FC97815CD62E)
-    pub optimizer_hint: Option<OptimizerHint>,
+    pub optimizer_hints: Vec<OptimizerHint>,
     /// Only for Sqlite
     pub or: Option<SqliteOnConflict>,
     /// Only for mysql
@@ -133,7 +133,7 @@ impl Display for Insert {
 
         if let Some(on_conflict) = self.or {
             f.write_str("INSERT")?;
-            if let Some(hint) = self.optimizer_hint.as_ref() {
+            for hint in &self.optimizer_hints {
                 write!(f, " {hint}")?;
             }
             write!(f, " {on_conflict} INTO {table_name} ")?;
@@ -147,7 +147,7 @@ impl Display for Insert {
                     "INSERT"
                 }
             )?;
-            if let Some(hint) = self.optimizer_hint.as_ref() {
+            for hint in &self.optimizer_hints {
                 write!(f, " {hint}")?;
             }
             if let Some(priority) = self.priority {
@@ -267,11 +267,11 @@ impl Display for Insert {
 pub struct Delete {
     /// Token for the `DELETE` keyword
     pub delete_token: AttachedToken,
-    /// A query optimizer hint
+    /// Query optimizer hints
     ///
     /// [MySQL](https://dev.mysql.com/doc/refman/8.4/en/optimizer-hints.html)
     /// [Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/Comments.html#GUID-D316D545-89E2-4D54-977F-FC97815CD62E)
-    pub optimizer_hint: Option<OptimizerHint>,
+    pub optimizer_hints: Vec<OptimizerHint>,
     /// Multi tables delete are supported in mysql
     pub tables: Vec<ObjectName>,
     /// FROM
@@ -291,7 +291,7 @@ pub struct Delete {
 impl Display for Delete {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str("DELETE")?;
-        if let Some(hint) = self.optimizer_hint.as_ref() {
+        for hint in &self.optimizer_hints {
             f.write_str(" ")?;
             hint.fmt(f)?;
         }
@@ -345,11 +345,11 @@ impl Display for Delete {
 pub struct Update {
     /// Token for the `UPDATE` keyword
     pub update_token: AttachedToken,
-    /// A query optimizer hint
+    /// Query optimizer hints
     ///
     /// [MySQL](https://dev.mysql.com/doc/refman/8.4/en/optimizer-hints.html)
     /// [Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/Comments.html#GUID-D316D545-89E2-4D54-977F-FC97815CD62E)
-    pub optimizer_hint: Option<OptimizerHint>,
+    pub optimizer_hints: Vec<OptimizerHint>,
     /// TABLE
     pub table: TableWithJoins,
     /// Column assignments
@@ -368,11 +368,12 @@ pub struct Update {
 
 impl Display for Update {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str("UPDATE ")?;
-        if let Some(hint) = self.optimizer_hint.as_ref() {
-            hint.fmt(f)?;
+        f.write_str("UPDATE")?;
+        for hint in &self.optimizer_hints {
             f.write_str(" ")?;
+            hint.fmt(f)?;
         }
+        f.write_str(" ")?;
         if let Some(or) = &self.or {
             or.fmt(f)?;
             f.write_str(" ")?;
@@ -419,10 +420,10 @@ impl Display for Update {
 pub struct Merge {
     /// The `MERGE` token that starts the statement.
     pub merge_token: AttachedToken,
-    /// A query optimizer hint
+    /// Query optimizer hints
     ///
     /// [Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/Comments.html#GUID-D316D545-89E2-4D54-977F-FC97815CD62E)
-    pub optimizer_hint: Option<OptimizerHint>,
+    pub optimizer_hints: Vec<OptimizerHint>,
     /// optional INTO keyword
     pub into: bool,
     /// Specifies the table to merge
@@ -440,7 +441,7 @@ pub struct Merge {
 impl Display for Merge {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str("MERGE")?;
-        if let Some(hint) = self.optimizer_hint.as_ref() {
+        for hint in &self.optimizer_hints {
             write!(f, " {hint}")?;
         }
         if self.into {

src/ast/mod.rs

@@ -2439,30 +2439,54 @@ impl fmt::Display for ShowCreateObject {
 pub enum CommentObject {
     /// A table column.
     Column,
-    /// A table.
-    Table,
+    /// A database.
+    Database,
+    /// A domain.
+    Domain,
     /// An extension.
     Extension,
+    /// A function.
+    Function,
+    /// An index.
+    Index,
+    /// A materialized view.
+    MaterializedView,
+    /// A procedure.
+    Procedure,
+    /// A role.
+    Role,
     /// A schema.
     Schema,
-    /// A database.
-    Database,
+    /// A sequence.
+    Sequence,
+    /// A table.
+    Table,
+    /// A type.
+    Type,
     /// A user.
     User,
-    /// A role.
-    Role,
+    /// A view.
+    View,
 }
 
 impl fmt::Display for CommentObject {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             CommentObject::Column => f.write_str("COLUMN"),
-            CommentObject::Table => f.write_str("TABLE"),
+            CommentObject::Database => f.write_str("DATABASE"),
+            CommentObject::Domain => f.write_str("DOMAIN"),
             CommentObject::Extension => f.write_str("EXTENSION"),
+            CommentObject::Function => f.write_str("FUNCTION"),
+            CommentObject::Index => f.write_str("INDEX"),
+            CommentObject::MaterializedView => f.write_str("MATERIALIZED VIEW"),
+            CommentObject::Procedure => f.write_str("PROCEDURE"),
+            CommentObject::Role => f.write_str("ROLE"),
             CommentObject::Schema => f.write_str("SCHEMA"),
-            CommentObject::Database => f.write_str("DATABASE"),
+            CommentObject::Sequence => f.write_str("SEQUENCE"),
+            CommentObject::Table => f.write_str("TABLE"),
+            CommentObject::Type => f.write_str("TYPE"),
             CommentObject::User => f.write_str("USER"),
-            CommentObject::Role => f.write_str("ROLE"),
+            CommentObject::View => f.write_str("VIEW"),
         }
     }
 }
@@ -11650,12 +11674,19 @@ pub struct ResetStatement {
 /// `SELECT`, `INSERT`, `UPDATE`, `REPLACE`, `MERGE`, and `DELETE` keywords in
 /// the corresponding statements.
 ///
-/// See [Select::optimizer_hint]
+/// See [Select::optimizer_hints]
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
 pub struct OptimizerHint {
-    /// the raw test of the optimizer hint without its markers
+    /// An optional prefix between the comment marker and `+`.
+    ///
+    /// Standard optimizer hints like `/*+ ... */` have an empty prefix,
+    /// while system-specific hints like `/*abc+ ... */` have `prefix = "abc"`.
+    /// The prefix is any sequence of ASCII alphanumeric characters
+    /// immediately before the `+` marker.
+    pub prefix: String,
+    /// the raw text of the optimizer hint without its markers
     pub text: String,
     /// the style of the comment which `text` was extracted from,
     /// e.g. `/*+...*/` or `--+...`
@@ -11685,11 +11716,14 @@ impl fmt::Display for OptimizerHint {
         match &self.style {
             OptimizerHintStyle::SingleLine { prefix } => {
                 f.write_str(prefix)?;
+                f.write_str(&self.prefix)?;
                 f.write_str("+")?;
                 f.write_str(&self.text)
             }
             OptimizerHintStyle::MultiLine => {
-                f.write_str("/*+")?;
+                f.write_str("/*")?;
+                f.write_str(&self.prefix)?;
+                f.write_str("+")?;
                 f.write_str(&self.text)?;
                 f.write_str("*/")
             }

src/ast/query.rs

@@ -445,11 +445,11 @@ impl SelectModifiers {
 pub struct Select {
     /// Token for the `SELECT` keyword
     pub select_token: AttachedToken,
-    /// A query optimizer hint
+    /// Query optimizer hints
     ///
     /// [MySQL](https://dev.mysql.com/doc/refman/8.4/en/optimizer-hints.html)
     /// [Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/Comments.html#GUID-D316D545-89E2-4D54-977F-FC97815CD62E)
-    pub optimizer_hint: Option<OptimizerHint>,
+    pub optimizer_hints: Vec<OptimizerHint>,
     /// `SELECT [DISTINCT] ...`
     pub distinct: Option<Distinct>,
     /// MySQL-specific SELECT modifiers.
@@ -521,7 +521,7 @@ impl fmt::Display for Select {
             }
         }
 
-        if let Some(hint) = self.optimizer_hint.as_ref() {
+        for hint in &self.optimizer_hints {
             f.write_str(" ")?;
             hint.fmt(f)?;
         }

src/ast/spans.rs

@@ -900,7 +900,7 @@ impl Spanned for Delete {
     fn span(&self) -> Span {
         let Delete {
             delete_token,
-            optimizer_hint: _,
+            optimizer_hints: _,
             tables,
             from,
             using,
@@ -934,7 +934,7 @@ impl Spanned for Update {
     fn span(&self) -> Span {
         let Update {
             update_token,
-            optimizer_hint: _,
+            optimizer_hints: _,
             table,
             assignments,
             from,
@@ -1298,7 +1298,7 @@ impl Spanned for Insert {
     fn span(&self) -> Span {
         let Insert {
             insert_token,
-            optimizer_hint: _,
+            optimizer_hints: _,
             or: _,     // enum, sqlite specific
             ignore: _, // bool
             into: _,   // bool
@@ -2246,7 +2246,7 @@ impl Spanned for Select {
     fn span(&self) -> Span {
         let Select {
             select_token,
-            optimizer_hint: _,
+            optimizer_hints: _,
             distinct: _, // todo
             select_modifiers: _,
             top: _, // todo, mysql specific
@@ -2840,7 +2840,7 @@ WHERE id = 1
         // ~ individual tokens within the statement
         let Statement::Merge(Merge {
             merge_token,
-            optimizer_hint: _,
+            optimizer_hints: _,
             into: _,
             table: _,
             source: _,

src/dialect/mod.rs

@@ -756,17 +756,17 @@ pub trait Dialect: Debug + Any {
             };
         }
 
-        let token = parser.peek_token();
+        let token = parser.peek_token_ref();
         debug!("get_next_precedence_full() {token:?}");
-        match token.token {
+        match &token.token {
             Token::Word(w) if w.keyword == Keyword::OR => Ok(p!(Or)),
             Token::Word(w) if w.keyword == Keyword::AND => Ok(p!(And)),
             Token::Word(w) if w.keyword == Keyword::XOR => Ok(p!(Xor)),
 
             Token::Word(w) if w.keyword == Keyword::AT => {
                 match (
-                    parser.peek_nth_token(1).token,
-                    parser.peek_nth_token(2).token,
+                    &parser.peek_nth_token_ref(1).token,
+                    &parser.peek_nth_token_ref(2).token,
                 ) {
                     (Token::Word(w), Token::Word(w2))
                         if w.keyword == Keyword::TIME && w2.keyword == Keyword::ZONE =>
@@ -777,28 +777,30 @@ pub trait Dialect: Debug + Any {
                 }
             }
 
-            Token::Word(w) if w.keyword == Keyword::NOT => match parser.peek_nth_token(1).token {
-                // The precedence of NOT varies depending on keyword that
-                // follows it. If it is followed by IN, BETWEEN, or LIKE,
-                // it takes on the precedence of those tokens. Otherwise, it
-                // is not an infix operator, and therefore has zero
-                // precedence.
-                Token::Word(w) if w.keyword == Keyword::IN => Ok(p!(Between)),
-                Token::Word(w) if w.keyword == Keyword::BETWEEN => Ok(p!(Between)),
-                Token::Word(w) if w.keyword == Keyword::LIKE => Ok(p!(Like)),
-                Token::Word(w) if w.keyword == Keyword::ILIKE => Ok(p!(Like)),
-                Token::Word(w) if w.keyword == Keyword::RLIKE => Ok(p!(Like)),
-                Token::Word(w) if w.keyword == Keyword::REGEXP => Ok(p!(Like)),
-                Token::Word(w) if w.keyword == Keyword::MATCH => Ok(p!(Like)),
-                Token::Word(w) if w.keyword == Keyword::SIMILAR => Ok(p!(Like)),
-                Token::Word(w) if w.keyword == Keyword::MEMBER => Ok(p!(Like)),
-                Token::Word(w)
-                    if w.keyword == Keyword::NULL && !parser.in_column_definition_state() =>
-                {
-                    Ok(p!(Is))
+            Token::Word(w) if w.keyword == Keyword::NOT => {
+                match &parser.peek_nth_token_ref(1).token {
+                    // The precedence of NOT varies depending on keyword that
+                    // follows it. If it is followed by IN, BETWEEN, or LIKE,
+                    // it takes on the precedence of those tokens. Otherwise, it
+                    // is not an infix operator, and therefore has zero
+                    // precedence.
+                    Token::Word(w) if w.keyword == Keyword::IN => Ok(p!(Between)),
+                    Token::Word(w) if w.keyword == Keyword::BETWEEN => Ok(p!(Between)),
+                    Token::Word(w) if w.keyword == Keyword::LIKE => Ok(p!(Like)),
+                    Token::Word(w) if w.keyword == Keyword::ILIKE => Ok(p!(Like)),
+                    Token::Word(w) if w.keyword == Keyword::RLIKE => Ok(p!(Like)),
+                    Token::Word(w) if w.keyword == Keyword::REGEXP => Ok(p!(Like)),
+                    Token::Word(w) if w.keyword == Keyword::MATCH => Ok(p!(Like)),
+                    Token::Word(w) if w.keyword == Keyword::SIMILAR => Ok(p!(Like)),
+                    Token::Word(w) if w.keyword == Keyword::MEMBER => Ok(p!(Like)),
+                    Token::Word(w)
+                        if w.keyword == Keyword::NULL && !parser.in_column_definition_state() =>
+                    {
+                        Ok(p!(Is))
+                    }
+                    _ => Ok(self.prec_unknown()),
                 }
-                _ => Ok(self.prec_unknown()),
-            },
+            }
             Token::Word(w) if w.keyword == Keyword::NOTNULL && self.supports_notnull_operator() => {
                 Ok(p!(Is))
             }
@@ -861,7 +863,7 @@ pub trait Dialect: Debug + Any {
             Token::DoubleColon | Token::ExclamationMark | Token::LBracket | Token::CaretAt => {
                 Ok(p!(DoubleColon))
             }
-            Token::Colon => match parser.peek_nth_token(1).token {
+            Token::Colon => match &parser.peek_nth_token_ref(1).token {
                 // When colon is followed by a string or a number, it's usually in MAP syntax.
                 Token::SingleQuotedString(_) | Token::Number(_, _) => Ok(self.prec_unknown()),
                 // In other cases, it's used in semi-structured data traversal like in variant or JSON

src/dialect/mssql.rs

@@ -159,7 +159,7 @@ impl Dialect for MsSqlDialect {
                         .is_some()
                         || matches!(p.peek_token_ref().token, Token::SemiColon | Token::EOF)
                     {
-                        p.expected("statement", p.peek_token())
+                        p.expected_ref("statement", p.peek_token_ref())
                     } else {
                         Ok(())
                     }
@@ -189,8 +189,8 @@ impl Dialect for MsSqlDialect {
     }
 
     fn get_next_precedence(&self, parser: &Parser) -> Option<Result<u8, ParserError>> {
-        let token = parser.peek_token();
-        match token.token {
+        let token = parser.peek_token_ref();
+        match &token.token {
             // lowest prec to prevent it from turning into a binary op
             Token::Colon => Some(Ok(self.prec_unknown())),
             _ => None,

src/dialect/mysql.rs

@@ -244,7 +244,7 @@ fn parse_lock_tables_type(parser: &mut Parser) -> Result<LockTableType, ParserEr
     } else if parser.parse_keywords(&[Keyword::LOW_PRIORITY, Keyword::WRITE]) {
         Ok(LockTableType::Write { low_priority: true })
     } else {
-        parser.expected("an lock type in LOCK TABLES", parser.peek_token())
+        parser.expected_ref("an lock type in LOCK TABLES", parser.peek_token_ref())
     }
 }