refactor for bypassing

Author: achristmascarl

src/app.rs

@@ -199,13 +199,13 @@ impl App {
       }
       match database.get_query_results().await? {
         DbTaskResult::Finished(results) => {
-          self.components.data.set_data_state(Some(results.results), Some(results.statement_type));
+          self.components.data.set_data_state(Some(results.results), results.statement_type);
           self.state.last_query_end = Some(chrono::Utc::now());
           self.state.query_task_running = false;
         },
         DbTaskResult::ConfirmTx(rows_affected, statement) => {
           self.state.last_query_end = Some(chrono::Utc::now());
-          self.set_popup(Box::new(ConfirmTx::new(rows_affected, statement.clone())));
+          self.set_popup(Box::new(ConfirmTx::new(rows_affected, statement)));
           self.state.query_task_running = true;
         },
         DbTaskResult::Pending => {
@@ -265,7 +265,7 @@ impl App {
                     let response = database.commit_tx().await?;
                     self.state.last_query_end = Some(chrono::Utc::now());
                     if let Some(results) = response {
-                      self.components.data.set_data_state(Some(results.results), Some(results.statement_type));
+                      self.components.data.set_data_state(Some(results.results), results.statement_type);
                       self.set_focus(Focus::Editor);
                     }
                   },
@@ -401,7 +401,7 @@ impl App {
               },
               Ok((ExecutionType::Normal, _)) => {
                 self.components.data.set_loading();
-                database.start_query(query_string).await?;
+                database.start_query(query_string, *bypass).await?;
                 self.state.last_query_start = Some(chrono::Utc::now());
                 self.state.last_query_end = None;
               },

src/components/data.rs

@@ -443,7 +443,7 @@ impl Component for Data<'_> {
       },
       DataState::StatementCompleted(statement) => {
         f.render_widget(
-          Paragraph::new(format!("{} statement completed", statement_type_string(statement)))
+          Paragraph::new(format!("{} statement completed", statement_type_string(Some(statement.clone()))))
             .wrap(Wrap { trim: false })
             .block(block),
           area,

src/database/mod.rs

@@ -41,7 +41,7 @@ pub struct Rows {
 #[derive(Debug)]
 pub struct QueryResultsWithMetadata {
   pub results: Result<Rows>,
-  pub statement_type: Statement,
+  pub statement_type: Option<Statement>,
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -68,7 +68,7 @@ pub type QueryTask = JoinHandle<QueryResultsWithMetadata>;
 
 pub enum DbTaskResult {
   Finished(QueryResultsWithMetadata),
-  ConfirmTx(Option<u64>, Statement),
+  ConfirmTx(Option<u64>, Option<Statement>),
   Pending,
   NoTask,
 }
@@ -83,7 +83,7 @@ pub trait Database {
 
   /// Spawns a tokio task that runs the query. The task should
   /// expect to be polled via the `get_query_results()` method.
-  async fn start_query(&mut self, query: String) -> Result<()>;
+  async fn start_query(&mut self, query: String, bypass_parser: bool) -> Result<()>;
 
   /// Aborts the tokio task running the active query or transaction.
   /// Some drivers also kill the process that was running the query,
@@ -193,12 +193,15 @@ fn get_default_execution_type(statement: Statement, confirmed: bool) -> Executio
   }
 }
 
-pub fn statement_type_string(statement: &Statement) -> String {
-  format!("{statement:?}").split('(').collect::<Vec<&str>>()[0].split('{').collect::<Vec<&str>>()[0]
-    .split('[')
-    .collect::<Vec<&str>>()[0]
-    .trim()
-    .to_string()
+pub fn statement_type_string(statement: Option<Statement>) -> String {
+  match statement {
+    Some(stmt) => format!("{stmt:?}").split('(').collect::<Vec<&str>>()[0].split('{').collect::<Vec<&str>>()[0]
+      .split('[')
+      .collect::<Vec<&str>>()[0]
+      .trim()
+      .to_string(),
+    None => "UNKNOWN".to_string(),
+  }
 }
 
 pub fn vec_to_string<T: std::string::ToString>(vec: Vec<T>) -> String {

src/database/mysql.rs

@@ -46,8 +46,14 @@ impl Database for MySqlDriver<'_> {
 
   // since it's possible for raw_sql to execute multiple queries in a single string,
   // we only execute the first one and then drop the rest.
-  async fn start_query(&mut self, query: String) -> Result<()> {
-    let (first_query, statement_type) = super::get_first_query(query, Driver::MySql)?;
+  async fn start_query(&mut self, query: String, bypass_parser: bool) -> Result<()> {
+    let (first_query, statement_type) = match bypass_parser {
+      true => (query, None),
+      false => {
+        let (first, stmt) = super::get_first_query(query, Driver::MySql)?;
+        (first, Some(stmt))
+      },
+    };
     let pool = self.pool.clone().unwrap();
     self.querying_conn = Some(Arc::new(Mutex::new(pool.acquire().await?)));
     let conn = self.querying_conn.clone().unwrap();
@@ -154,18 +160,18 @@ impl Database for MySqlDriver<'_> {
           (
             QueryResultsWithMetadata {
               results: Ok(Rows { headers: vec![], rows: vec![], rows_affected: Some(rows_affected) }),
-              statement_type,
+              statement_type: Some(statement_type),
             },
             tx,
           )
         },
         Ok(Either::Right(rows)) => {
           log::info!("{:?} rows affected", rows.rows_affected);
-          (QueryResultsWithMetadata { results: Ok(rows), statement_type }, tx)
+          (QueryResultsWithMetadata { results: Ok(rows), statement_type: Some(statement_type) }, tx)
         },
         Err(e) => {
           log::error!("{e:?}");
-          (QueryResultsWithMetadata { results: Err(e), statement_type }, tx)
+          (QueryResultsWithMetadata { results: Err(e), statement_type: Some(statement_type) }, tx)
         },
       }
     })));

src/database/postgresql.rs

@@ -50,8 +50,14 @@ impl Database for PostgresDriver<'_> {
 
   // since it's possible for raw_sql to execute multiple queries in a single string,
   // we only execute the first one and then drop the rest.
-  async fn start_query(&mut self, query: String) -> Result<()> {
-    let (first_query, statement_type) = super::get_first_query(query, Driver::Postgres)?;
+  async fn start_query(&mut self, query: String, bypass_parser: bool) -> Result<()> {
+    let (first_query, statement_type) = match bypass_parser {
+      true => (query, None),
+      false => {
+        let (first, stmt) = super::get_first_query(query, Driver::Postgres)?;
+        (first, Some(stmt))
+      },
+    };
     let pool = self.pool.clone().unwrap();
     self.querying_conn = Some(Arc::new(Mutex::new(pool.acquire().await?)));
     let conn = self.querying_conn.clone().unwrap();
@@ -170,18 +176,18 @@ impl Database for PostgresDriver<'_> {
           (
             QueryResultsWithMetadata {
               results: Ok(Rows { headers: vec![], rows: vec![], rows_affected: Some(rows_affected) }),
-              statement_type,
+              statement_type: Some(statement_type),
             },
             tx,
           )
         },
         Ok(Either::Right(rows)) => {
           log::info!("{:?} rows affected", rows.rows_affected);
-          (QueryResultsWithMetadata { results: Ok(rows), statement_type }, tx)
+          (QueryResultsWithMetadata { results: Ok(rows), statement_type: Some(statement_type) }, tx)
         },
         Err(e) => {
           log::error!("{e:?}");
-          (QueryResultsWithMetadata { results: Err(e), statement_type }, tx)
+          (QueryResultsWithMetadata { results: Err(e), statement_type: Some(statement_type) }, tx)
         },
       }
     })));

src/database/sqlite.rs

@@ -43,8 +43,14 @@ impl Database for SqliteDriver<'_> {
 
   // since it's possible for raw_sql to execute multiple queries in a single string,
   // we only execute the first one and then drop the rest.
-  async fn start_query(&mut self, query: String) -> Result<()> {
-    let (first_query, statement_type) = super::get_first_query(query, Driver::Sqlite)?;
+  async fn start_query(&mut self, query: String, bypass_parser: bool) -> Result<()> {
+    let (first_query, statement_type) = match bypass_parser {
+      true => (query, None),
+      false => {
+        let (first, stmt) = super::get_first_query(query, Driver::Sqlite)?;
+        (first, Some(stmt))
+      },
+    };
     let pool = self.pool.clone().unwrap();
     self.task = Some(SqliteTask::Query(tokio::spawn(async move {
       let results = query_with_pool(pool, first_query.clone()).await;
@@ -125,18 +131,18 @@ impl Database for SqliteDriver<'_> {
           (
             QueryResultsWithMetadata {
               results: Ok(Rows { headers: vec![], rows: vec![], rows_affected: Some(rows_affected) }),
-              statement_type,
+              statement_type: Some(statement_type),
             },
             tx,
           )
         },
         Ok(Either::Right(rows)) => {
           log::info!("{:?} rows affected", rows.rows_affected);
-          (QueryResultsWithMetadata { results: Ok(rows), statement_type }, tx)
+          (QueryResultsWithMetadata { results: Ok(rows), statement_type: Some(statement_type) }, tx)
         },
         Err(e) => {
           log::error!("{e:?}");
-          (QueryResultsWithMetadata { results: Err(e), statement_type }, tx)
+          (QueryResultsWithMetadata { results: Err(e), statement_type: Some(statement_type) }, tx)
         },
       }
     })));

src/popups/confirm_query.rs

@@ -34,13 +34,13 @@ impl PopUp for ConfirmQuery {
       Statement::Explain { statement, .. } => {
         format!(
           "Are you sure you want to run an EXPLAIN ANALYZE that will run a {} statement?",
-          statement_type_string(&statement).to_uppercase(),
+          statement_type_string(Some(*statement.clone())).to_uppercase(),
         )
       },
       _ => {
         format!(
           "Are you sure you want to use a {} statement?",
-          statement_type_string(&self.statement_type).to_uppercase()
+          statement_type_string(Some(self.statement_type.clone())).to_uppercase()
         )
       },
     }

src/popups/confirm_tx.rs

@@ -7,11 +7,11 @@ use crate::database::statement_type_string;
 #[derive(Debug)]
 pub struct ConfirmTx {
   rows_affected: Option<u64>,
-  statement_type: Statement,
+  statement_type: Option<Statement>,
 }
 
 impl ConfirmTx {
-  pub fn new(rows_affected: Option<u64>, statement_type: Statement) -> Self {
+  pub fn new(rows_affected: Option<u64>, statement_type: Option<Statement>) -> Self {
     Self { rows_affected, statement_type }
   }
 }
@@ -32,23 +32,26 @@ impl PopUp for ConfirmTx {
   fn get_cta_text(&self, app_state: &crate::app::AppState) -> String {
     let rows_affected = self.rows_affected.unwrap_or_default();
     match self.statement_type.clone() {
-      Statement::Delete(_) | Statement::Insert(_) | Statement::Update { .. } => {
+      None => {
+        format!("Are you sure you want to commit a transaction that will affect {rows_affected} rows?")
+      },
+      Some(Statement::Delete(_)) | Some(Statement::Insert(_)) | Some(Statement::Update { .. }) => {
         format!(
           "Are you sure you want to {} {} rows?",
-          statement_type_string(&self.statement_type).to_uppercase(),
+          statement_type_string(self.statement_type.clone()).to_uppercase(),
           rows_affected
         )
       },
-      Statement::Explain { statement, .. } => {
+      Some(Statement::Explain { statement, .. }) => {
         format!(
           "Are you sure you want to run an EXPLAIN ANALYZE that will {} rows?",
-          statement_type_string(&statement).to_uppercase(),
+          statement_type_string(Some(*statement.clone())).to_uppercase(),
         )
       },
       _ => {
         format!(
           "Are you sure you want to use a {} statement?",
-          statement_type_string(&self.statement_type).to_uppercase()
+          statement_type_string(self.statement_type.clone()).to_uppercase()
         )
       },
     }