Merge remote-tracking branch 'origin/main' into fix-mysql-drop-index-error

vimko · vimko · commit 0d4967cbb155 · 2025-06-04T22:11:36.000+08:00
diff --git a/src/ast/ddl.rs b/src/ast/ddl.rs
@@ -139,6 +139,7 @@ pub enum AlterTableOperation {
     },
     /// `DROP [ COLUMN ] [ IF EXISTS ] <column_name> [ CASCADE ]`
     DropColumn {
+        has_column_keyword: bool,
         column_name: Ident,
         if_exists: bool,
         drop_behavior: Option<DropBehavior>,
@@ -615,12 +616,14 @@ impl fmt::Display for AlterTableOperation {
             AlterTableOperation::DropForeignKey { name } => write!(f, "DROP FOREIGN KEY {name}"),
             AlterTableOperation::DropIndex { name } => write!(f, "DROP INDEX {name}"),
             AlterTableOperation::DropColumn {
+                has_column_keyword,
                 column_name,
                 if_exists,
                 drop_behavior,
             } => write!(
                 f,
-                "DROP COLUMN {}{}{}",
+                "DROP {}{}{}{}",
+                if *has_column_keyword { "COLUMN " } else { "" },
                 if *if_exists { "IF EXISTS " } else { "" },
                 column_name,
                 match drop_behavior {
diff --git a/src/ast/mod.rs b/src/ast/mod.rs
@@ -3416,6 +3416,9 @@ pub enum Statement {
         purge: bool,
         /// MySQL-specific "TEMPORARY" keyword
         temporary: bool,
+        /// MySQL-specific drop index syntax, which requires table specification  
+        /// See <https://dev.mysql.com/doc/refman/8.4/en/drop-index.html>
+        table: Option<ObjectName>,
     },
     /// ```sql
     /// DROP FUNCTION
@@ -5264,17 +5267,24 @@ impl fmt::Display for Statement {
                 restrict,
                 purge,
                 temporary,
-            } => write!(
-                f,
-                "DROP {}{}{} {}{}{}{}",
-                if *temporary { "TEMPORARY " } else { "" },
-                object_type,
-                if *if_exists { " IF EXISTS" } else { "" },
-                display_comma_separated(names),
-                if *cascade { " CASCADE" } else { "" },
-                if *restrict { " RESTRICT" } else { "" },
-                if *purge { " PURGE" } else { "" }
-            ),
+                table,
+            } => {
+                write!(
+                    f,
+                    "DROP {}{}{} {}{}{}{}",
+                    if *temporary { "TEMPORARY " } else { "" },
+                    object_type,
+                    if *if_exists { " IF EXISTS" } else { "" },
+                    display_comma_separated(names),
+                    if *cascade { " CASCADE" } else { "" },
+                    if *restrict { " RESTRICT" } else { "" },
+                    if *purge { " PURGE" } else { "" },
+                )?;
+                if let Some(table_name) = table.as_ref() {
+                    write!(f, " ON {}", table_name)?;
+                };
+                Ok(())
+            }
             Statement::DropFunction {
                 if_exists,
                 func_desc,
diff --git a/src/ast/query.rs b/src/ast/query.rs
@@ -1559,7 +1559,7 @@ impl fmt::Display for TableSampleBucket {
 }
 impl fmt::Display for TableSample {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, " {}", self.modifier)?;
+        write!(f, "{}", self.modifier)?;
         if let Some(name) = &self.name {
             write!(f, " {}", name)?;
         }
@@ -1862,7 +1862,7 @@ impl fmt::Display for TableFactor {
                     write!(f, " WITH ORDINALITY")?;
                 }
                 if let Some(TableSampleKind::BeforeTableAlias(sample)) = sample {
-                    write!(f, "{sample}")?;
+                    write!(f, " {sample}")?;
                 }
                 if let Some(alias) = alias {
                     write!(f, " AS {alias}")?;
@@ -1877,7 +1877,7 @@ impl fmt::Display for TableFactor {
                     write!(f, "{version}")?;
                 }
                 if let Some(TableSampleKind::AfterTableAlias(sample)) = sample {
-                    write!(f, "{sample}")?;
+                    write!(f, " {sample}")?;
                 }
                 Ok(())
             }
@@ -2680,6 +2680,10 @@ pub enum PipeOperator {
         full_table_exprs: Vec<ExprWithAliasAndOrderBy>,
         group_by_expr: Vec<ExprWithAliasAndOrderBy>,
     },
+    /// Selects a random sample of rows from the input table.
+    /// Syntax: `|> TABLESAMPLE SYSTEM (10 PERCENT)
+    /// See more at <https://cloud.google.com/bigquery/docs/reference/standard-sql/pipe-syntax#tablesample_pipe_operator>
+    TableSample { sample: Box<TableSample> },
 }
 
 impl fmt::Display for PipeOperator {
@@ -2731,6 +2735,10 @@ impl fmt::Display for PipeOperator {
             PipeOperator::OrderBy { exprs } => {
                 write!(f, "ORDER BY {}", display_comma_separated(exprs.as_slice()))
             }
+
+            PipeOperator::TableSample { sample } => {
+                write!(f, "{}", sample)
+            }
         }
     }
 }
diff --git a/src/ast/spans.rs b/src/ast/spans.rs
@@ -1091,6 +1091,7 @@ impl Spanned for AlterTableOperation {
                 drop_behavior: _,
             } => name.span,
             AlterTableOperation::DropColumn {
+                has_column_keyword: _,
                 column_name,
                 if_exists: _,
                 drop_behavior: _,
diff --git a/src/parser/mod.rs b/src/parser/mod.rs
@@ -5289,11 +5289,17 @@ impl<'a> Parser<'a> {
             |parser: &mut Parser| -> Result<OperateFunctionArg, ParserError> {
                 let name = parser.parse_identifier()?;
                 let data_type = parser.parse_data_type()?;
+                let default_expr = if parser.consume_token(&Token::Eq) {
+                    Some(parser.parse_expr()?)
+                } else {
+                    None
+                };
+
                 Ok(OperateFunctionArg {
                     mode: None,
                     name: Some(name),
                     data_type,
-                    default_expr: None,
+                    default_expr,
                 })
             };
         self.expect_token(&Token::LParen)?;
@@ -6271,6 +6277,11 @@ impl<'a> Parser<'a> {
                 loc
             );
         }
+        let table = if self.parse_keyword(Keyword::ON) {
+            Some(self.parse_object_name(false)?)
+        } else {
+            None
+        };
         Ok(Statement::Drop {
             object_type,
             if_exists,
@@ -6279,6 +6290,7 @@ impl<'a> Parser<'a> {
             restrict,
             purge,
             temporary,
+            table,
         })
     }
 
@@ -8633,11 +8645,12 @@ impl<'a> Parser<'a> {
             } else if self.parse_keywords(&[Keyword::CLUSTERING, Keyword::KEY]) {
                 AlterTableOperation::DropClusteringKey
             } else {
-                let _ = self.parse_keyword(Keyword::COLUMN); // [ COLUMN ]
+                let has_column_keyword = self.parse_keyword(Keyword::COLUMN); // [ COLUMN ]
                 let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]);
                 let column_name = self.parse_identifier()?;
                 let drop_behavior = self.parse_optional_drop_behavior();
                 AlterTableOperation::DropColumn {
+                    has_column_keyword,
                     column_name,
                     if_exists,
                     drop_behavior,
@@ -10123,7 +10136,13 @@ impl<'a> Parser<'a> {
             }
             if self.parse_keywords(&[Keyword::GROUPING, Keyword::SETS]) {
                 self.expect_token(&Token::LParen)?;
-                let result = self.parse_comma_separated(|p| p.parse_tuple(true, true))?;
+                let result = self.parse_comma_separated(|p| {
+                    if p.peek_token_ref().token == Token::LParen {
+                        p.parse_tuple(true, true)
+                    } else {
+                        Ok(vec![p.parse_expr()?])
+                    }
+                })?;
                 self.expect_token(&Token::RParen)?;
                 modifiers.push(GroupByWithModifier::GroupingSets(Expr::GroupingSets(
                     result,
@@ -11072,6 +11091,7 @@ impl<'a> Parser<'a> {
                 Keyword::LIMIT,
                 Keyword::AGGREGATE,
                 Keyword::ORDER,
+                Keyword::TABLESAMPLE,
             ])?;
             match kw {
                 Keyword::SELECT => {
@@ -11134,6 +11154,10 @@ impl<'a> Parser<'a> {
                     let exprs = self.parse_comma_separated(Parser::parse_order_by_expr)?;
                     pipe_operators.push(PipeOperator::OrderBy { exprs })
                 }
+                Keyword::TABLESAMPLE => {
+                    let sample = self.parse_table_sample(TableSampleModifier::TableSample)?;
+                    pipe_operators.push(PipeOperator::TableSample { sample });
+                }
                 unhandled => {
                     return Err(ParserError::ParserError(format!(
                     "`expect_one_of_keywords` further up allowed unhandled keyword: {unhandled:?}"
@@ -12778,7 +12802,13 @@ impl<'a> Parser<'a> {
         } else {
             return Ok(None);
         };
+        self.parse_table_sample(modifier).map(Some)
+    }
 
+    fn parse_table_sample(
+        &mut self,
+        modifier: TableSampleModifier,
+    ) -> Result<Box<TableSample>, ParserError> {
         let name = match self.parse_one_of_keywords(&[
             Keyword::BERNOULLI,
             Keyword::ROW,
@@ -12860,14 +12890,14 @@ impl<'a> Parser<'a> {
             None
         };
 
-        Ok(Some(Box::new(TableSample {
+        Ok(Box::new(TableSample {
             modifier,
             name,
             quantity,
             seed,
             bucket,
             offset,
-        })))
+        }))
     }
 
     fn parse_table_sample_seed(
diff --git a/tests/sqlparser_common.rs b/tests/sqlparser_common.rs
@@ -2822,6 +2822,38 @@ fn parse_group_by_special_grouping_sets() {
     }
 }
 
+#[test]
+fn parse_group_by_grouping_sets_single_values() {
+    let sql = "SELECT a, b, SUM(c) FROM tab1 GROUP BY a, b GROUPING SETS ((a, b), a, (b), c, ())";
+    let canonical =
+        "SELECT a, b, SUM(c) FROM tab1 GROUP BY a, b GROUPING SETS ((a, b), (a), (b), (c), ())";
+    match all_dialects().one_statement_parses_to(sql, canonical) {
+        Statement::Query(query) => {
+            let group_by = &query.body.as_select().unwrap().group_by;
+            assert_eq!(
+                group_by,
+                &GroupByExpr::Expressions(
+                    vec![
+                        Expr::Identifier(Ident::new("a")),
+                        Expr::Identifier(Ident::new("b"))
+                    ],
+                    vec![GroupByWithModifier::GroupingSets(Expr::GroupingSets(vec![
+                        vec![
+                            Expr::Identifier(Ident::new("a")),
+                            Expr::Identifier(Ident::new("b"))
+                        ],
+                        vec![Expr::Identifier(Ident::new("a"))],
+                        vec![Expr::Identifier(Ident::new("b"))],
+                        vec![Expr::Identifier(Ident::new("c"))],
+                        vec![]
+                    ]))]
+                )
+            );
+        }
+        _ => unreachable!(),
+    }
+}
+
 #[test]
 fn parse_select_having() {
     let sql = "SELECT foo FROM bar GROUP BY foo HAVING COUNT(*) > 1";
@@ -4926,17 +4958,18 @@ fn parse_alter_table_drop_column() {
     check_one("DROP COLUMN IF EXISTS is_active CASCADE");
     check_one("DROP COLUMN IF EXISTS is_active RESTRICT");
     one_statement_parses_to(
-        "ALTER TABLE tab DROP IF EXISTS is_active CASCADE",
+        "ALTER TABLE tab DROP COLUMN IF EXISTS is_active CASCADE",
         "ALTER TABLE tab DROP COLUMN IF EXISTS is_active CASCADE",
     );
     one_statement_parses_to(
         "ALTER TABLE tab DROP is_active CASCADE",
-        "ALTER TABLE tab DROP COLUMN is_active CASCADE",
+        "ALTER TABLE tab DROP is_active CASCADE",
     );
 
     fn check_one(constraint_text: &str) {
         match alter_table_op(verified_stmt(&format!("ALTER TABLE tab {constraint_text}"))) {
             AlterTableOperation::DropColumn {
+                has_column_keyword: true,
                 column_name,
                 if_exists,
                 drop_behavior,
@@ -15157,6 +15190,11 @@ fn parse_pipeline_operator() {
     dialects.verified_stmt("SELECT * FROM users |> ORDER BY id DESC");
     dialects.verified_stmt("SELECT * FROM users |> ORDER BY id DESC, name ASC");
 
+    // tablesample pipe operator
+    dialects.verified_stmt("SELECT * FROM tbl |> TABLESAMPLE BERNOULLI (50)");
+    dialects.verified_stmt("SELECT * FROM tbl |> TABLESAMPLE SYSTEM (50 PERCENT)");
+    dialects.verified_stmt("SELECT * FROM tbl |> TABLESAMPLE SYSTEM (50) REPEATABLE (10)");
+
     // many pipes
     dialects.verified_stmt(
         "SELECT * FROM CustomerOrders |> AGGREGATE SUM(cost) AS total_cost GROUP BY customer_id, state, item_type |> EXTEND COUNT(*) OVER (PARTITION BY customer_id) AS num_orders |> WHERE num_orders > 1 |> AGGREGATE AVG(total_cost) AS average GROUP BY state DESC, item_type ASC",
diff --git a/tests/sqlparser_mssql.rs b/tests/sqlparser_mssql.rs
@@ -377,6 +377,46 @@ fn parse_create_function() {
     );
 }
 
+#[test]
+fn parse_create_function_parameter_default_values() {
+    let single_default_sql =
+        "CREATE FUNCTION test_func(@param1 INT = 42) RETURNS INT AS BEGIN RETURN @param1; END";
+    assert_eq!(
+        ms().verified_stmt(single_default_sql),
+        Statement::CreateFunction(CreateFunction {
+            or_alter: false,
+            or_replace: false,
+            temporary: false,
+            if_not_exists: false,
+            name: ObjectName::from(vec![Ident::new("test_func")]),
+            args: Some(vec![OperateFunctionArg {
+                mode: None,
+                name: Some(Ident::new("@param1")),
+                data_type: DataType::Int(None),
+                default_expr: Some(Expr::Value((number("42")).with_empty_span())),
+            },]),
+            return_type: Some(DataType::Int(None)),
+            function_body: Some(CreateFunctionBody::AsBeginEnd(BeginEndStatements {
+                begin_token: AttachedToken::empty(),
+                statements: vec![Statement::Return(ReturnStatement {
+                    value: Some(ReturnStatementValue::Expr(Expr::Identifier(Ident::new(
+                        "@param1"
+                    )))),
+                })],
+                end_token: AttachedToken::empty(),
+            })),
+            behavior: None,
+            called_on_null: None,
+            parallel: None,
+            using: None,
+            language: None,
+            determinism_specifier: None,
+            options: None,
+            remote_connection: None,
+        }),
+    );
+}
+
 #[test]
 fn parse_mssql_apply_join() {
     let _ = ms_and_generic().verified_only_select(
diff --git a/tests/sqlparser_mysql.rs b/tests/sqlparser_mysql.rs

Original file line number	Diff line number	Diff line change
`@@ -1559,7 +1559,7 @@ impl fmt::Display for TableSampleBucket {`
`1559`	`1559`	`}`
`1560`	`1560`	`impl fmt::Display for TableSample {`
`1561`	`1561`	`fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`1562`		`- write!(f, " {}", self.modifier)?;`
	`1562`	`+ write!(f, "{}", self.modifier)?;`
`1563`	`1563`	`if let Some(name) = &self.name {`
`1564`	`1564`	`write!(f, " {}", name)?;`
`1565`	`1565`	`}`
`@@ -1862,7 +1862,7 @@ impl fmt::Display for TableFactor {`
`1862`	`1862`	`write!(f, " WITH ORDINALITY")?;`
`1863`	`1863`	`}`
`1864`	`1864`	`if let Some(TableSampleKind::BeforeTableAlias(sample)) = sample {`
`1865`		`- write!(f, "{sample}")?;`
	`1865`	`+ write!(f, " {sample}")?;`
`1866`	`1866`	`}`
`1867`	`1867`	`if let Some(alias) = alias {`
`1868`	`1868`	`write!(f, " AS {alias}")?;`
`@@ -1877,7 +1877,7 @@ impl fmt::Display for TableFactor {`
`1877`	`1877`	`write!(f, "{version}")?;`
`1878`	`1878`	`}`
`1879`	`1879`	`if let Some(TableSampleKind::AfterTableAlias(sample)) = sample {`
`1880`		`- write!(f, "{sample}")?;`
	`1880`	`+ write!(f, " {sample}")?;`
`1881`	`1881`	`}`
`1882`	`1882`	`Ok(())`
`1883`	`1883`	`}`
`@@ -2680,6 +2680,10 @@ pub enum PipeOperator {`
`2680`	`2680`	`full_table_exprs: Vec<ExprWithAliasAndOrderBy>,`
`2681`	`2681`	`group_by_expr: Vec<ExprWithAliasAndOrderBy>,`
`2682`	`2682`	`},`
	`2683`	`+ /// Selects a random sample of rows from the input table.`
	`2684`	+ /// Syntax: `\|> TABLESAMPLE SYSTEM (10 PERCENT)
	`2685`	`+ /// See more at <https://cloud.google.com/bigquery/docs/reference/standard-sql/pipe-syntax#tablesample_pipe_operator>`
	`2686`	`+ TableSample { sample: Box<TableSample> },`
`2683`	`2687`	`}`
`2684`	`2688`
`2685`	`2689`	`impl fmt::Display for PipeOperator {`
`@@ -2731,6 +2735,10 @@ impl fmt::Display for PipeOperator {`
`2731`	`2735`	`PipeOperator::OrderBy { exprs } => {`
`2732`	`2736`	`write!(f, "ORDER BY {}", display_comma_separated(exprs.as_slice()))`
`2733`	`2737`	`}`
	`2738`	`+`
	`2739`	`+ PipeOperator::TableSample { sample } => {`
	`2740`	`+ write!(f, "{}", sample)`
	`2741`	`+ }`
`2734`	`2742`	`}`
`2735`	`2743`	`}`
`2736`	`2744`	`}`