refactor: order_by_all

Author: PokIsemaine

src/ast/mod.rs

@@ -66,16 +66,15 @@ pub use self::query::{
     JsonTableColumn, JsonTableColumnErrorHandling, JsonTableNamedColumn, JsonTableNestedColumn,
     LateralView, LockClause, LockType, MatchRecognizePattern, MatchRecognizeSymbol, Measure,
     NamedWindowDefinition, NamedWindowExpr, NonBlock, Offset, OffsetRows, OpenJsonTableColumn,
-    OrderBy, OrderByAll, OrderByExpr, OrderByExprsWithInterpolate, PivotValueSource,
-    ProjectionSelect, Query, RenameSelectItem, RepetitionQuantifier, ReplaceSelectElement,
-    ReplaceSelectItem, RowsPerMatch, Select, SelectFlavor, SelectInto, SelectItem,
-    SelectItemQualifiedWildcardKind, SetExpr, SetOperator, SetQuantifier, Setting,
-    SymbolDefinition, Table, TableAlias, TableAliasColumnDef, TableFactor, TableFunctionArgs,
-    TableIndexHintForClause, TableIndexHintType, TableIndexHints, TableIndexType, TableSample,
-    TableSampleBucket, TableSampleKind, TableSampleMethod, TableSampleModifier,
-    TableSampleQuantity, TableSampleSeed, TableSampleSeedModifier, TableSampleUnit, TableVersion,
-    TableWithJoins, Top, TopQuantity, UpdateTableFromKind, ValueTableMode, Values,
-    WildcardAdditionalOptions, With, WithFill,
+    OrderBy, OrderByAll, OrderByExpr, OrderByKind, PivotValueSource, ProjectionSelect, Query,
+    RenameSelectItem, RepetitionQuantifier, ReplaceSelectElement, ReplaceSelectItem, RowsPerMatch,
+    Select, SelectFlavor, SelectInto, SelectItem, SelectItemQualifiedWildcardKind, SetExpr,
+    SetOperator, SetQuantifier, Setting, SymbolDefinition, Table, TableAlias, TableAliasColumnDef,
+    TableFactor, TableFunctionArgs, TableIndexHintForClause, TableIndexHintType, TableIndexHints,
+    TableIndexType, TableSample, TableSampleBucket, TableSampleKind, TableSampleMethod,
+    TableSampleModifier, TableSampleQuantity, TableSampleSeed, TableSampleSeedModifier,
+    TableSampleUnit, TableVersion, TableWithJoins, Top, TopQuantity, UpdateTableFromKind,
+    ValueTableMode, Values, WildcardAdditionalOptions, With, WithFill,
 };
 
 pub use self::trigger::{

src/ast/query.rs

@@ -2205,25 +2205,48 @@ pub enum JoinConstraint {
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
-pub enum OrderBy {
+pub enum OrderByKind {
     /// ALL syntax of [DuckDB] and [ClickHouse].
     ///
     /// [DuckDB]:  <https://duckdb.org/docs/sql/query_syntax/orderby>
     /// [ClickHouse]: <https://clickhouse.com/docs/en/sql-reference/statements/select/order-by>
     All(OrderByAll),
 
     /// Expressions
-    Expressions(OrderByExprsWithInterpolate),
+    Expressions(Vec<OrderByExpr>),
+}
+
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct OrderBy {
+    pub kind: OrderByKind,
+
+    /// Optional: `INTERPOLATE`
+    /// Supported by [ClickHouse syntax]
+    /// Note that when combined with `OrderByKind::All`, it should be None, as ClickHouse doesn't support using them together.
+    ///
+    /// [ClickHouse syntax]: <https://clickhouse.com/docs/en/sql-reference/statements/select/order-by#order-by-expr-with-fill-modifier>
+    pub interpolate: Option<Interpolate>,
 }
 
 impl fmt::Display for OrderBy {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "ORDER BY")?;
-        match self {
-            OrderBy::Expressions(exprs) => {
-                write!(f, "{}", exprs)?;
+        match &self.kind {
+            OrderByKind::Expressions(exprs) => {
+                write!(f, " {}", display_comma_separated(exprs))?;
+
+                if let Some(ref interpolate) = self.interpolate {
+                    match &interpolate.exprs {
+                        Some(exprs) => {
+                            write!(f, " INTERPOLATE ({})", display_comma_separated(exprs))?
+                        }
+                        None => write!(f, " INTERPOLATE")?,
+                    }
+                }
             }
-            OrderBy::All(all) => {
+            OrderByKind::All(all) => {
                 write!(f, " ALL{}", all)?;
             }
         }
@@ -2232,23 +2255,6 @@ impl fmt::Display for OrderBy {
     }
 }
 
-impl OrderBy {
-    pub fn get_exprs(&self) -> Option<&Vec<OrderByExpr>> {
-        match self {
-            OrderBy::Expressions(exprs_with_interpolate) => Some(&exprs_with_interpolate.exprs),
-            OrderBy::All(_) => None,
-        }
-    }
-    pub fn get_interpolate(&self) -> Option<&Interpolate> {
-        match self {
-            OrderBy::Expressions(exprs_with_interpolate) => {
-                exprs_with_interpolate.interpolate.as_ref()
-            }
-            OrderBy::All(_) => None,
-        }
-    }
-}
-
 /// An `ORDER BY` expression
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
@@ -2342,34 +2348,6 @@ impl fmt::Display for InterpolateExpr {
     }
 }
 
-/// `ORDER BY` expressions with interpolate
-#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
-pub struct OrderByExprsWithInterpolate {
-    pub exprs: Vec<OrderByExpr>,
-    /// Expressions
-    /// Optional: `INTERPOLATE`
-    /// 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<Interpolate>,
-}
-
-impl fmt::Display for OrderByExprsWithInterpolate {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        if !self.exprs.is_empty() {
-            write!(f, " {}", display_comma_separated(&self.exprs))?;
-        }
-        if let Some(ref interpolate) = self.interpolate {
-            match &interpolate.exprs {
-                Some(exprs) => write!(f, " INTERPOLATE ({})", display_comma_separated(exprs))?,
-                None => write!(f, " INTERPOLATE")?,
-            }
-        }
-        Ok(())
-    }
-}
-
 /// 'ORDER BY ALL' clause
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

src/ast/spans.rs

@@ -30,7 +30,7 @@ use super::{
     GroupByExpr, HavingBound, IlikeSelectItem, Insert, Interpolate, InterpolateExpr, Join,
     JoinConstraint, JoinOperator, JsonPath, JsonPathElem, LateralView, MatchRecognizePattern,
     Measure, NamedWindowDefinition, ObjectName, ObjectNamePart, Offset, OnConflict,
-    OnConflictAction, OnInsert, OrderBy, OrderByExpr, Partition, PivotValueSource,
+    OnConflictAction, OnInsert, OrderBy, OrderByExpr, OrderByKind, Partition, PivotValueSource,
     ProjectionSelect, Query, ReferentialAction, RenameSelectItem, ReplaceSelectElement,
     ReplaceSelectItem, Select, SelectInto, SelectItem, SetExpr, SqlOption, Statement, Subscript,
     SymbolDefinition, TableAlias, TableAliasColumnDef, TableConstraint, TableFactor, TableObject,
@@ -1102,14 +1102,13 @@ impl Spanned for ProjectionSelect {
 /// - [OrderBy::All]
 impl Spanned for OrderBy {
     fn span(&self) -> Span {
-        match self {
-            OrderBy::All(_) => Span::empty(),
-            OrderBy::Expressions(expressions) => union_spans(
-                expressions
-                    .exprs
+        match &self.kind {
+            OrderByKind::All(_) => Span::empty(),
+            OrderByKind::Expressions(exprs) => union_spans(
+                exprs
                     .iter()
                     .map(|i| i.span())
-                    .chain(expressions.interpolate.iter().map(|i| i.span())),
+                    .chain(self.interpolate.iter().map(|i| i.span())),
             ),
         }
     }

src/dialect/clickhouse.rs

@@ -79,4 +79,9 @@ impl Dialect for ClickHouseDialect {
     fn supports_from_first_select(&self) -> bool {
         true
     }
+
+    // See <https://clickhouse.com/docs/en/sql-reference/statements/select/order-by>
+    fn supports_order_by_all(&self) -> bool {
+        true
+    }
 }

src/dialect/duckdb.rs

@@ -89,4 +89,9 @@ impl Dialect for DuckDbDialect {
     fn supports_from_first_select(&self) -> bool {
         true
     }
+
+    // See DuckDB <https://duckdb.org/docs/sql/query_syntax/orderby.html#order-by-all-examples>
+    fn supports_order_by_all(&self) -> bool {
+        true
+    }
 }

src/dialect/mod.rs

@@ -912,6 +912,16 @@ pub trait Dialect: Debug + Any {
     fn supports_array_typedef_size(&self) -> bool {
         false
     }
+
+    /// Returns true if the dialect supports `ORDER BY ALL`.
+    /// `ALL` which means all columns of the SELECT clause.
+    ///
+    /// DuckDB: <https://duckdb.org/docs/sql/query_syntax/orderby.html#order-by-all>
+    /// ClickHouse: <https://clickhouse.com/docs/en/sql-reference/statements/select/order-by>
+    /// For example: ```SELECT * FROM addresses ORDER BY ALL;```.
+    fn supports_order_by_all(&self) -> bool {
+        false
+    }
 }
 
 /// This represents the operators for which precedence must be defined

src/parser/mod.rs

@@ -9184,16 +9184,28 @@ impl<'a> Parser<'a> {
     pub fn parse_optional_order_by(&mut self) -> Result<Option<OrderBy>, ParserError> {
         if self.parse_keywords(&[Keyword::ORDER, Keyword::BY]) {
             let order_by = if self.parse_keyword(Keyword::ALL) {
+                if !self.dialect.supports_order_by_all() {
+                    return parser_err!(
+                        "ALL is not supported in ORDER BY",
+                        self.peek_token().span.start
+                    );
+                }
                 let order_by_all = self.parse_order_by_all()?;
-                OrderBy::All(order_by_all)
+                OrderBy {
+                    kind: OrderByKind::All(order_by_all),
+                    interpolate: None,
+                }
             } else {
                 let exprs = self.parse_comma_separated(Parser::parse_order_by_expr)?;
                 let interpolate = if dialect_of!(self is ClickHouseDialect | GenericDialect) {
                     self.parse_interpolations()?
                 } else {
                     None
                 };
-                OrderBy::Expressions(OrderByExprsWithInterpolate { exprs, interpolate })
+                OrderBy {
+                    kind: OrderByKind::Expressions(exprs),
+                    interpolate,
+                }
             };
             Ok(Some(order_by))
         } else {

tests/sqlparser_clickhouse.rs

@@ -322,15 +322,15 @@ fn parse_alter_table_add_projection() {
                             vec![Identifier(Ident::new("a"))],
                             vec![]
                         )),
-                        order_by: Some(OrderBy::Expressions(OrderByExprsWithInterpolate {
-                            exprs: vec![OrderByExpr {
+                        order_by: Some(OrderBy {
+                            kind: OrderByKind::Expressions(vec![OrderByExpr {
                                 expr: Identifier(Ident::new("b")),
                                 asc: None,
                                 nulls_first: None,
                                 with_fill: None,
-                            }],
+                            }]),
                             interpolate: None,
-                        })),
+                        }),
                     }
                 }
             )
@@ -1134,8 +1134,8 @@ fn parse_select_order_by_with_fill_interpolate() {
         LIMIT 2";
     let select = clickhouse().verified_query(sql);
     assert_eq!(
-        OrderBy::Expressions(OrderByExprsWithInterpolate {
-            exprs: vec![
+        OrderBy {
+            kind: OrderByKind::Expressions(vec![
                 OrderByExpr {
                     expr: Expr::Identifier(Ident::new("fname")),
                     asc: Some(true),
@@ -1156,7 +1156,7 @@ fn parse_select_order_by_with_fill_interpolate() {
                         step: Some(Expr::Value(number("3"))),
                     }),
                 },
-            ],
+            ]),
             interpolate: Some(Interpolate {
                 exprs: Some(vec![InterpolateExpr {
                     column: Ident::new("col1"),
@@ -1167,7 +1167,7 @@ fn parse_select_order_by_with_fill_interpolate() {
                     }),
                 }])
             })
-        }),
+        },
         select.order_by.expect("ORDER BY expected")
     );
     assert_eq!(Some(Expr::Value(number("2"))), select.limit);
@@ -1214,13 +1214,12 @@ fn parse_with_fill() {
             from: Some(Expr::Value(number("10"))),
             to: Some(Expr::Value(number("20"))),
             step: Some(Expr::Value(number("2"))),
-        }),
-        select
-            .order_by
-            .expect("ORDER BY expected")
-            .get_exprs()
-            .unwrap()[0]
-            .with_fill
+        })
+        .as_ref(),
+        match select.order_by.expect("ORDER BY expected").kind {
+            OrderByKind::Expressions(ref exprs) => exprs[0].with_fill.as_ref(),
+            _ => None,
+        }
     );
 }
 
@@ -1276,7 +1275,8 @@ fn parse_interpolate_body_with_columns() {
         select
             .order_by
             .expect("ORDER BY expected")
-            .get_interpolate()
+            .interpolate
+            .as_ref()
     );
 }
 
@@ -1289,7 +1289,8 @@ fn parse_interpolate_without_body() {
         select
             .order_by
             .expect("ORDER BY expected")
-            .get_interpolate()
+            .interpolate
+            .as_ref()
     );
 }
 
@@ -1305,7 +1306,8 @@ fn parse_interpolate_with_empty_body() {
         select
             .order_by
             .expect("ORDER BY expected")
-            .get_interpolate()
+            .interpolate
+            .as_ref()
     );
 }