Further reduce Expr to 112 bytes in size

Author: xitep

src/ast/mod.rs

@@ -460,7 +460,7 @@ impl fmt::Display for Array {
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
 pub struct Interval {
     /// The interval value expression (commonly a string literal).
-    pub value: Box<Expr>,
+    pub value: Expr,
     /// Optional leading time unit (e.g., `HOUR`, `MINUTE`).
     pub leading_field: Option<DateTimeField>,
     /// Optional leading precision for the leading field.
@@ -475,7 +475,7 @@ pub struct Interval {
 
 impl fmt::Display for Interval {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let value = self.value.as_ref();
+        let value = &self.value;
         match (
             &self.leading_field,
             self.leading_precision,
@@ -1025,44 +1025,9 @@ pub enum Expr {
         expr: Box<Expr>,
     },
     /// CONVERT a value to a different data type or character encoding. e.g. `CONVERT(foo USING utf8mb4)`
-    // XXX too big
-    Convert {
-        /// CONVERT (false) or TRY_CONVERT (true)
-        /// <https://learn.microsoft.com/en-us/sql/t-sql/functions/try-convert-transact-sql?view=sql-server-ver16>
-        is_try: bool,
-        /// The expression to convert.
-        expr: Box<Expr>,
-        /// The target data type, if provided.
-        data_type: Option<DataType>,
-        /// Optional target character encoding (e.g., `utf8mb4`).
-        charset: Option<ObjectName>,
-        /// `true` when target precedes the value (MSSQL syntax).
-        target_before_value: bool,
-        /// How to translate the expression.
-        ///
-        /// [MSSQL]: https://learn.microsoft.com/en-us/sql/t-sql/functions/cast-and-convert-transact-sql?view=sql-server-ver16#style
-        styles: Vec<Expr>,
-    },
+    Convert(Box<ConvertExpr>),
     /// `CAST` an expression to a different data type e.g. `CAST(foo AS VARCHAR(123))`
-    // XXX too big
-    Cast {
-        /// The cast kind (e.g., `CAST`, `TRY_CAST`).
-        kind: CastKind,
-        /// Expression being cast.
-        expr: Box<Expr>,
-        /// Target data type.
-        data_type: DataType,
-        /// [MySQL] allows CAST(... AS type ARRAY) in functional index definitions for InnoDB
-        /// multi-valued indices. It's not really a datatype, and is only allowed in `CAST` in key
-        /// specifications, so it's a flag here.
-        ///
-        /// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/cast-functions.html#function_cast
-        array: bool,
-        /// Optional CAST(string_expression AS type FORMAT format_string_expression) as used by [BigQuery]
-        ///
-        /// [BigQuery]: https://cloud.google.com/bigquery/docs/reference/standard-sql/format-elements#formatting_syntax
-        format: Option<CastFormat>,
-    },
+    Cast(Box<CastExpr>),
     /// AT a timestamp to a different timezone e.g. `FROM_UNIXTIME(0) AT TIME ZONE 'UTC-06:00'`
     AtTimeZone {
         /// Timestamp expression to shift.
@@ -1194,29 +1159,15 @@ pub enum Expr {
     /// A constant of form `<data_type> 'value'`.
     /// This can represent ANSI SQL `DATE`, `TIME`, and `TIMESTAMP` literals (such as `DATE '2020-01-01'`),
     /// as well as constants of other types (a non-standard PostgreSQL extension).
-    // XXX too big
-    TypedString(TypedString),
+    TypedString(Box<TypedString>),
     /// Scalar function call e.g. `LEFT(foo, 5)`
-    // XXX too big
     Function(Box<Function>),
     /// `CASE [<operand>] WHEN <condition> THEN <result> ... [ELSE <result>] END`
     ///
     /// Note we only recognize a complete single expression as `<condition>`,
     /// not `< 0` nor `1, 2, 3` as allowed in a `<simple when clause>` per
     /// <https://jakewheat.github.io/sql-overview/sql-2011-foundation-grammar.html#simple-when-clause>
-    // XXX too big
-    Case {
-        /// The attached `CASE` token (keeps original spacing/comments).
-        case_token: AttachedToken,
-        /// The attached `END` token (keeps original spacing/comments).
-        end_token: AttachedToken,
-        /// Optional operand expression after `CASE` (for simple CASE).
-        operand: Option<Box<Expr>>,
-        /// The `WHEN ... THEN` conditions and results.
-        conditions: Vec<CaseWhen>,
-        /// Optional `ELSE` result expression.
-        else_result: Option<Box<Expr>>,
-    },
+    Case(Box<CaseExpr>),
     /// An exists expression `[ NOT ] EXISTS(SELECT ...)`, used in expressions like
     /// `WHERE [ NOT ] EXISTS (SELECT ...)`.
     Exists {
@@ -1282,8 +1233,7 @@ pub enum Expr {
     /// An array expression e.g. `ARRAY[1, 2]`
     Array(Array),
     /// An interval expression e.g. `INTERVAL '1' YEAR`
-    // XXX too big
-    Interval(Interval),
+    Interval(Box<Interval>),
     /// `MySQL` specific text search function [(1)].
     ///
     /// Syntax:
@@ -1334,8 +1284,7 @@ pub enum Expr {
     /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/functions#higher-order-functions---operator-and-lambdaparams-expr-function)
     /// [Databricks](https://docs.databricks.com/en/sql/language-manual/sql-ref-lambda-functions.html)
     /// [DuckDB](https://duckdb.org/docs/stable/sql/functions/lambda)
-    // XXX too big
-    Lambda(LambdaFunction),
+    Lambda(Box<LambdaFunction>),
     /// Checks membership of a value in a JSON array
     MemberOf(MemberOf),
 }
@@ -1357,6 +1306,68 @@ impl Expr {
     }
 }
 
+/// A [`CONVERT` expression](Expr::Convert)
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct ConvertExpr {
+    /// CONVERT (false) or TRY_CONVERT (true)
+    /// <https://learn.microsoft.com/en-us/sql/t-sql/functions/try-convert-transact-sql?view=sql-server-ver16>
+    pub is_try: bool,
+    /// The expression to convert.
+    pub expr: Expr,
+    /// The target data type, if provided.
+    pub data_type: Option<DataType>,
+    /// Optional target character encoding (e.g., `utf8mb4`).
+    pub charset: Option<ObjectName>,
+    /// `true` when target precedes the value (MSSQL syntax).
+    pub target_before_value: bool,
+    /// How to translate the expression.
+    ///
+    /// [MSSQL]: https://learn.microsoft.com/en-us/sql/t-sql/functions/cast-and-convert-transact-sql?view=sql-server-ver16#style
+    pub styles: Vec<Expr>,
+}
+
+/// A [`CAST` expression](Expr::Cast)
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct CastExpr {
+    /// The cast kind (e.g., `CAST`, `TRY_CAST`).
+    pub kind: CastKind,
+    /// Expression being cast.
+    pub expr: Expr,
+    /// Target data type.
+    pub data_type: DataType,
+    /// [MySQL] allows CAST(... AS type ARRAY) in functional index definitions for InnoDB
+    /// multi-valued indices. It's not really a datatype, and is only allowed in `CAST` in key
+    /// specifications, so it's a flag here.
+    ///
+    /// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/cast-functions.html#function_cast
+    pub array: bool,
+    /// Optional CAST(string_expression AS type FORMAT format_string_expression) as used by [BigQuery]
+    ///
+    /// [BigQuery]: https://cloud.google.com/bigquery/docs/reference/standard-sql/format-elements#formatting_syntax
+    pub format: Option<CastFormat>,
+}
+
+/// A [`CASE` expression](Expr::Case)
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct CaseExpr {
+    /// The attached `CASE` token (keeps original spacing/comments).
+    pub case_token: AttachedToken,
+    /// The attached `END` token (keeps original spacing/comments).
+    pub end_token: AttachedToken,
+    /// Optional operand expression after `CASE` (for simple CASE).
+    pub operand: Option<Box<Expr>>,
+    /// The `WHEN ... THEN` conditions and results.
+    pub conditions: Vec<CaseWhen>,
+    /// Optional `ELSE` result expression.
+    pub else_result: Option<Box<Expr>>,
+}
+
 /// The contents inside the `[` and `]` in a subscript expression.
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
@@ -1454,7 +1465,7 @@ pub struct LambdaFunction {
     /// The parameters to the lambda function.
     pub params: OneOrManyWithParens<LambdaFunctionParameter>,
     /// The body of the lambda function.
-    pub body: Box<Expr>,
+    pub body: Expr,
     /// The syntax style used to write the lambda function.
     pub syntax: LambdaSyntax,
 }
@@ -1909,14 +1920,15 @@ impl fmt::Display for Expr {
                     write!(f, "{op}{expr}")
                 }
             }
-            Expr::Convert {
-                is_try,
-                expr,
-                target_before_value,
-                data_type,
-                charset,
-                styles,
-            } => {
+            Expr::Convert(convert) => {
+                let ConvertExpr {
+                    is_try,
+                    expr,
+                    target_before_value,
+                    data_type,
+                    charset,
+                    styles,
+                } = &**convert;
                 write!(f, "{}CONVERT(", if *is_try { "TRY_" } else { "" })?;
                 if let Some(data_type) = data_type {
                     if let Some(charset) = charset {
@@ -1936,40 +1948,43 @@ impl fmt::Display for Expr {
                 }
                 write!(f, ")")
             }
-            Expr::Cast {
-                kind,
-                expr,
-                data_type,
-                array,
-                format,
-            } => match kind {
-                CastKind::Cast => {
-                    write!(f, "CAST({expr} AS {data_type}")?;
-                    if *array {
-                        write!(f, " ARRAY")?;
+            Expr::Cast(cast) => {
+                let CastExpr  {
+                    kind,
+                    expr,
+                    data_type,
+                    array,
+                    format,
+                } = &**cast;
+                match kind {
+                    CastKind::Cast => {
+                        write!(f, "CAST({expr} AS {data_type}")?;
+                        if *array {
+                            write!(f, " ARRAY")?;
+                        }
+                        if let Some(format) = format {
+                            write!(f, " FORMAT {format}")?;
+                        }
+                        write!(f, ")")
                     }
-                    if let Some(format) = format {
-                        write!(f, " FORMAT {format}")?;
+                    CastKind::TryCast => {
+                        if let Some(format) = format {
+                            write!(f, "TRY_CAST({expr} AS {data_type} FORMAT {format})")
+                        } else {
+                            write!(f, "TRY_CAST({expr} AS {data_type})")
+                        }
                     }
-                    write!(f, ")")
-                }
-                CastKind::TryCast => {
-                    if let Some(format) = format {
-                        write!(f, "TRY_CAST({expr} AS {data_type} FORMAT {format})")
-                    } else {
-                        write!(f, "TRY_CAST({expr} AS {data_type})")
+                    CastKind::SafeCast => {
+                        if let Some(format) = format {
+                            write!(f, "SAFE_CAST({expr} AS {data_type} FORMAT {format})")
+                        } else {
+                            write!(f, "SAFE_CAST({expr} AS {data_type})")
+                        }
                     }
-                }
-                CastKind::SafeCast => {
-                    if let Some(format) = format {
-                        write!(f, "SAFE_CAST({expr} AS {data_type} FORMAT {format})")
-                    } else {
-                        write!(f, "SAFE_CAST({expr} AS {data_type})")
+                    CastKind::DoubleColon => {
+                        write!(f, "{expr}::{data_type}")
                     }
                 }
-                CastKind::DoubleColon => {
-                    write!(f, "{expr}::{data_type}")
-                }
             },
             Expr::Extract {
                 field,
@@ -2000,13 +2015,14 @@ impl fmt::Display for Expr {
             Expr::Prefixed { prefix, value } => write!(f, "{prefix} {value}"),
             Expr::TypedString(ts) => ts.fmt(f),
             Expr::Function(fun) => fun.fmt(f),
-            Expr::Case {
-                case_token: _,
-                end_token: _,
-                operand,
-                conditions,
-                else_result,
-            } => {
+            Expr::Case(case) => {
+                let CaseExpr {
+                    case_token: _,
+                    end_token: _,
+                    operand,
+                    conditions,
+                    else_result,
+                } = &**case;
                 f.write_str("CASE")?;
                 if let Some(operand) = operand {
                     f.write_str(" ")?;
@@ -12343,28 +12359,28 @@ mod tests {
     #[test]
     fn test_interval_display() {
         let interval = Expr::Interval(Interval {
-            value: Box::new(Expr::Value(
+            value: Expr::Value(
                 Value::SingleQuotedString(String::from("123:45.67")).with_empty_span(),
-            )),
+            ),
             leading_field: Some(DateTimeField::Minute),
             leading_precision: Some(10),
             last_field: Some(DateTimeField::Second),
             fractional_seconds_precision: Some(9),
-        });
+        }.into());
         assert_eq!(
             "INTERVAL '123:45.67' MINUTE (10) TO SECOND (9)",
             format!("{interval}"),
         );
 
         let interval = Expr::Interval(Interval {
-            value: Box::new(Expr::Value(
+            value: Expr::Value(
                 Value::SingleQuotedString(String::from("5")).with_empty_span(),
-            )),
+            ),
             leading_field: Some(DateTimeField::Second),
             leading_precision: Some(1),
             last_field: None,
             fractional_seconds_precision: Some(3),
-        });
+        }.into());
         assert_eq!("INTERVAL '5' SECOND (1, 3)", format!("{interval}"));
     }