fix: modify replace option ast

Author: togami2864

src/ast/query.rs

@@ -395,7 +395,7 @@ pub struct WildcardAdditionalOptions {
     /// `[RENAME ...]`.
     pub opt_rename: Option<RenameSelectItem>,
     /// `[REPLACE]`
-    pub opt_replace:Option<ReplaceSelectItem>
+    pub opt_replace: Option<ReplaceSelectItem>,
 }
 
 impl fmt::Display for WildcardAdditionalOptions {
@@ -409,6 +409,9 @@ impl fmt::Display for WildcardAdditionalOptions {
         if let Some(rename) = &self.opt_rename {
             write!(f, " {rename}")?;
         }
+        if let Some(replace) = &self.opt_replace {
+            write!(f, " {replace}")?;
+        }
         Ok(())
     }
 }
@@ -544,13 +547,13 @@ pub enum ReplaceSelectItem {
     /// ```plaintext
     /// <col_name> AS <col_alias>
     /// ```
-    Single(IdentWithAlias),
+    Single(Box<SelectItem>),
     /// Multiple column names with aliases inside parenthesis.
     /// # Syntax
     /// ```plaintext
     /// (<col_name> AS <col_alias>, <col_name> AS <col_alias>, ...)
     /// ```
-    Multiple(Vec<IdentWithAlias>),
+    Multiple(Vec<Box<SelectItem>>),
 }
 
 impl fmt::Display for ReplaceSelectItem {

src/parser.rs

@@ -6164,17 +6164,17 @@ impl<'a> Parser<'a> {
             None
         };
 
-        let opt_replace = if dialect_of!(self is GenericDialect | BigQueryDialect){
-    self.parse_optional_select_item_replace()?
-        }else {
+        let opt_replace = if dialect_of!(self is GenericDialect | BigQueryDialect) {
+            self.parse_optional_select_item_replace()?
+        } else {
             None
         };
 
         Ok(WildcardAdditionalOptions {
             opt_exclude,
             opt_except,
             opt_rename,
-            opt_replace
+            opt_replace,
         })
     }
 
@@ -6248,26 +6248,26 @@ impl<'a> Parser<'a> {
         Ok(opt_rename)
     }
 
-        /// Parse a [`Replace](RepalceSelectItem) information for wildcard select items.
-        pub fn parse_optional_select_item_replace(
-            &mut self,
-        ) -> Result<Option<ReplaceSelectItem>, ParserError> {
-            let opt_replace = if self.parse_keyword(Keyword::REPLACE) {
-                if self.consume_token(&Token::LParen) {
-                    let idents =
-                        self.parse_comma_separated(|parser| parser.parse_identifier_with_alias())?;
-                    self.expect_token(&Token::RParen)?;
-                    Some(ReplaceSelectItem::Multiple(idents))
-                } else {
-                    let ident = self.parse_identifier_with_alias()?;
-                    Some(ReplaceSelectItem::Single(ident))
-                }
+    /// Parse a [`Replace](RepalceSelectItem) information for wildcard select items.
+    pub fn parse_optional_select_item_replace(
+        &mut self,
+    ) -> Result<Option<ReplaceSelectItem>, ParserError> {
+        let opt_replace = if self.parse_keyword(Keyword::REPLACE) {
+            if self.consume_token(&Token::LParen) {
+                let idents =
+                    self.parse_comma_separated(|parser| Ok(Box::new(parser.parse_select_item()?)))?;
+                self.expect_token(&Token::RParen)?;
+                Some(ReplaceSelectItem::Multiple(idents))
             } else {
-                None
-            };
+                let ident = self.parse_select_item()?;
+                Some(ReplaceSelectItem::Single(Box::new(ident)))
+            }
+        } else {
+            None
+        };
 
-            Ok(opt_replace)
-        }
+        Ok(opt_replace)
+    }
 
     /// Parse an expression, optionally followed by ASC or DESC (used in ORDER BY)
     pub fn parse_order_by_expr(&mut self) -> Result<OrderByExpr, ParserError> {

tests/sqlparser_bigquery.rs

@@ -315,17 +315,22 @@ fn test_select_wildcard_with_except() {
 
 #[test]
 fn test_select_wildcard_with_replace() {
-    let select = bigquery_and_generic().verified_only_select(r#"WITH orders AS
-    (SELECT 5 as order_id,
-    "sprocket" as item_name,
-    200 as quantity)
-  SELECT * REPLACE ("widget" AS item_name)
-  FROM orders;"#);
+    let select = bigquery_and_generic()
+        .verified_only_select(r#"SELECT * REPLACE (quantity / 2 AS quantity) FROM orders"#);
     let expected = SelectItem::Wildcard(WildcardAdditionalOptions {
-        opt_except: Some(ExceptSelectItem {
-            first_element: Ident::new("col_a"),
-            additional_elements: vec![],
-        }),
+        opt_replace: Some(ReplaceSelectItem::Multiple(vec![Box::new(
+            SelectItem::ExprWithAlias {
+                expr: Expr::BinaryOp {
+                    left: Box::new(sqlparser::ast::Expr::Identifier(Ident::new("quantity"))),
+                    op: BinaryOperator::Divide,
+                    right: Box::new(sqlparser::ast::Expr::Value(Value::Number(
+                        "2".to_string(),
+                        false,
+                    ))),
+                },
+                alias: Ident::new("quantity"),
+            },
+        )])),
         ..Default::default()
     });
     assert_eq!(expected, select.projection[0]);