Remove unused code.

Author: ignatz

trailbase-sqlite/src/connection.rs

@@ -185,7 +185,7 @@ impl Row {
 type CallFn = Box<dyn FnOnce(&mut rusqlite::Connection) + Send + 'static>;
 
 enum Message {
-  Execute(CallFn),
+  Run(CallFn),
   Close(oneshot::Sender<std::result::Result<(), rusqlite::Error>>),
 }
 
@@ -224,7 +224,7 @@ impl Connection {
 
     self
       .sender
-      .send(Message::Execute(Box::new(move |conn| {
+      .send(Message::Run(Box::new(move |conn| {
         let value = function(conn);
         let _ = sender.send(value);
       })))
@@ -239,41 +239,14 @@ impl Connection {
   {
     self
       .sender
-      .send(Message::Execute(Box::new(move |conn| {
+      .send(Message::Run(Box::new(move |conn| {
         function(conn);
       })))
       .map_err(|_| Error::ConnectionClosed)?;
 
     return Ok(());
   }
 
-  /// Call a function in background thread and get the result
-  /// asynchronously.
-  ///
-  /// This method can cause a `panic` if the underlying database connection is closed.
-  /// it is a more user-friendly alternative to the [`Connection::call`] method.
-  /// It should be safe if the connection is never explicitly closed (using the
-  /// [`Connection::close`] call).
-  ///
-  /// Calling this on a closed connection will cause a `panic`.
-  pub async fn call_unwrap<F, R>(&self, function: F) -> R
-  where
-    F: FnOnce(&mut rusqlite::Connection) -> R + Send + 'static,
-    R: Send + 'static,
-  {
-    let (sender, receiver) = oneshot::channel::<R>();
-
-    self
-      .sender
-      .send(Message::Execute(Box::new(move |conn| {
-        let value = function(conn);
-        let _ = sender.send(value);
-      })))
-      .expect("database connection should be open");
-
-    receiver.await.expect(BUG_TEXT)
-  }
-
   /// Query SQL statement.
   pub async fn query(&self, sql: &str, params: impl Params + Send + 'static) -> Result<Rows> {
     let sql = sql.to_string();
@@ -464,20 +437,14 @@ where
 fn event_loop(mut conn: rusqlite::Connection, receiver: Receiver<Message>) {
   while let Ok(message) = receiver.recv() {
     match message {
-      Message::Execute(f) => f(&mut conn),
+      Message::Run(f) => f(&mut conn),
       Message::Close(s) => {
-        let result = conn.close();
+        match conn.close() {
+          Ok(v) => s.send(Ok(v)).expect(BUG_TEXT),
+          Err((_conn, e)) => s.send(Err(e)).expect(BUG_TEXT),
+        };
 
-        match result {
-          Ok(v) => {
-            s.send(Ok(v)).expect(BUG_TEXT);
-            break;
-          }
-          Err((c, e)) => {
-            conn = c;
-            s.send(Err(e)).expect(BUG_TEXT);
-          }
-        }
+        return;
       }
     }
   }

trailbase-sqlite/src/tests.rs

@@ -28,24 +28,6 @@ async fn call_success_test() {
   assert_eq!(0, result.unwrap());
 }
 
-#[tokio::test]
-async fn call_unwrap_success_test() {
-  let conn = Connection::open_in_memory().await.unwrap();
-
-  let result = conn
-    .call_unwrap(|conn| {
-      conn
-        .execute(
-          "CREATE TABLE person(id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL);",
-          [],
-        )
-        .unwrap()
-    })
-    .await;
-
-  assert_eq!(0, result);
-}
-
 #[tokio::test]
 async fn call_failure_test() {
   let conn = Connection::open_in_memory().await.unwrap();
@@ -105,21 +87,6 @@ async fn close_call_test() {
   ));
 }
 
-#[tokio::test]
-#[should_panic]
-async fn close_call_unwrap_test() {
-  let conn = Connection::open_in_memory().await.unwrap();
-
-  let conn2 = conn.clone();
-
-  assert!(conn.close().await.is_ok());
-
-  conn2
-    .call_unwrap(|conn| conn.execute("SELECT 1;", []))
-    .await
-    .unwrap();
-}
-
 #[tokio::test]
 async fn close_failure_test() {
   let conn = Connection::open_in_memory().await.unwrap();