feat: parse select replace items

Author: togami2864

src/ast/mod.rs

@@ -36,9 +36,9 @@ 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, ReplaceSelectItem, Select, SelectInto, SelectItem, SetExpr,
-    SetOperator, SetQuantifier, Table, TableAlias, TableFactor, TableWithJoins, Top, Values,
-    WildcardAdditionalOptions, With,
+    Query, RenameSelectItem, ReplaceSelectElement, ReplaceSelectItem, Select, SelectInto,
+    SelectItem, SetExpr, SetOperator, SetQuantifier, Table, TableAlias, TableFactor,
+    TableWithJoins, Top, Values, WildcardAdditionalOptions, With,
 };
 pub use self::value::{
     escape_quoted_string, DateTimeField, DollarQuotedString, TrimWhereField, Value,

src/ast/query.rs

@@ -540,33 +540,21 @@ impl fmt::Display for ExceptSelectItem {
 #[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.
-    ///
+pub struct ReplaceSelectItem {
     /// # Syntax
     /// ```plaintext
-    /// <col_name> [AS] <col_alias>
+    /// (<col_name> [AS] <col_alias>)
     /// ```
-    Single(Box<ReplaceSelectElement>),
-    /// Multiple column names with aliases inside parenthesis.
-    /// # Syntax
     /// ```plaintext
     /// (<col_name> [AS] <col_alias>, <col_name> [AS] <col_alias>, ...)
     /// ```
-    Multiple(Vec<Box<ReplaceSelectElement>>),
+    pub items: Vec<Box<ReplaceSelectElement>>,
 }
 
 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))?;
-            }
-        }
+        write!(f, " ({})", display_comma_separated(&self.items))?;
         Ok(())
     }
 }

src/parser.rs

@@ -6254,20 +6254,31 @@ impl<'a> Parser<'a> {
     ) -> 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()?)))?;
+                let items = self.parse_comma_separated(|parser| {
+                    Ok(Box::new(parser.parse_replace_elements()?))
+                })?;
                 self.expect_token(&Token::RParen)?;
-                Some(ReplaceSelectItem::Multiple(idents))
+                Some(ReplaceSelectItem { items })
             } else {
-                let ident = self.parse_select_item()?;
-                Some(ReplaceSelectItem::Single(Box::new(ident)))
+                let tok = self.next_token();
+                return self.expected("( after REPLACE but", tok);
             }
         } else {
             None
         };
 
         Ok(opt_replace)
     }
+    pub fn parse_replace_elements(&mut self) -> Result<ReplaceSelectElement, ParserError> {
+        let expr = self.parse_expr()?;
+        let as_keyword = self.parse_keyword(Keyword::AS);
+        let ident = self.parse_identifier()?;
+        Ok(ReplaceSelectElement {
+            expr,
+            colum_name: ident,
+            as_keyword,
+        })
+    }
 
     /// 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

@@ -321,37 +321,47 @@ fn test_select_wildcard_with_except() {
 #[test]
 fn test_select_wildcard_with_replace() {
     let select = bigquery_and_generic()
-        .verified_only_select(r#"SELECT * REPLACE 'widget' AS item_name FROM orders"#);
+        .verified_only_select(r#"SELECT * REPLACE ('widget' AS item_name) FROM orders"#);
     let expected = SelectItem::Wildcard(WildcardAdditionalOptions {
-        opt_replace: Some(ReplaceSelectItem::Single(Box::new(
-            SelectItem::ExprWithAlias {
+        opt_replace: Some(ReplaceSelectItem {
+            items: vec![Box::new(ReplaceSelectElement {
                 expr: Expr::Value(Value::SingleQuotedString("widget".to_owned())),
-                alias: Ident::new("item_name"),
-            },
-        ))),
+                colum_name: Ident::new("item_name"),
+                as_keyword: true,
+            })],
+        }),
         ..Default::default()
     });
     assert_eq!(expected, select.projection[0]);
 
-    let select = bigquery_and_generic()
-        .verified_only_select(r#"SELECT * REPLACE (quantity / 2 AS quantity) FROM orders"#);
+    let select = bigquery_and_generic().verified_only_select(
+        r#"SELECT * REPLACE (quantity / 2 AS quantity, 3 AS order_id) FROM orders"#,
+    );
     let expected = SelectItem::Wildcard(WildcardAdditionalOptions {
-        opt_replace: Some(ReplaceSelectItem::Multiple(vec![Box::new(
-            SelectItem::ExprWithAlias {
-                expr: Expr::BinaryOp {
-                    left: Box::new(Expr::Identifier(Ident::new("quantity"))),
-                    op: BinaryOperator::Divide,
-                    #[cfg(not(feature = "bigdecimal"))]
-                    right: Box::new(Expr::Value(Value::Number("2".to_string(), false))),
-                    #[cfg(feature = "bigdecimal")]
-                    right: Box::new(Expr::Value(Value::Number(
-                        BigDecimal::from_str("2").unwrap(),
-                        false,
-                    ))),
-                },
-                alias: Ident::new("quantity"),
-            },
-        )])),
+        opt_replace: Some(ReplaceSelectItem {
+            items: vec![
+                Box::new(ReplaceSelectElement {
+                    expr: Expr::BinaryOp {
+                        left: Box::new(Expr::Identifier(Ident::new("quantity"))),
+                        op: BinaryOperator::Divide,
+                        #[cfg(not(feature = "bigdecimal"))]
+                        right: Box::new(Expr::Value(Value::Number("2".to_string(), false))),
+                        #[cfg(feature = "bigdecimal")]
+                        right: Box::new(Expr::Value(Value::Number(
+                            BigDecimal::from_str("2").unwrap(),
+                            false,
+                        ))),
+                    },
+                    colum_name: Ident::new("quantity"),
+                    as_keyword: true,
+                }),
+                Box::new(ReplaceSelectElement {
+                    expr: Expr::Value(Value::Number("3".to_string(), false)),
+                    colum_name: Ident::new("order_id"),
+                    as_keyword: true,
+                }),
+            ],
+        }),
         ..Default::default()
     });
     assert_eq!(expected, select.projection[0]);