Box less-used Enums types

Author: Alexander Beedie

src/ast/mod.rs

@@ -1362,11 +1362,11 @@ pub enum Subscript {
     /// ```
     Slice {
         /// Optional lower bound for the slice (inclusive).
-        lower_bound: Option<Expr>,
+        lower_bound: Option<Box<Expr>>,
         /// Optional upper bound for the slice (inclusive).
-        upper_bound: Option<Expr>,
+        upper_bound: Option<Box<Expr>>,
         /// Optional stride for the slice (step size).
-        stride: Option<Expr>,
+        stride: Option<Box<Expr>>,
     },
 }
 
@@ -7686,7 +7686,7 @@ pub enum FunctionArg {
     /// Enabled when `Dialect::supports_named_fn_args_with_expr_name` returns 'true'
     ExprNamed {
         /// The expression used as the argument name.
-        name: Expr,
+        name: Box<Expr>,
         /// The argument expression or wildcard form.
         arg: FunctionArgExpr,
         /// The operator separating name and value.
@@ -7960,7 +7960,7 @@ pub enum FunctionArgumentClause {
     /// [BigQuery]: https://cloud.google.com/bigquery/docs/reference/standard-sql/aggregate_functions#array_agg
     OrderBy(Vec<OrderByExpr>),
     /// Specifies a limit for the `ARRAY_AGG` and `ARRAY_CONCAT_AGG` functions on BigQuery.
-    Limit(Expr),
+    Limit(Box<Expr>),
     /// Specifies the behavior on overflow of the `LISTAGG` function.
     ///
     /// See <https://trino.io/docs/current/functions/aggregate.html>.

src/ast/query.rs

@@ -477,9 +477,9 @@ pub struct Select {
     /// and it can be used together with WHERE selection.
     ///
     /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/select/prewhere)
-    pub prewhere: Option<Expr>,
+    pub prewhere: Option<Box<Expr>>,
     /// WHERE
-    pub selection: Option<Expr>,
+    pub selection: Option<Box<Expr>>,
     /// [START WITH ..] CONNECT BY ..
     pub connect_by: Vec<ConnectByKind>,
     /// GROUP BY
@@ -491,11 +491,11 @@ pub struct Select {
     /// SORT BY (Hive)
     pub sort_by: Vec<OrderByExpr>,
     /// HAVING
-    pub having: Option<Expr>,
+    pub having: Option<Box<Expr>>,
     /// WINDOW AS
     pub named_window: Vec<NamedWindowDefinition>,
     /// QUALIFY (Snowflake)
-    pub qualify: Option<Expr>,
+    pub qualify: Option<Box<Expr>>,
     /// The positioning of QUALIFY and WINDOW clauses differ between dialects.
     /// e.g. BigQuery requires that WINDOW comes after QUALIFY, while DUCKDB accepts
     /// WINDOW before QUALIFY.
@@ -873,9 +873,9 @@ pub enum SelectItem {
     },
     /// An expression, followed by a wildcard expansion.
     /// e.g. `alias.*`, `STRUCT<STRING>('foo').*`
-    QualifiedWildcard(SelectItemQualifiedWildcardKind, WildcardAdditionalOptions),
+    QualifiedWildcard(SelectItemQualifiedWildcardKind, Box<WildcardAdditionalOptions>),
     /// An unqualified `*`
-    Wildcard(WildcardAdditionalOptions),
+    Wildcard(Box<WildcardAdditionalOptions>),
 }
 
 impl fmt::Display for SelectItemQualifiedWildcardKind {
@@ -2855,7 +2855,7 @@ pub struct OrderByExpr {
     /// Ordering options such as `ASC`/`DESC` and `NULLS` behavior.
     pub options: OrderByOptions,
     /// Optional `WITH FILL` clause (ClickHouse extension) which specifies how to fill gaps.
-    pub with_fill: Option<WithFill>,
+    pub with_fill: Option<Box<WithFill>>,
 }
 
 impl From<Ident> for OrderByExpr {

src/parser/mod.rs

@@ -4106,13 +4106,13 @@ impl<'a> Parser<'a> {
             None
         } else {
             // parse expr until we hit a colon (or any token with lower precedence)
-            Some(self.parse_subexpr(self.dialect.prec_value(Precedence::Colon))?)
+            Some(Box::new(self.parse_subexpr(self.dialect.prec_value(Precedence::Colon))?))
         };
 
         // check for end
         if self.consume_token(&Token::RBracket) {
             if let Some(lower_bound) = lower_bound {
-                return Ok(Subscript::Index { index: lower_bound });
+                return Ok(Subscript::Index { index: *lower_bound });
             };
             return Ok(Subscript::Slice {
                 lower_bound,
@@ -4135,7 +4135,7 @@ impl<'a> Parser<'a> {
             });
         } else {
             // parse expr until we hit a colon (or any token with lower precedence)
-            Some(self.parse_subexpr(self.dialect.prec_value(Precedence::Colon))?)
+            Some(Box::new(self.parse_subexpr(self.dialect.prec_value(Precedence::Colon))?))
         };
 
         // check for end
@@ -4152,7 +4152,7 @@ impl<'a> Parser<'a> {
         let stride = if self.consume_token(&Token::RBracket) {
             None
         } else {
-            Some(self.parse_expr()?)
+            Some(Box::new(self.parse_expr()?))
         };
 
         if stride.is_some() {
@@ -14209,13 +14209,13 @@ impl<'a> Parser<'a> {
 
         let prewhere = if self.dialect.supports_prewhere() && self.parse_keyword(Keyword::PREWHERE)
         {
-            Some(self.parse_expr()?)
+            Some(Box::new(self.parse_expr()?))
         } else {
             None
         };
 
         let selection = if self.parse_keyword(Keyword::WHERE) {
-            Some(self.parse_expr()?)
+            Some(Box::new(self.parse_expr()?))
         } else {
             None
         };
@@ -14245,7 +14245,7 @@ impl<'a> Parser<'a> {
         };
 
         let having = if self.parse_keyword(Keyword::HAVING) {
-            Some(self.parse_expr()?)
+            Some(Box::new(self.parse_expr()?))
         } else {
             None
         };
@@ -14255,12 +14255,12 @@ impl<'a> Parser<'a> {
         {
             let named_windows = self.parse_comma_separated(Parser::parse_named_window)?;
             if self.parse_keyword(Keyword::QUALIFY) {
-                (named_windows, Some(self.parse_expr()?), true)
+                (named_windows, Some(Box::new(self.parse_expr()?)), true)
             } else {
                 (named_windows, None, true)
             }
         } else if self.parse_keyword(Keyword::QUALIFY) {
-            let qualify = Some(self.parse_expr()?);
+            let qualify = Some(Box::new(self.parse_expr()?));
             if self.parse_keyword(Keyword::WINDOW) {
                 (
                     self.parse_comma_separated(Parser::parse_named_window)?,
@@ -17539,7 +17539,7 @@ impl<'a> Parser<'a> {
                 let operator = p.parse_function_named_arg_operator()?;
                 let arg = p.parse_wildcard_expr()?.into();
                 Ok(FunctionArg::ExprNamed {
-                    name,
+                    name: Box::new(name),
                     arg,
                     operator,
                 })
@@ -17670,7 +17670,7 @@ impl<'a> Parser<'a> {
         }
 
         if self.parse_keyword(Keyword::LIMIT) {
-            clauses.push(FunctionArgumentClause::Limit(self.parse_expr()?));
+            clauses.push(FunctionArgumentClause::Limit(Box::new(self.parse_expr()?)));
         }
 
         if dialect_of!(self is GenericDialect | BigQueryDialect)
@@ -17763,10 +17763,10 @@ impl<'a> Parser<'a> {
         match self.parse_wildcard_expr()? {
             Expr::QualifiedWildcard(prefix, token) => Ok(SelectItem::QualifiedWildcard(
                 SelectItemQualifiedWildcardKind::ObjectName(prefix),
-                self.parse_wildcard_additional_options(token.0)?,
+                Box::new(self.parse_wildcard_additional_options(token.0)?),
             )),
             Expr::Wildcard(token) => Ok(SelectItem::Wildcard(
-                self.parse_wildcard_additional_options(token.0)?,
+                Box::new(self.parse_wildcard_additional_options(token.0)?),
             )),
             Expr::Identifier(v) if v.value.to_lowercase() == "from" && v.quote_style.is_none() => {
                 parser_err!(
@@ -17798,7 +17798,7 @@ impl<'a> Parser<'a> {
                 let wildcard_token = self.get_previous_token().clone();
                 Ok(SelectItem::QualifiedWildcard(
                     SelectItemQualifiedWildcardKind::Expr(expr),
-                    self.parse_wildcard_additional_options(wildcard_token)?,
+                    Box::new(self.parse_wildcard_additional_options(wildcard_token)?),
                 ))
             }
             expr => self
@@ -18041,7 +18041,7 @@ impl<'a> Parser<'a> {
         let with_fill = if self.dialect.supports_with_fill()
             && self.parse_keywords(&[Keyword::WITH, Keyword::FILL])
         {
-            Some(self.parse_with_fill()?)
+            Some(Box::new(self.parse_with_fill()?))
         } else {
             None
         };

tests/sqlparser_clickhouse.rs

@@ -70,7 +70,7 @@ fn parse_map_access_expr() {
             }],
             lateral_views: vec![],
             prewhere: None,
-            selection: Some(BinaryOp {
+            selection: Some(Box::new(BinaryOp {
                 left: Box::new(BinaryOp {
                     left: Box::new(Identifier(Ident::new("id"))),
                     op: BinaryOperator::Eq,
@@ -93,7 +93,7 @@ fn parse_map_access_expr() {
                     op: BinaryOperator::NotEq,
                     right: Box::new(Expr::value(Value::SingleQuotedString("foo".to_string()))),
                 }),
-            }),
+            })),
             group_by: GroupByExpr::Expressions(vec![], vec![]),
             cluster_by: vec![],
             distribute_by: vec![],
@@ -1162,23 +1162,23 @@ fn parse_select_order_by_with_fill_interpolate() {
                         asc: Some(true),
                         nulls_first: Some(true),
                     },
-                    with_fill: Some(WithFill {
+                    with_fill: Some(Box::new(WithFill {
                         from: Some(Expr::value(number("10"))),
                         to: Some(Expr::value(number("20"))),
                         step: Some(Expr::value(number("2"))),
-                    }),
+                    })),
                 },
                 OrderByExpr {
                     expr: Expr::Identifier(Ident::new("lname")),
                     options: OrderByOptions {
                         asc: Some(false),
                         nulls_first: Some(false),
                     },
-                    with_fill: Some(WithFill {
+                    with_fill: Some(Box::new(WithFill {
                         from: Some(Expr::value(number("30"))),
                         to: Some(Expr::value(number("40"))),
                         step: Some(Expr::value(number("3"))),
-                    }),
+                    })),
                 },
             ]),
             interpolate: Some(Interpolate {
@@ -1248,7 +1248,7 @@ fn parse_with_fill() {
         })
         .as_ref(),
         match select.order_by.expect("ORDER BY expected").kind {
-            OrderByKind::Expressions(ref exprs) => exprs[0].with_fill.as_ref(),
+            OrderByKind::Expressions(ref exprs) => exprs[0].with_fill.as_deref(),
             _ => None,
         }
     );
@@ -1346,7 +1346,7 @@ fn parse_interpolate_with_empty_body() {
 fn test_prewhere() {
     match clickhouse_and_generic().verified_stmt("SELECT * FROM t PREWHERE x = 1 WHERE y = 2") {
         Statement::Query(query) => {
-            let prewhere = query.body.as_select().unwrap().prewhere.as_ref();
+            let prewhere = query.body.as_select().unwrap().prewhere.as_deref();
             assert_eq!(
                 prewhere,
                 Some(&BinaryOp {
@@ -1357,7 +1357,7 @@ fn test_prewhere() {
                     )),
                 })
             );
-            let selection = query.as_ref().body.as_select().unwrap().selection.as_ref();
+            let selection = query.as_ref().body.as_select().unwrap().selection.as_deref();
             assert_eq!(
                 selection,
                 Some(&BinaryOp {
@@ -1374,7 +1374,7 @@ fn test_prewhere() {
 
     match clickhouse_and_generic().verified_stmt("SELECT * FROM t PREWHERE x = 1 AND y = 2") {
         Statement::Query(query) => {
-            let prewhere = query.body.as_select().unwrap().prewhere.as_ref();
+            let prewhere = query.body.as_select().unwrap().prewhere.as_deref();
             assert_eq!(
                 prewhere,
                 Some(&BinaryOp {