Merge remote-tracking branch 'origin/main'

Author: xitep

src/ast/mod.rs

@@ -136,8 +136,8 @@ mod dml;
 pub mod helpers;
 pub mod table_constraints;
 pub use table_constraints::{
-    CheckConstraint, ForeignKeyConstraint, FullTextOrSpatialConstraint, IndexConstraint,
-    PrimaryKeyConstraint, TableConstraint, UniqueConstraint,
+    CheckConstraint, ConstraintUsingIndex, ForeignKeyConstraint, FullTextOrSpatialConstraint,
+    IndexConstraint, PrimaryKeyConstraint, TableConstraint, UniqueConstraint,
 };
 mod operator;
 mod query;
@@ -4764,6 +4764,10 @@ pub enum Statement {
     ///
     /// See: <https://learn.microsoft.com/en-us/sql/t-sql/statements/print-transact-sql>
     Print(PrintStatement),
+    /// MSSQL `WAITFOR` statement.
+    ///
+    /// See: <https://learn.microsoft.com/en-us/sql/t-sql/language-elements/waitfor-transact-sql>
+    WaitFor(WaitForStatement),
     /// ```sql
     /// RETURN [ expression ]
     /// ```
@@ -6217,6 +6221,7 @@ impl fmt::Display for Statement {
             }
             Statement::Throw(s) => write!(f, "{s}"),
             Statement::Print(s) => write!(f, "{s}"),
+            Statement::WaitFor(s) => write!(f, "{s}"),
             Statement::Return(r) => write!(f, "{r}"),
             Statement::List(command) => write!(f, "LIST {command}"),
             Statement::Remove(command) => write!(f, "REMOVE {command}"),
@@ -10964,6 +10969,47 @@ impl fmt::Display for PrintStatement {
     }
 }
 
+/// The type of `WAITFOR` statement (MSSQL).
+///
+/// See: <https://learn.microsoft.com/en-us/sql/t-sql/language-elements/waitfor-transact-sql>
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum WaitForType {
+    /// `WAITFOR DELAY 'time_to_pass'`
+    Delay,
+    /// `WAITFOR TIME 'time_to_execute'`
+    Time,
+}
+
+impl fmt::Display for WaitForType {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            WaitForType::Delay => write!(f, "DELAY"),
+            WaitForType::Time => write!(f, "TIME"),
+        }
+    }
+}
+
+/// MSSQL `WAITFOR` statement.
+///
+/// See: <https://learn.microsoft.com/en-us/sql/t-sql/language-elements/waitfor-transact-sql>
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct WaitForStatement {
+    /// `DELAY` or `TIME`.
+    pub wait_type: WaitForType,
+    /// The time expression.
+    pub expr: Expr,
+}
+
+impl fmt::Display for WaitForStatement {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "WAITFOR {} {}", self.wait_type, self.expr)
+    }
+}
+
 /// Represents a `Return` statement.
 ///
 /// [MsSql triggers](https://learn.microsoft.com/en-us/sql/t-sql/statements/create-trigger-transact-sql)

src/ast/spans.rs

@@ -483,6 +483,7 @@ impl Spanned for Statement {
             Statement::RaisError { .. } => Span::empty(),
             Statement::Throw(_) => Span::empty(),
             Statement::Print { .. } => Span::empty(),
+            Statement::WaitFor(_) => Span::empty(),
             Statement::Return { .. } => Span::empty(),
             Statement::List(..) | Statement::Remove(..) => Span::empty(),
             Statement::ExportData(ExportData {
@@ -625,6 +626,8 @@ impl Spanned for TableConstraint {
             TableConstraint::Check(constraint) => constraint.span(),
             TableConstraint::Index(constraint) => constraint.span(),
             TableConstraint::FulltextOrSpatial(constraint) => constraint.span(),
+            TableConstraint::PrimaryKeyUsingIndex(constraint)
+            | TableConstraint::UniqueUsingIndex(constraint) => constraint.span(),
         }
     }
 }

src/ast/table_constraints.rs

@@ -101,6 +101,22 @@ pub enum TableConstraint {
     /// [1]: https://dev.mysql.com/doc/refman/8.0/en/fulltext-natural-language.html
     /// [2]: https://dev.mysql.com/doc/refman/8.0/en/spatial-types.html
     FulltextOrSpatial(FullTextOrSpatialConstraint),
+    /// PostgreSQL [definition][1] for promoting an existing unique index to a
+    /// `PRIMARY KEY` constraint:
+    ///
+    /// `[ CONSTRAINT constraint_name ] PRIMARY KEY USING INDEX index_name
+    ///   [ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]`
+    ///
+    /// [1]: https://www.postgresql.org/docs/current/sql-altertable.html
+    PrimaryKeyUsingIndex(ConstraintUsingIndex),
+    /// PostgreSQL [definition][1] for promoting an existing unique index to a
+    /// `UNIQUE` constraint:
+    ///
+    /// `[ CONSTRAINT constraint_name ] UNIQUE USING INDEX index_name
+    ///   [ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]`
+    ///
+    /// [1]: https://www.postgresql.org/docs/current/sql-altertable.html
+    UniqueUsingIndex(ConstraintUsingIndex),
 }
 
 impl From<UniqueConstraint> for TableConstraint {
@@ -148,6 +164,8 @@ impl fmt::Display for TableConstraint {
             TableConstraint::Check(constraint) => constraint.fmt(f),
             TableConstraint::Index(constraint) => constraint.fmt(f),
             TableConstraint::FulltextOrSpatial(constraint) => constraint.fmt(f),
+            TableConstraint::PrimaryKeyUsingIndex(c) => c.fmt_with_keyword(f, "PRIMARY KEY"),
+            TableConstraint::UniqueUsingIndex(c) => c.fmt_with_keyword(f, "UNIQUE"),
         }
     }
 }
@@ -535,3 +553,53 @@ impl crate::ast::Spanned for UniqueConstraint {
         )
     }
 }
+
+/// PostgreSQL constraint that promotes an existing unique index to a table constraint.
+///
+/// `[ CONSTRAINT constraint_name ] { UNIQUE | PRIMARY KEY } USING INDEX index_name
+///   [ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]`
+///
+/// See <https://www.postgresql.org/docs/current/sql-altertable.html>
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct ConstraintUsingIndex {
+    /// Optional constraint name.
+    pub name: Option<Ident>,
+    /// The name of the existing unique index to promote.
+    pub index_name: Ident,
+    /// Optional characteristics like `DEFERRABLE`.
+    pub characteristics: Option<ConstraintCharacteristics>,
+}
+
+impl ConstraintUsingIndex {
+    /// Format as `[CONSTRAINT name] <keyword> USING INDEX index_name [characteristics]`.
+    pub fn fmt_with_keyword(&self, f: &mut fmt::Formatter, keyword: &str) -> fmt::Result {
+        use crate::ast::ddl::{display_constraint_name, display_option_spaced};
+        write!(
+            f,
+            "{}{} USING INDEX {}",
+            display_constraint_name(&self.name),
+            keyword,
+            self.index_name,
+        )?;
+        write!(f, "{}", display_option_spaced(&self.characteristics))?;
+        Ok(())
+    }
+}
+
+impl crate::ast::Spanned for ConstraintUsingIndex {
+    fn span(&self) -> Span {
+        let start = self
+            .name
+            .as_ref()
+            .map(|i| i.span)
+            .unwrap_or(self.index_name.span);
+        let end = self
+            .characteristics
+            .as_ref()
+            .map(|c| c.span())
+            .unwrap_or(self.index_name.span);
+        start.union(&end)
+    }
+}

src/dialect/generic.rs

@@ -225,10 +225,6 @@ impl Dialect for GenericDialect {
         true
     }
 
-    fn supports_lambda_functions(&self) -> bool {
-        true
-    }
-
     fn supports_select_wildcard_replace(&self) -> bool {
         true
     }

src/keywords.rs

@@ -312,6 +312,7 @@ define_keywords!(
     DEFINE,
     DEFINED,
     DEFINER,
+    DELAY,
     DELAYED,
     DELAY_KEY_WRITE,
     DELEGATED,
@@ -1138,6 +1139,7 @@ define_keywords!(
     VIRTUAL,
     VOLATILE,
     VOLUME,
+    WAITFOR,
     WAREHOUSE,
     WAREHOUSES,
     WEEK,

src/parser/mod.rs

@@ -703,6 +703,8 @@ impl<'a> Parser<'a> {
                 // `COMMENT` is snowflake specific https://docs.snowflake.com/en/sql-reference/sql/comment
                 Keyword::COMMENT if self.dialect.supports_comment_on() => self.parse_comment(),
                 Keyword::PRINT => self.parse_print(),
+                // `WAITFOR` is MSSQL specific https://learn.microsoft.com/en-us/sql/t-sql/language-elements/waitfor-transact-sql
+                Keyword::WAITFOR => self.parse_waitfor(),
                 Keyword::RETURN => self.parse_return(),
                 Keyword::EXPORT => {
                     self.prev_token();
@@ -9331,6 +9333,21 @@ impl<'a> Parser<'a> {
         }
     }
 
+    /// Parse `index_name [ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]`
+    /// after `{ PRIMARY KEY | UNIQUE } USING INDEX`.
+    fn parse_constraint_using_index(
+        &mut self,
+        name: Option<Ident>,
+    ) -> Result<ConstraintUsingIndex, ParserError> {
+        let index_name = self.parse_identifier()?;
+        let characteristics = self.parse_constraint_characteristics()?;
+        Ok(ConstraintUsingIndex {
+            name,
+            index_name,
+            characteristics,
+        })
+    }
+
     /// Parse optional constraint characteristics such as `DEFERRABLE`, `INITIALLY` and `ENFORCED`.
     pub fn parse_constraint_characteristics(
         &mut self,
@@ -9395,6 +9412,14 @@ impl<'a> Parser<'a> {
         let next_token = self.next_token();
         match next_token.token {
             Token::Word(w) if w.keyword == Keyword::UNIQUE => {
+                // PostgreSQL: UNIQUE USING INDEX index_name
+                // https://www.postgresql.org/docs/current/sql-altertable.html
+                if self.parse_keywords(&[Keyword::USING, Keyword::INDEX]) {
+                    return Ok(Some(TableConstraint::UniqueUsingIndex(
+                        self.parse_constraint_using_index(name)?,
+                    )));
+                }
+
                 let index_type_display = self.parse_index_type_display();
                 if !dialect_of!(self is GenericDialect | MySqlDialect)
                     && !index_type_display.is_none()
@@ -9430,6 +9455,14 @@ impl<'a> Parser<'a> {
                 // after `PRIMARY` always stay `KEY`
                 self.expect_keyword_is(Keyword::KEY)?;
 
+                // PostgreSQL: PRIMARY KEY USING INDEX index_name
+                // https://www.postgresql.org/docs/current/sql-altertable.html
+                if self.parse_keywords(&[Keyword::USING, Keyword::INDEX]) {
+                    return Ok(Some(TableConstraint::PrimaryKeyUsingIndex(
+                        self.parse_constraint_using_index(name)?,
+                    )));
+                }
+
                 // optional index name
                 let index_name = self.parse_optional_ident()?;
                 let index_type = self.parse_optional_using_then_index_type()?;
@@ -19289,6 +19322,21 @@ impl<'a> Parser<'a> {
         }))
     }
 
+    /// Parse [Statement::WaitFor]
+    ///
+    /// See: <https://learn.microsoft.com/en-us/sql/t-sql/language-elements/waitfor-transact-sql>
+    fn parse_waitfor(&mut self) -> Result<Statement, ParserError> {
+        let wait_type = if self.parse_keyword(Keyword::DELAY) {
+            WaitForType::Delay
+        } else if self.parse_keyword(Keyword::TIME) {
+            WaitForType::Time
+        } else {
+            return self.expected("DELAY or TIME", self.peek_token());
+        };
+        let expr = self.parse_expr()?;
+        Ok(Statement::WaitFor(WaitForStatement { wait_type, expr }))
+    }
+
     /// Parse [Statement::Return]
     fn parse_return(&mut self) -> Result<Statement, ParserError> {
         match self.maybe_parse(|p| p.parse_expr())? {

tests/sqlparser_common.rs

@@ -1663,6 +1663,7 @@ fn parse_json_ops_without_colon() {
             Arrow,
             all_dialects_except(|d| d.supports_lambda_functions()),
         ),
+        ("->", Arrow, pg_and_generic()),
         ("->>", LongArrow, all_dialects()),
         ("#>", HashArrow, pg_and_generic()),
         ("#>>", HashLongArrow, pg_and_generic()),

tests/sqlparser_duckdb.rs

@@ -882,17 +882,17 @@ fn parse_extract_single_quotes() {
 fn test_duckdb_lambda_function() {
     // Test basic lambda with list_filter
     let sql = "SELECT [3, 4, 5, 6].list_filter(lambda x : x > 4)";
-    duckdb_and_generic().verified_stmt(sql);
+    duckdb().verified_stmt(sql);
 
     // Test lambda with arrow syntax (also supported by DuckDB)
     let sql_arrow = "SELECT list_filter([1, 2, 3], x -> x > 1)";
-    duckdb_and_generic().verified_stmt(sql_arrow);
+    duckdb().verified_stmt(sql_arrow);
 
     // Test lambda with multiple parameters (with index)
     let sql_multi = "SELECT list_filter([1, 3, 1, 5], lambda x, i : x > i)";
-    duckdb_and_generic().verified_stmt(sql_multi);
+    duckdb().verified_stmt(sql_multi);
 
     // Test lambda in list_transform
     let sql_transform = "SELECT list_transform([1, 2, 3], lambda x : x * 2)";
-    duckdb_and_generic().verified_stmt(sql_transform);
+    duckdb().verified_stmt(sql_transform);
 }

tests/sqlparser_mssql.rs

@@ -1702,6 +1702,43 @@ fn test_parse_throw() {
     );
 }
 
+#[test]
+fn test_parse_waitfor() {
+    // WAITFOR DELAY
+    let sql = "WAITFOR DELAY '00:00:05'";
+    let stmt = ms_and_generic().verified_stmt(sql);
+    assert_eq!(
+        stmt,
+        Statement::WaitFor(WaitForStatement {
+            wait_type: WaitForType::Delay,
+            expr: Expr::Value(
+                (Value::SingleQuotedString("00:00:05".to_string())).with_empty_span()
+            ),
+        })
+    );
+
+    // WAITFOR TIME
+    let sql = "WAITFOR TIME '14:30:00'";
+    let stmt = ms_and_generic().verified_stmt(sql);
+    assert_eq!(
+        stmt,
+        Statement::WaitFor(WaitForStatement {
+            wait_type: WaitForType::Time,
+            expr: Expr::Value(
+                (Value::SingleQuotedString("14:30:00".to_string())).with_empty_span()
+            ),
+        })
+    );
+
+    // WAITFOR DELAY with variable
+    let sql = "WAITFOR DELAY @WaitTime";
+    let _ = ms_and_generic().verified_stmt(sql);
+
+    // Error: WAITFOR without DELAY or TIME
+    let res = ms_and_generic().parse_sql_statements("WAITFOR '00:00:05'");
+    assert!(res.is_err());
+}
+
 #[test]
 fn parse_use() {
     let valid_object_names = [