fix: interval rewrite rule that messes up show create flow function (#5642)

* fix/interval-cast-rewrite:
 ### Enhance Interval Parsing and Casting

 - **`create_parser.rs`**: Added a test case `test_parse_interval_cast` to verify the parsing of interval casts.
 - **`expand_interval.rs`**: Refactored interval casting logic to handle `CastKind` and `format` attributes. Removed the `create_interval` function and integrated its logic directly into the casting process.
 - **`interval.result`**: Updated test results to reflect changes in interval representation, switching from `IntervalMonthDayNano` to `Utf8` format for interval operations.

* reformat code

src/sql/src/parsers/create_parser.rs

@@ -2475,4 +2475,13 @@ CREATE TABLE log (
             assert!(extensions.fulltext_index_options.is_some());
         }
     }
+
+    #[test]
+    fn test_parse_interval_cast() {
+        let s = "select '10s'::INTERVAL";
+        let stmts =
+            ParserContext::create_with_dialect(s, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
+        assert_eq!("SELECT '10 seconds'::INTERVAL", &stmts[0].to_string());
+    }
 }

src/sql/src/statements/transform/expand_interval.rs

@@ -99,15 +99,21 @@ impl TransformRule for ExpandIntervalTransformRule {
             Expr::Cast {
                 expr: cast_exp,
                 data_type,
-                ..
+                kind,
+                format,
             } => {
                 if DataType::Interval == *data_type {
                     match &**cast_exp {
                         Expr::Value(Value::SingleQuotedString(value))
                         | Expr::Value(Value::DoubleQuotedString(value)) => {
-                            let interval_name =
+                            let interval_value =
                                 normalize_interval_name(value).unwrap_or_else(|| value.to_string());
-                            *expr = create_interval(single_quoted_string_expr(interval_name));
+                            *expr = Expr::Cast {
+                                kind: kind.clone(),
+                                expr: single_quoted_string_expr(interval_value),
+                                data_type: DataType::Interval,
+                                format: std::mem::take(format),
+                            }
                         }
                         _ => {}
                     }
@@ -123,16 +129,6 @@ fn single_quoted_string_expr(string: String) -> Box<Expr> {
     Box::new(Expr::Value(Value::SingleQuotedString(string)))
 }
 
-fn create_interval(value: Box<Expr>) -> Expr {
-    Expr::Interval(Interval {
-        value,
-        leading_field: None,
-        leading_precision: None,
-        last_field: None,
-        fractional_seconds_precision: None,
-    })
-}
-
 fn update_existing_interval_with_value(interval: &Interval, value: Box<Expr>) -> Expr {
     Expr::Interval(Interval {
         value,
@@ -199,14 +195,23 @@ fn expand_interval_abbreviation(interval_str: &str) -> Option<String> {
 mod tests {
     use std::ops::ControlFlow;
 
-    use sqlparser::ast::{BinaryOperator, DataType, Expr, Interval, Value};
+    use sqlparser::ast::{BinaryOperator, CastKind, DataType, Expr, Interval, Value};
 
     use crate::statements::transform::expand_interval::{
-        create_interval, normalize_interval_name, single_quoted_string_expr,
-        ExpandIntervalTransformRule,
+        normalize_interval_name, single_quoted_string_expr, ExpandIntervalTransformRule,
     };
     use crate::statements::transform::TransformRule;
 
+    fn create_interval(value: Box<Expr>) -> Expr {
+        Expr::Interval(Interval {
+            value,
+            leading_field: None,
+            leading_precision: None,
+            last_field: None,
+            fractional_seconds_precision: None,
+        })
+    }
+
     #[test]
     fn test_transform_interval_basic_conversions() {
         let test_cases = vec![
@@ -379,15 +384,14 @@ mod tests {
         assert_eq!(control_flow, ControlFlow::Continue(()));
         assert_eq!(
             cast_to_interval_expr,
-            Expr::Interval(Interval {
-                value: Box::new(Expr::Value(Value::SingleQuotedString(
+            Expr::Cast {
+                kind: CastKind::Cast,
+                expr: Box::new(Expr::Value(Value::SingleQuotedString(
                     "3 years 2 months".to_string()
                 ))),
-                leading_field: None,
-                leading_precision: None,
-                last_field: None,
-                fractional_seconds_precision: None,
-            })
+                data_type: DataType::Interval,
+                format: None,
+            }
         );
 
         let mut cast_to_i64_expr = Expr::Cast {