explicitly commit transaction

it was *okay* in drop since we were dropping in spawn_blocking tasks, but kind of setting things up for problems later.

also all the option stuff to let it be take()n was gross and now it's gone

src/disk.rs

···
     pub fn get_writer(&'_ mut self) -> Result<SqliteWriter<'_>, rusqlite::Error> {
         let tx = self.conn.transaction()?;
         // let insert_stmt = tx.prepare("INSERT INTO blocks (key, val) VALUES (?1, ?2)")?;
-        Ok(SqliteWriter { tx: Some(tx) })
+        Ok(SqliteWriter { tx })
     }
     pub fn get_reader(&'_ self) -> Result<SqliteReader<'_>, rusqlite::Error> {
         let select_stmt = self.conn.prepare("SELECT val FROM blocks WHERE key = ?1")?;
···
 }
 
 pub struct SqliteWriter<'conn> {
-    tx: Option<rusqlite::Transaction<'conn>>,
-}
-
-/// oops careful in async
-impl Drop for SqliteWriter<'_> {
-    fn drop(&mut self) {
-        let tx = self.tx.take();
-        tx.unwrap().commit().unwrap();
-    }
+    tx: rusqlite::Transaction<'conn>,
 }
 
 impl SqliteWriter<'_> {
···
         &mut self,
         kv: impl Iterator<Item = Result<(Vec<u8>, Vec<u8>), DriveError>>,
     ) -> Result<(), DriveError> {
-        let tx = self.tx.as_ref().unwrap();
-        let mut insert_stmt = tx.prepare_cached("INSERT INTO blocks (key, val) VALUES (?1, ?2)")?;
+        let mut insert_stmt = self
+            .tx
+            .prepare_cached("INSERT INTO blocks (key, val) VALUES (?1, ?2)")?;
         for pair in kv {
             let (k, v) = pair?;
             insert_stmt.execute((k, v))?;
         }
+        Ok(())
+    }
+    pub fn commit(self) -> Result<(), rusqlite::Error> {
+        self.tx.commit()?;
         Ok(())
     }
 }

src/drive.rs

···
                 .map(|(k, v)| Ok(encode(v).map(|v| (k.to_bytes(), v))?));
 
             writer.put_many(kvs)?;
-
-            drop(writer); // cannot outlive access
+            writer.commit()?;
             Ok::<_, DriveError>(access)
         })
         .await??;
···
                 writer.put_many(kvs)?;
             }
 
-            drop(writer); // cannot outlive access
+            writer.commit()?;
             Ok::<_, DriveError>(access)
         }); // await later