Get start_transaction working with spawned thread

src/concurrency/mod.rs

@@ -7,3 +7,29 @@ pub use std::thread;
 // spawned outside its control, and it doesn't work.
 #[cfg(shuttle)]
 pub use shuttle::thread;
+
+#[cfg(not(shuttle))]
+pub(crate) fn run_blocking<F, R>(f: F) -> R
+where
+    F: FnOnce() -> R+Send,
+R: Send,
+{
+    // let (sender, receiver) = std::sync::mpsc::channel();
+    // std::thread::scope(|scope|{
+    //     scope.spawn(f)
+    // });
+    unimplemented!()
+}
+
+#[cfg(shuttle)]
+pub(crate) fn run_blocking<F, R>(f: F) -> R
+    where
+        F: FnOnce() -> R+Send,
+R: Send,
+
+{
+    let (sender, receiver) = shuttle::sync::mpsc::channel();
+    std::thread::scope(|scope| {
+        scope.spawn(f)
+    })
+}

src/handle.rs

@@ -224,12 +224,25 @@ impl Handle {
         &self,
         behaviour: TransactionBehavior,
     ) -> rusqlite::Result<OwnedTx> {
-        Ok(self
-            .start_transaction(|conn, handle| {
-                let rtx = conn.transaction_with_behavior(behaviour)?;
-                Ok(Transaction::new(rtx, handle))
-            })?
-            .into())
+        unsafe {
+            Ok(self
+                .start_transaction(|conn, handle| {
+                    let conn_ptr = std::ptr::from_mut(conn);
+                    let conn_void_ptr: CanSend<*mut ()> = std::mem::transmute(conn_ptr);
+                    type TxRes<'a> = rusqlite::Result<rusqlite::Transaction<'a>>;
+                    let tx_thread = std::thread::spawn(move||{
+                        eprintln!("hello from transaction thread");
+                        let conn: &mut Connection = std::mem::transmute(conn_void_ptr);
+                        let tx_res: TxRes = conn.transaction_with_behavior(behaviour);
+                        CanSend(Box::into_raw(Box::new(tx_res)))
+                    });
+                    let rtx_raw = tx_thread.join().unwrap();
+                    eprintln!("joined transaction thread");
+                    let rtx = Box::from_raw(rtx_raw.0 as *mut TxRes);
+                    Ok(Transaction::new((*rtx)?, handle))
+                })?
+                .into())
+        }
     }
 
     /// Starts a deferred transaction (the default). There is no guaranteed read-only transaction
@@ -567,3 +580,7 @@ impl AsRef<Handle> for Rc<RwLockReadGuard<'_, Handle>> {
         self.deref()
     }
 }
+
+struct CanSend<T>(T);
+
+unsafe impl<T> Send for CanSend<T> {}