feat: define opt_replace for wildcard replace

Author: togami2864

src/ast/mod.rs

@@ -36,7 +36,7 @@ pub use self::operator::{BinaryOperator, UnaryOperator};
 pub use self::query::{
     Cte, ExceptSelectItem, ExcludeSelectItem, Fetch, IdentWithAlias, Join, JoinConstraint,
     JoinOperator, LateralView, LockClause, LockType, NonBlock, Offset, OffsetRows, OrderByExpr,
-    Query, RenameSelectItem, Select, SelectInto, SelectItem, SetExpr, SetOperator, SetQuantifier,
+    Query, RenameSelectItem, ReplaceSelectItem, Select, SelectInto, SelectItem, SetExpr, SetOperator, SetQuantifier,
     Table, TableAlias, TableFactor, TableWithJoins, Top, Values, WildcardAdditionalOptions, With,
 };
 pub use self::value::{

src/ast/query.rs

@@ -394,6 +394,8 @@ pub struct WildcardAdditionalOptions {
     pub opt_except: Option<ExceptSelectItem>,
     /// `[RENAME ...]`.
     pub opt_rename: Option<RenameSelectItem>,
+    /// `[REPLACE]`
+    pub opt_replace:Option<ReplaceSelectItem>
 }
 
 impl fmt::Display for WildcardAdditionalOptions {
@@ -526,6 +528,46 @@ impl fmt::Display for ExceptSelectItem {
     }
 }
 
+/// Bigquery `REPLACE` information.
+///
+/// # Syntax
+/// ```plaintext
+/// REPLACE <new_expr> AS <col_name>
+/// ```
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum ReplaceSelectItem {
+    /// Single column name with alias without parenthesis.
+    ///
+    /// # Syntax
+    /// ```plaintext
+    /// <col_name> AS <col_alias>
+    /// ```
+    Single(IdentWithAlias),
+    /// Multiple column names with aliases inside parenthesis.
+    /// # Syntax
+    /// ```plaintext
+    /// (<col_name> AS <col_alias>, <col_name> AS <col_alias>, ...)
+    /// ```
+    Multiple(Vec<IdentWithAlias>),
+}
+
+impl fmt::Display for ReplaceSelectItem {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "REPLACE")?;
+        match self {
+            Self::Single(column) => {
+                write!(f, " {column}")?;
+            }
+            Self::Multiple(columns) => {
+                write!(f, " ({})", display_comma_separated(columns))?;
+            }
+        }
+        Ok(())
+    }
+}
+
 impl fmt::Display for SelectItem {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match &self {

src/parser.rs

@@ -6164,10 +6164,17 @@ impl<'a> Parser<'a> {
             None
         };
 
+        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
         })
     }
 
@@ -6241,6 +6248,27 @@ 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))
+                }
+            } else {
+                None
+            };
+
+            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> {
         let expr = self.parse_expr()?;