Some small optimizations

src/ast/helpers/stmt_data_loading.rs

@@ -103,11 +103,14 @@ impl fmt::Display for StageParamsObject {
 impl fmt::Display for DataLoadingOptions {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         if !self.options.is_empty() {
+            let mut first = false;
             for option in &self.options {
-                write!(f, "{}", option)?;
-                if !option.eq(self.options.last().unwrap()) {
-                    write!(f, " ")?;
+                if !first {
+                    first = true;
+                } else {
+                    f.write_str(" ")?;
                 }
+                write!(f, "{}", option)?;
             }
         }
         Ok(())

src/ast/mod.rs

@@ -4490,30 +4490,21 @@ impl fmt::Display for Statement {
                 options,
                 query,
             } => {
-                if table_flag.is_some() {
-                    write!(
-                        f,
-                        "CACHE {table_flag} TABLE {table_name}",
-                        table_flag = table_flag.clone().unwrap(),
-                        table_name = table_name,
-                    )?;
+                if let Some(table_flag) = table_flag {
+                    write!(f, "CACHE {table_flag} TABLE {table_name}")?;
                 } else {
-                    write!(f, "CACHE TABLE {table_name}",)?;
+                    write!(f, "CACHE TABLE {table_name}")?;
                 }
 
                 if !options.is_empty() {
                     write!(f, " OPTIONS({})", display_comma_separated(options))?;
                 }
 
-                let has_query = query.is_some();
-                if *has_as && has_query {
-                    write!(f, " AS {query}", query = query.clone().unwrap())
-                } else if !has_as && has_query {
-                    write!(f, " {query}", query = query.clone().unwrap())
-                } else if *has_as && !has_query {
-                    write!(f, " AS")
-                } else {
-                    Ok(())
+                match (*has_as, query) {
+                    (true, Some(query)) => write!(f, " AS {query}"),
+                    (true, None) => f.write_str(" AS"),
+                    (false, Some(query)) => write!(f, " {query}"),
+                    (false, None) => Ok(()),
                 }
             }
             Statement::UNCache {

src/parser/mod.rs

@@ -10477,12 +10477,12 @@ impl<'a> Parser<'a> {
             return parser_err!("Unsupported statement REPLACE", self.peek_token().location);
         }
 
-        let insert = &mut self.parse_insert()?;
-        if let Statement::Insert(Insert { replace_into, .. }) = insert {
+        let mut insert = self.parse_insert()?;
+        if let Statement::Insert(Insert { replace_into, .. }) = &mut insert {
             *replace_into = true;
         }
 
-        Ok(insert.clone())
+        Ok(insert)
     }
 
     /// Parse an INSERT statement, returning a `Box`ed SetExpr