Simplify parsing, remove InterpolateArg::Empty

Author: nickpresta

src/ast/mod.rs

@@ -43,15 +43,14 @@ pub use self::operator::{BinaryOperator, UnaryOperator};
 pub use self::query::{
     AfterMatchSkip, ConnectBy, Cte, CteAsMaterialized, Distinct, EmptyMatchesMode,
     ExceptSelectItem, ExcludeSelectItem, ExprWithAlias, Fetch, ForClause, ForJson, ForXml,
-    GroupByExpr, GroupByWithModifier, IdentWithAlias, IlikeSelectItem, Interpolation,
-    InterpolationArg, Join, JoinConstraint, JoinOperator, JsonTableColumn,
-    JsonTableColumnErrorHandling, LateralView, LockClause, LockType, MatchRecognizePattern,
-    MatchRecognizeSymbol, Measure, NamedWindowDefinition, NamedWindowExpr, NonBlock, Offset,
-    OffsetRows, OrderByExpr, PivotValueSource, Query, RenameSelectItem, RepetitionQuantifier,
-    ReplaceSelectElement, ReplaceSelectItem, RowsPerMatch, Select, SelectInto, SelectItem, SetExpr,
-    SetOperator, SetQuantifier, SymbolDefinition, Table, TableAlias, TableFactor, TableVersion,
-    TableWithJoins, Top, TopQuantity, ValueTableMode, Values, WildcardAdditionalOptions, With,
-    WithFill,
+    GroupByExpr, GroupByWithModifier, IdentWithAlias, IlikeSelectItem, Interpolate, InterpolateArg,
+    Join, JoinConstraint, JoinOperator, JsonTableColumn, JsonTableColumnErrorHandling, LateralView,
+    LockClause, LockType, MatchRecognizePattern, MatchRecognizeSymbol, Measure,
+    NamedWindowDefinition, NamedWindowExpr, NonBlock, Offset, OffsetRows, OrderByExpr,
+    PivotValueSource, Query, RenameSelectItem, RepetitionQuantifier, ReplaceSelectElement,
+    ReplaceSelectItem, RowsPerMatch, Select, SelectInto, SelectItem, SetExpr, SetOperator,
+    SetQuantifier, SymbolDefinition, Table, TableAlias, TableFactor, TableVersion, TableWithJoins,
+    Top, TopQuantity, ValueTableMode, Values, WildcardAdditionalOptions, With, WithFill,
 };
 pub use self::value::{
     escape_double_quote_string, escape_quoted_string, DateTimeField, DollarQuotedString,

src/ast/query.rs

@@ -1634,7 +1634,7 @@ pub struct OrderByExpr {
     /// Supported by [ClickHouse syntax]
     ///
     /// [ClickHouse syntax]: <https://clickhouse.com/docs/en/sql-reference/statements/select/order-by#order-by-expr-with-fill-modifier>
-    pub interpolate: Option<InterpolationArg>,
+    pub interpolate: Option<InterpolateArg>,
 }
 
 impl fmt::Display for OrderByExpr {
@@ -1655,10 +1655,13 @@ impl fmt::Display for OrderByExpr {
         }
         if let Some(ref interpolate) = self.interpolate {
             match interpolate {
-                InterpolationArg::NoBody => write!(f, " INTERPOLATE")?,
-                InterpolationArg::EmptyBody => write!(f, " INTERPOLATE ()")?,
-                InterpolationArg::Columns(columns) => {
-                    write!(f, " INTERPOLATE ({})", display_comma_separated(columns))?;
+                InterpolateArg::NoBody => write!(f, " INTERPOLATE")?,
+                InterpolateArg::Columns(columns) => {
+                    if columns.is_empty() {
+                        write!(f, " INTERPOLATE ()")?;
+                    } else {
+                        write!(f, " INTERPOLATE ({})", display_comma_separated(columns))?;
+                    }
                 }
             }
         }
@@ -1702,21 +1705,20 @@ impl fmt::Display for WithFill {
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
-pub struct Interpolation {
-    pub column: Expr,
+pub struct Interpolate {
+    pub column: Ident,
     pub formula: Option<Expr>,
 }
 
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
-pub enum InterpolationArg {
+pub enum InterpolateArg {
     NoBody,
-    EmptyBody,
-    Columns(Vec<Interpolation>),
+    Columns(Vec<Interpolate>),
 }
 
-impl fmt::Display for Interpolation {
+impl fmt::Display for Interpolate {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}", self.column)?;
         if let Some(ref formula) = self.formula {

src/parser/mod.rs

@@ -10420,19 +10420,13 @@ impl<'a> Parser<'a> {
             && self.parse_keyword(Keyword::INTERPOLATE)
         {
             if self.consume_token(&Token::LParen) {
-                if self.peek_token().token == Token::RParen {
-                    // INTERPOLATE ()
-                    self.next_token();
-                    Some(InterpolationArg::EmptyBody)
-                } else {
-                    // INTERPOLATE ( ... )
-                    let interpolations = self.parse_interpolations()?;
-                    self.expect_token(&Token::RParen)?;
-                    Some(InterpolationArg::Columns(interpolations))
-                }
+                let interpolations = self.parse_interpolations()?;
+                self.expect_token(&Token::RParen)?;
+                // INTERPOLATE () and INTERPOLATE ( ... ) variants
+                Some(InterpolateArg::Columns(interpolations))
             } else {
                 // INTERPOLATE
-                Some(InterpolationArg::NoBody)
+                Some(InterpolateArg::NoBody)
             }
         } else {
             None
@@ -10473,19 +10467,19 @@ impl<'a> Parser<'a> {
 
     // Parse a set of comma seperated INTERPOLATE expressions (ClickHouse dialect)
     // that follow the INTERPOLATE keyword in an ORDER BY clause with the WITH FILL modifier
-    pub fn parse_interpolations(&mut self) -> Result<Vec<Interpolation>, ParserError> {
-        self.parse_comma_separated(|p| p.parse_interpolation())
+    pub fn parse_interpolations(&mut self) -> Result<Vec<Interpolate>, ParserError> {
+        self.parse_comma_separated0(|p| p.parse_interpolation())
     }
 
     // Parse a INTERPOLATE expression (ClickHouse dialect)
-    pub fn parse_interpolation(&mut self) -> Result<Interpolation, ParserError> {
-        let column = self.parse_expr()?;
+    pub fn parse_interpolation(&mut self) -> Result<Interpolate, ParserError> {
+        let column = self.parse_identifier(false)?;
         let formula = if self.parse_keyword(Keyword::AS) {
             Some(self.parse_expr()?)
         } else {
             None
         };
-        Ok(Interpolation { column, formula })
+        Ok(Interpolate { column, formula })
     }
 
     /// Parse a TOP clause, MSSQL equivalent of LIMIT,

tests/sqlparser_clickhouse.rs

@@ -712,8 +712,8 @@ fn parse_select_order_by_with_fill_interpolate() {
                     to: Some(Expr::Value(number("40"))),
                     step: Some(Expr::Value(number("3"))),
                 }),
-                interpolate: Some(InterpolationArg::Columns(vec![Interpolation {
-                    column: Expr::Identifier(Ident::new("col1")),
+                interpolate: Some(InterpolateArg::Columns(vec![Interpolate {
+                    column: Ident::new("col1"),
                     formula: Some(Expr::BinaryOp {
                         left: Box::new(Expr::Identifier(Ident::new("col1"))),
                         op: BinaryOperator::Plus,
@@ -743,26 +743,26 @@ fn parse_with_fill() {
 }
 
 #[test]
-fn parse_interpolation_body_with_columns() {
+fn parse_interpolate_body_with_columns() {
     let sql = "SELECT fname FROM customer ORDER BY fname WITH FILL \
         INTERPOLATE (col1 AS col1 + 1, col2 AS col3, col4 AS col4 + 4)";
     let select = clickhouse().verified_query(sql);
     assert_eq!(
-        Some(InterpolationArg::Columns(vec![
-            Interpolation {
-                column: Expr::Identifier(Ident::new("col1")),
+        Some(InterpolateArg::Columns(vec![
+            Interpolate {
+                column: Ident::new("col1"),
                 formula: Some(Expr::BinaryOp {
                     left: Box::new(Expr::Identifier(Ident::new("col1"))),
                     op: BinaryOperator::Plus,
                     right: Box::new(Expr::Value(number("1"))),
                 }),
             },
-            Interpolation {
-                column: Expr::Identifier(Ident::new("col2")),
+            Interpolate {
+                column: Ident::new("col2"),
                 formula: Some(Expr::Identifier(Ident::new("col3"))),
             },
-            Interpolation {
-                column: Expr::Identifier(Ident::new("col4")),
+            Interpolate {
+                column: Ident::new("col4"),
                 formula: Some(Expr::BinaryOp {
                     left: Box::new(Expr::Identifier(Ident::new("col4"))),
                     op: BinaryOperator::Plus,
@@ -775,21 +775,18 @@ fn parse_interpolation_body_with_columns() {
 }
 
 #[test]
-fn parse_interpolation_without_body() {
+fn parse_interpolate_without_body() {
     let sql = "SELECT fname FROM customer ORDER BY fname WITH FILL INTERPOLATE";
     let select = clickhouse().verified_query(sql);
-    assert_eq!(
-        Some(InterpolationArg::NoBody),
-        select.order_by[0].interpolate
-    );
+    assert_eq!(Some(InterpolateArg::NoBody), select.order_by[0].interpolate);
 }
 
 #[test]
-fn parse_interpolation_with_empty_body() {
+fn parse_interpolate_with_empty_body() {
     let sql = "SELECT fname FROM customer ORDER BY fname WITH FILL INTERPOLATE ()";
     let select = clickhouse().verified_query(sql);
     assert_eq!(
-        Some(InterpolationArg::EmptyBody),
+        Some(InterpolateArg::Columns(vec![])),
         select.order_by[0].interpolate
     );
 }