heed why not

it's fast but it's being allowed to use a lot of mem

Cargo.lock

···
 version = "2.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2261d10cca569e4643e526d8dc2e62e433cc8aba21ab764233731f8d369bf394"
+dependencies = [
+ "serde",
+]
 
 [[package]]
 name = "bumpalo"
 version = "3.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
 [[package]]
 name = "bytes"
···
 checksum = "b544cf8c89359205f4f990d0e6f3828db42df85b5dac95d09157a250eb0749c4"
 dependencies = [
  "serde",
+]
+
+[[package]]
+name = "cc"
+version = "1.2.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37521ac7aabe3d13122dc382493e20c9416f299d2ccd5b3a5340a2570cdeb0f3"
+dependencies = [
+ "find-msvc-tools",
+ "shlex",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
+name = "crossbeam-queue"
+version = "0.3.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f58bbc28f91df819d0aa2a2c00cd19754769c2fad90579b3592b1c9ba7a3115"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
 name = "crossbeam-utils"
 version = "0.8.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "displaydoc"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.106",
+]
+
+[[package]]
+name = "doxygen-rs"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "415b6ec780d34dcf624666747194393603d0373b7141eef01d12ee58881507d9"
+dependencies = [
+ "phf",
+]
+
+[[package]]
 name = "either"
 version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
 
 [[package]]
+name = "find-msvc-tools"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52051878f80a721bb68ebfbc930e07b65ba72f2da88968ea5c06fd6ca3d3a127"
+
+[[package]]
 name = "foldhash"
 version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
 
 [[package]]
+name = "form_urlencoded"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
+dependencies = [
+ "percent-encoding",
+]
+
+[[package]]
 name = "futures"
 version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
 [[package]]
+name = "heed"
+version = "0.22.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a56c94661ddfb51aa9cdfbf102cfcc340aa69267f95ebccc4af08d7c530d393"
+dependencies = [
+ "bitflags",
+ "byteorder",
+ "heed-traits",
+ "heed-types",
+ "libc",
+ "lmdb-master-sys",
+ "once_cell",
+ "page_size",
+ "serde",
+ "synchronoise",
+ "url",
+]
+
+[[package]]
+name = "heed-traits"
+version = "0.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb3130048d404c57ce5a1ac61a903696e8fcde7e8c2991e9fcfc1f27c3ef74ff"
+
+[[package]]
+name = "heed-types"
+version = "0.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c255bdf46e07fb840d120a36dcc81f385140d7191c76a7391672675c01a55d"
+dependencies = [
+ "bincode 1.3.3",
+ "byteorder",
+ "heed-traits",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "icu_collections"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c6b649701667bbe825c3b7e6388cb521c23d88644678e83c0c4d0a621a34b43"
+dependencies = [
+ "displaydoc",
+ "potential_utf",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locale_core"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edba7861004dd3714265b4db54a3c390e880ab658fec5f7db895fae2046b5bb6"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f6c8828b67bf8908d82127b2054ea1b4427ff0230ee9141c54251934ab1b599"
+dependencies = [
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7aedcccd01fc5fe81e6b489c15b247b8b0690feb23304303a9e560f37efc560a"
+
+[[package]]
+name = "icu_properties"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e93fcd3157766c0c8da2f8cff6ce651a31f0810eaa1c51ec363ef790bbb5fb99"
+dependencies = [
+ "icu_collections",
+ "icu_locale_core",
+ "icu_properties_data",
+ "icu_provider",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02845b3647bb045f1100ecd6480ff52f34c35f82d9880e029d329c21d1054899"
+
+[[package]]
+name = "icu_provider"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85962cf0ce02e1e0a629cc34e7ca3e373ce20dda4c4d7294bbd0bf1fdb59e614"
+dependencies = [
+ "displaydoc",
+ "icu_locale_core",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "idna"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
+dependencies = [
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
+]
+
+[[package]]
+name = "idna_adapter"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
+]
+
+[[package]]
 name = "io-uring"
 version = "0.7.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039"
 
 [[package]]
+name = "litemap"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77"
+
+[[package]]
+name = "lmdb-master-sys"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "864808e0b19fb6dd3b70ba94ee671b82fce17554cf80aeb0a155c65bb08027df"
+dependencies = [
+ "cc",
+ "doxygen-rs",
+ "libc",
+]
+
+[[package]]
 name = "lock_api"
 version = "0.4.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "11.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"
+
+[[package]]
+name = "page_size"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "30d5b2194ed13191c1999ae0704b7839fb18384fa22e49b57eeaa97d79ce40da"
+dependencies = [
+ "libc",
+ "winapi",
+]
 
 [[package]]
 name = "parking_lot"
···
 ]
 
 [[package]]
+name = "percent-encoding"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
+
+[[package]]
+name = "phf"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd6780a80ae0c52cc120a26a1a42c1ae51b247a253e4e06113d23d2c2edd078"
+dependencies = [
+ "phf_macros",
+ "phf_shared",
+]
+
+[[package]]
+name = "phf_generator"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c80231409c20246a13fddb31776fb942c38553c51e871f8cbd687a4cfb5843d"
+dependencies = [
+ "phf_shared",
+ "rand",
+]
+
+[[package]]
+name = "phf_macros"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f84ac04429c13a7ff43785d75ad27569f2951ce0ffd30a3321230db2fc727216"
+dependencies = [
+ "phf_generator",
+ "phf_shared",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.106",
+]
+
+[[package]]
+name = "phf_shared"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67eabc2ef2a60eb7faa00097bd1ffdb5bd28e62bf39990626a582201b7a754e5"
+dependencies = [
+ "siphasher",
+]
+
+[[package]]
 name = "pin-project-lite"
 version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "d8a2f0d8d040d7848a709caf78912debcc3f33ee4b3cac47d73d1e1069e83507"
 dependencies = [
  "portable-atomic",
+]
+
+[[package]]
+name = "potential_utf"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b73949432f5e2a09657003c25bca5e19a0e9c84f8058ca374f49e0ebe605af77"
+dependencies = [
+ "zerovec",
 ]
 
 [[package]]
···
  "env_logger",
  "futures",
  "futures-core",
+ "heed",
  "ipld-core",
  "iroh-car",
  "log",
···
 ]
 
 [[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
 name = "signal-hook-registry"
 version = "1.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 dependencies = [
  "libc",
 ]
+
+[[package]]
+name = "siphasher"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d"
 
 [[package]]
 name = "slab"
···
 ]
 
 [[package]]
+name = "stable_deref_trait"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
+
+[[package]]
 name = "strsim"
 version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "synchronoise"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3dbc01390fc626ce8d1cffe3376ded2b72a11bb70e1c75f404a210e4daa4def2"
+dependencies = [
+ "crossbeam-queue",
+]
+
+[[package]]
+name = "synstructure"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.106",
+]
+
+[[package]]
 name = "tempfile"
 version = "3.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "tinystr"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42d3e9c45c09de15d06dd8acf5f4e0e399e85927b7f00711024eb7ae10fa4869"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
+
+[[package]]
 name = "tinytemplate"
 version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "6d49784317cd0d1ee7ec5c716dd598ec5b4483ea832a2dced265471cc0f690ae"
 
 [[package]]
+name = "url"
+version = "2.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08bc136a29a3d1758e07a9cca267be308aeebf5cfd5a10f3f67ab2097683ef5b"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "percent-encoding",
+ "serde",
+]
+
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+
+[[package]]
 name = "utf8parse"
 version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
 name = "winapi-util"
 version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
 name = "windows-link"
 version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59"
 
 [[package]]
+name = "writeable"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9"
+
+[[package]]
+name = "yoke"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72d6e5c6afb84d73944e5cedb052c4680d5657337201555f9f2a16b7406d4954"
+dependencies = [
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.106",
+ "synstructure",
+]
+
+[[package]]
 name = "zerocopy"
 version = "0.8.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "quote",
  "syn 2.0.106",
 ]
+
+[[package]]
+name = "zerofrom"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
+dependencies = [
+ "zerofrom-derive",
+]
+
+[[package]]
+name = "zerofrom-derive"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.106",
+ "synstructure",
+]
+
+[[package]]
+name = "zerotrie"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a59c17a5562d507e4b54960e8569ebee33bee890c70aa3fe7b97e85a9fd7851"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+]
+
+[[package]]
+name = "zerovec"
+version = "0.11.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c28719294829477f525be0186d13efa9a3c602f7ec202ca9e353d310fb9a002"
+dependencies = [
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+
+[[package]]
+name = "zerovec-derive"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eadce39539ca5cb3985590102671f2567e659fca9666581ad3411d59207951f3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.106",
+]

Cargo.toml

···
 bincode = { version = "2.0.1", features = ["serde"] }
 futures = "0.3.31"
 futures-core = "0.3.31"
+heed = "0.22.0"
 ipld-core = { version = "0.4.2", features = ["serde"] }
 iroh-car = "0.5.1"
 log = "0.4.28"

examples/disk-read-file/main.rs

···
     let mb = 2_usize.pow(20);
 
     let mut driver =
-        match repo_stream::drive::load_car(reader, |block| S(block.len()), 1 * mb).await? {
+        match repo_stream::drive::load_car(reader, |block| S(block.len()), 5 * mb).await? {
             repo_stream::drive::Vehicle::Lil(_, _) => panic!("try this on a bigger car"),
             repo_stream::drive::Vehicle::Big(big_stuff) => {
-                // let disk_store = repo_stream::disk::SqliteStore::new(tmpfile);
-                // let disk_store = repo_stream::disk::RedbStore::new(tmpfile);
-                let disk_store = repo_stream::disk::RustcaskStore::new(tmpfile);
+                let disk_store = repo_stream::disk::SqliteStore::new(tmpfile.clone());
+                // let disk_store = repo_stream::disk::RedbStore::new(tmpfile.clone());
+                // let disk_store = repo_stream::disk::RustcaskStore::new(tmpfile.clone());
+                // let disk_store = repo_stream::disk::HeedStore::new(tmpfile.clone());
                 let (commit, driver) = big_stuff.finish_loading(disk_store).await?;
                 log::warn!("big: {:?}", commit);
                 driver
···
 
     let mut n = 0;
     loop {
-        let (d, Some(pairs)) = driver.next_chunk(256).await? else {
+        let (d, p) = driver.next_chunk(1024).await?;
+        driver = d;
+        let Some(pairs) = p else {
             break;
         };
-        driver = d;
         n += pairs.len();
         // log::info!("got {rkey:?}");
     }
+    // log::info!("now is the time to check mem...");
+    // tokio::time::sleep(std::time::Duration::from_secs(22)).await;
+    drop(driver);
     log::info!("bye! {n}");
+
+    std::fs::remove_file(tmpfile).unwrap();
+    // std::fs::remove_dir_all(tmpfile).unwrap();
 
     Ok(())
 }

src/disk.rs

···
 
 pub trait DiskWriter<E: StorageErrorBase> {
     fn put(&mut self, key: Vec<u8>, val: Vec<u8>) -> Result<(), E>;
+    fn put_many(&mut self, _kv: impl Iterator<Item = (Vec<u8>, Vec<u8>)>) -> Result<(), E>;
 }
 
 pub trait DiskReader {
···
         let conn = tokio::task::spawn_blocking(move || {
             let conn = rusqlite::Connection::open(path)?;
 
+            let sq_mb = -(2_i64.pow(10)); // negative is kibibytes for sqlite cache_size
+
+            // conn.pragma_update(None, "journal_mode", "OFF")?;
+            // conn.pragma_update(None, "journal_mode", "MEMORY")?;
             conn.pragma_update(None, "journal_mode", "WAL")?;
             conn.pragma_update(None, "synchronous", "OFF")?;
-            conn.pragma_update(None, "cache_size", (-4 * 2_i64.pow(10)).to_string())?;
+            conn.pragma_update(None, "cache_size", (5 * sq_mb).to_string())?;
             conn.execute(
                 "CREATE TABLE blocks (
                     key  BLOB PRIMARY KEY NOT NULL,
···
 impl DiskAccess for SqliteAccess {
     type StorageError = rusqlite::Error;
     fn get_writer(&mut self) -> Result<impl DiskWriter<rusqlite::Error>, rusqlite::Error> {
-        let insert_stmt = self
-            .conn
-            .prepare("INSERT INTO blocks (key, val) VALUES (?1, ?2)")?;
-        Ok(SqliteWriter { insert_stmt })
+        let tx = self.conn.transaction()?;
+        // let insert_stmt = tx.prepare("INSERT INTO blocks (key, val) VALUES (?1, ?2)")?;
+        Ok(SqliteWriter { tx: Some(tx) })
     }
     fn get_reader(
         &self,
···
 }
 
 pub struct SqliteWriter<'conn> {
-    insert_stmt: rusqlite::Statement<'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();
+    }
 }
 
 impl DiskWriter<rusqlite::Error> for SqliteWriter<'_> {
     fn put(&mut self, key: Vec<u8>, val: Vec<u8>) -> rusqlite::Result<()> {
-        self.insert_stmt.execute((key, val))?;
+        let tx = self.tx.as_ref().unwrap();
+        let mut insert_stmt = tx.prepare_cached("INSERT INTO blocks (key, val) VALUES (?1, ?2)")?;
+        insert_stmt.execute((key, val))?;
+        Ok(())
+    }
+    fn put_many(&mut self, kv: impl Iterator<Item = (Vec<u8>, Vec<u8>)>) -> rusqlite::Result<()> {
+        let tx = self.tx.as_ref().unwrap();
+        let mut insert_stmt = tx.prepare_cached("INSERT INTO blocks (key, val) VALUES (?1, ?2)")?;
+        for (k, v) in kv {
+            insert_stmt.execute((k, v))?;
+        }
         Ok(())
     }
 }
···
     type Access = RedbAccess;
     async fn get_access(&mut self) -> Result<RedbAccess, redb::Error> {
         let path = self.path.clone();
-        let kb = 2_usize.pow(10);
+        let mb = 2_usize.pow(20);
         let db = tokio::task::spawn_blocking(move || {
             let db = redb::Database::builder()
-                .set_cache_size(16 * kb)
+                .set_cache_size(5 * mb)
                 .create(path)?;
             Ok::<_, Self::StorageError>(db)
         })
···
     fn put(&mut self, key: Vec<u8>, val: Vec<u8>) -> Result<(), redb::Error> {
         let mut table = self.tx.as_ref().unwrap().open_table(REDB_TABLE)?;
         table.insert(&*key, &*val)?;
+        Ok(())
+    }
+    fn put_many(&mut self, kv: impl Iterator<Item = (Vec<u8>, Vec<u8>)>) -> Result<(), redb::Error> {
+        let mut table = self.tx.as_ref().unwrap().open_table(REDB_TABLE)?;
+        for (k, v) in kv {
+            table.insert(&*k, &*v)?;
+        }
         Ok(())
     }
 }
···
         self.db.set(key, val)?;
         Ok(())
     }
+    fn put_many(&mut self, kv: impl Iterator<Item = (Vec<u8>, Vec<u8>)>) -> Result<(), CaskError> {
+        for (k, v) in kv {
+            self.db.set(k, v)?;
+        }
+        Ok(())
+    }
 }
 
 pub struct RustcaskReader {
···
             .map_err(|e| CaskError::GetError(e.to_string()))
     }
 }
+
+
+///////// heeeeeeeeeeeeed
+
+type HeedBytes = heed::types::SerdeBincode<Vec<u8>>;
+type HeedDb = heed::Database<HeedBytes, HeedBytes>;
+// type HeedDb = heed::Database<Vec<u8>, Vec<u8>>;
+
+pub struct HeedStore {
+    path: PathBuf,
+}
+
+impl HeedStore {
+    pub fn new(path: PathBuf) -> Self {
+        Self { path }
+    }
+}
+
+impl StorageErrorBase for heed::Error {}
+
+impl DiskStore for HeedStore {
+    type StorageError = heed::Error;
+    type Access = HeedAccess;
+    async fn get_access(&mut self) -> Result<HeedAccess, heed::Error> {
+        let path = self.path.clone();
+        let env = tokio::task::spawn_blocking(move || {
+            std::fs::create_dir_all(&path).unwrap();
+            let env = unsafe {
+                heed::EnvOpenOptions::new()
+                    .map_size(1 * 2_usize.pow(30))
+                    .open(path)?
+            };
+            Ok::<_, Self::StorageError>(env)
+        })
+        .await
+        .expect("join error")?;
+
+        Ok(HeedAccess { env, db: None })
+    }
+}
+
+pub struct HeedAccess {
+    env: heed::Env,
+    db: Option<HeedDb>,
+}
+
+impl DiskAccess for HeedAccess {
+    type StorageError = heed::Error;
+    fn get_writer(&mut self) -> Result<impl DiskWriter<heed::Error>, heed::Error> {
+        let mut tx = self.env.write_txn()?;
+        let db = self.env.create_database(&mut tx, None)?;
+        self.db = Some(db.clone());
+        Ok(HeedWriter { tx: Some(tx), db })
+    }
+    fn get_reader(&self) -> Result<impl DiskReader<StorageError = heed::Error>, heed::Error> {
+        let tx = self.env.read_txn()?;
+        let db = self.db.expect("should have called get_writer first");
+        Ok(HeedReader { tx, db })
+    }
+}
+
+pub struct HeedWriter<'tx> {
+    tx: Option<heed::RwTxn<'tx>>,
+    db: HeedDb,
+}
+
+impl DiskWriter<heed::Error> for HeedWriter<'_> {
+    fn put(&mut self, key: Vec<u8>, val: Vec<u8>) -> Result<(), heed::Error> {
+        let mut tx = self.tx.as_mut().unwrap();
+        self.db.put(&mut tx, &key, &val)?;
+        Ok(())
+    }
+    fn put_many(&mut self, kv: impl Iterator<Item = (Vec<u8>, Vec<u8>)>) -> Result<(), heed::Error> {
+        let mut tx = self.tx.as_mut().unwrap();
+        for (k, v) in kv {
+            self.db.put(&mut tx, &k, &v)?;
+        }
+        Ok(())
+    }
+}
+
+/// oops careful in async
+impl Drop for HeedWriter<'_> {
+    fn drop(&mut self) {
+        let tx = self.tx.take();
+        tx.unwrap().commit().unwrap();
+    }
+}
+
+pub struct HeedReader<'tx> {
+    tx: heed::RoTxn<'tx, heed::WithTls>,
+    db: HeedDb,
+}
+
+impl DiskReader for HeedReader<'_> {
+    type StorageError = heed::Error;
+    fn get(&mut self, key: Vec<u8>) -> Result<Option<Vec<u8>>, heed::Error> {
+        self.db.get(&self.tx, &key)
+    }
+}

src/drive.rs

···
         // dump mem blocks into the store
         access = tokio::task::spawn(async move {
             let mut writer = access.get_writer()?;
-            for (k, v) in self.mem_blocks {
-                let key_bytes = k.to_bytes();
-                let val_bytes = encode(v)?; // TODO
-                writer.put(key_bytes, val_bytes)?;
-            }
+
+            let kvs = self
+                .mem_blocks
+                .into_iter()
+                .map(|(k, v)| (k.to_bytes(), encode(v).unwrap()));
+
+            writer.put_many(kvs)?;
+
             drop(writer); // cannot outlive access
             Ok::<_, DiskDriveError<S::StorageError>>(access)
         })
···
             // dump mem blocks into the store
             access = tokio::task::spawn_blocking(move || {
                 let mut writer = access.get_writer()?;
-                for (k, v) in chunk {
-                    let key_bytes = k.to_bytes();
-                    let val_bytes = encode(v)?; // TODO
-                    writer.put(key_bytes, val_bytes)?;
-                }
+
+                let kvs = chunk
+                    .into_iter()
+                    .map(|(k, v)| (k.to_bytes(), encode(v).unwrap()));
+
+                writer.put_many(kvs)?;
+
                 drop(writer); // cannot outlive access
                 Ok::<_, DiskDriveError<S::StorageError>>(access)
             })