it's you, sqlite. it's always been you.

you're not the fastest but you are the most well-behaved.

Cargo.lock

···
 
 [[package]]
 name = "bincode"
-version = "1.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "bincode"
 version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "36eaf5d7b090263e8150820482d5d93cd964a81e4019913c972f4edcc6edb740"
···
 version = "2.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2261d10cca569e4643e526d8dc2e62e433cc8aba21ab764233731f8d369bf394"
-dependencies = [
- "serde",
-]
 
 [[package]]
 name = "bumpalo"
···
 checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"
 
 [[package]]
-name = "byteorder"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
-
-[[package]]
 name = "bytes"
 version = "1.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 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"
···
 
 [[package]]
 name = "getrandom"
-version = "0.2.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592"
-dependencies = [
- "cfg-if",
- "libc",
- "wasi 0.11.1+wasi-snapshot-preview1",
-]
-
-[[package]]
-name = "getrandom"
 version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4"
···
 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"
···
 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"
 version = "0.12.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[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"
···
 ]
 
 [[package]]
-name = "potential_utf"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b73949432f5e2a09657003c25bca5e19a0e9c84f8058ca374f49e0ebe605af77"
-dependencies = [
- "zerovec",
-]
-
-[[package]]
-name = "ppv-lite86"
-version = "0.2.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
-dependencies = [
- "zerocopy",
-]
-
-[[package]]
 name = "proc-macro2"
 version = "1.0.101"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
 
 [[package]]
-name = "rand"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
-dependencies = [
- "libc",
- "rand_chacha",
- "rand_core",
-]
-
-[[package]]
-name = "rand_chacha"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
-dependencies = [
- "ppv-lite86",
- "rand_core",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.6.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
-dependencies = [
- "getrandom 0.2.16",
-]
-
-[[package]]
 name = "rayon"
 version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
-name = "redb"
-version = "3.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae323eb086579a3769daa2c753bb96deb95993c534711e0dbe881b5192906a06"
-dependencies = [
- "libc",
-]
-
-[[package]]
 name = "redox_syscall"
 version = "0.5.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 name = "repo-stream"
 version = "0.1.1"
 dependencies = [
- "bincode 2.0.1",
+ "bincode",
  "clap",
  "criterion",
  "env_logger",
  "futures",
  "futures-core",
- "heed",
  "ipld-core",
  "iroh-car",
  "log",
  "multibase",
- "redb",
  "rusqlite",
- "rustcask",
  "serde",
  "serde_bytes",
  "serde_ipld_dagcbor",
···
 checksum = "56f7d92ca342cea22a06f2121d944b4fd82af56988c270852495420f961d4ace"
 
 [[package]]
-name = "rustcask"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e17ed1a2733a60fea8495ddcb42c22cabd17afec7ffa7b024b161dd662da4003"
-dependencies = [
- "bincode 1.3.3",
- "bytes",
- "clap",
- "log",
- "rand",
- "regex",
- "serde",
- "tokio",
-]
-
-[[package]]
 name = "rustix"
 version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[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"
···
 ]
 
 [[package]]
-name = "siphasher"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d"
-
-[[package]]
 name = "slab"
 version = "0.4.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "libc",
  "windows-sys 0.59.0",
 ]
-
-[[package]]
-name = "stable_deref_trait"
-version = "1.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
 
 [[package]]
 name = "strsim"
···
 ]
 
 [[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"
 checksum = "2d31c77bdf42a745371d260a26ca7163f1e0924b64afa0b688e61b5a9fa02f16"
 dependencies = [
  "fastrand",
- "getrandom 0.3.3",
+ "getrandom",
  "once_cell",
  "rustix",
  "windows-sys 0.60.2",
···
  "proc-macro2",
  "quote",
  "syn 2.0.106",
-]
-
-[[package]]
-name = "tinystr"
-version = "0.8.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42d3e9c45c09de15d06dd8acf5f4e0e399e85927b7f00711024eb7ae10fa4869"
-dependencies = [
- "displaydoc",
- "zerovec",
 ]
 
 [[package]]
···
 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"
···
 dependencies = [
  "windows-sys 0.60.2",
 ]
-
-[[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"
···
 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"
 multibase = "0.9.2"
-redb = "3.1.0"
 rusqlite = "0.37.0"
-rustcask = "0.1.0"
 serde = { version = "1.0.228", features = ["derive"] }
 serde_bytes = "0.11.19"
 serde_ipld_dagcbor = "0.6.4"
···
 inherits = "release"
 debug = true
 
-[profile.release]
-debug = true
+# [profile.release]
+# debug = true
 
 [[bench]]
 name = "non-huge-cars"

examples/disk-read-file/main.rs

···
             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.clone(), limit_mb);
-                // let disk_store = repo_stream::disk::RedbStore::new(tmpfile.clone(), limit_mb);
-                // 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
···
     drop(driver);
     log::info!("bye! {n}");
 
-    std::fs::remove_file(tmpfile).unwrap();
-    // std::fs::remove_dir_all(tmpfile).unwrap();
+    std::fs::remove_file(tmpfile).unwrap(); // need to also remove -shm -wal
 
     Ok(())
 }

src/disk.rs

···
-use redb::ReadableDatabase;
 use rusqlite::OptionalExtension;
-use std::error::Error;
 use std::path::PathBuf;
 
-pub trait StorageErrorBase: Error + Send + 'static {}
-
-/// high level potential storage resource
-///
-/// separating this allows (hopefully) implementing a storage pool that can
-/// async-block when until a member is available to use
-pub trait DiskStore {
-    type StorageError: StorageErrorBase + Send;
-    type Access: DiskAccess<StorageError = Self::StorageError>;
-    fn get_access(&mut self) -> impl Future<Output = Result<Self::Access, Self::StorageError>>;
-}
-
-/// actual concrete access to disk storage
-pub trait DiskAccess: Send {
-    type StorageError: StorageErrorBase;
-
-    fn get_writer(&mut self) -> Result<impl DiskWriter<Self::StorageError>, Self::StorageError>;
-
-    fn get_reader(
-        &self,
-    ) -> Result<impl DiskReader<StorageError = Self::StorageError>, Self::StorageError>;
-
-    // TODO: force a cleanup implementation?
-}
-
-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 {
-    type StorageError: StorageErrorBase;
-    fn get(&mut self, key: Vec<u8>) -> Result<Option<Vec<u8>>, Self::StorageError>;
-}
-
-///////////////// sqlite
-
 pub struct SqliteStore {
     path: PathBuf,
     limit_mb: usize,
···
     }
 }
 
-impl StorageErrorBase for rusqlite::Error {}
-
-impl DiskStore for SqliteStore {
-    type StorageError = rusqlite::Error;
-    type Access = SqliteAccess;
-    async fn get_access(&mut self) -> Result<SqliteAccess, rusqlite::Error> {
+impl SqliteStore {
+    pub async fn get_access(&mut self) -> Result<SqliteAccess, rusqlite::Error> {
         let path = self.path.clone();
         let limit_mb = self.limit_mb;
         let conn = tokio::task::spawn_blocking(move || {
···
                 (),
             )?;
 
-            Ok::<_, Self::StorageError>(conn)
+            Ok::<_, rusqlite::Error>(conn)
         })
         .await
         .expect("join error")?;
···
     conn: rusqlite::Connection,
 }
 
-impl DiskAccess for SqliteAccess {
-    type StorageError = rusqlite::Error;
-    fn get_writer(&mut self) -> Result<impl DiskWriter<rusqlite::Error>, rusqlite::Error> {
+impl SqliteAccess {
+    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) })
     }
-    fn get_reader(
-        &self,
-    ) -> Result<impl DiskReader<StorageError = rusqlite::Error>, rusqlite::Error> {
+    pub fn get_reader(&'_ self) -> Result<SqliteReader<'_>, rusqlite::Error> {
         let select_stmt = self.conn.prepare("SELECT val FROM blocks WHERE key = ?1")?;
         Ok(SqliteReader { select_stmt })
     }
···
     }
 }
 
-impl DiskWriter<rusqlite::Error> for SqliteWriter<'_> {
-    fn put(&mut self, key: Vec<u8>, val: Vec<u8>) -> rusqlite::Result<()> {
+impl SqliteWriter<'_> {
+    pub fn put(&mut self, key: Vec<u8>, val: 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)")?;
         insert_stmt.execute((key, val))?;
         Ok(())
     }
-    fn put_many(&mut self, kv: impl Iterator<Item = (Vec<u8>, Vec<u8>)>) -> rusqlite::Result<()> {
+    pub 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 {
···
     select_stmt: rusqlite::Statement<'conn>,
 }
 
-impl DiskReader for SqliteReader<'_> {
-    type StorageError = rusqlite::Error;
-    fn get(&mut self, key: Vec<u8>) -> rusqlite::Result<Option<Vec<u8>>> {
+impl SqliteReader<'_> {
+    pub fn get(&mut self, key: Vec<u8>) -> rusqlite::Result<Option<Vec<u8>>> {
         self.select_stmt
             .query_one((&key,), |row| row.get(0))
             .optional()
     }
 }
-
-//////////// redb why not
-
-const REDB_TABLE: redb::TableDefinition<&[u8], &[u8]> = redb::TableDefinition::new("blocks");
-
-pub struct RedbStore {
-    path: PathBuf,
-    limit_mb: usize,
-}
-
-impl RedbStore {
-    pub fn new(path: PathBuf, limit_mb: usize) -> Self {
-        Self { path, limit_mb }
-    }
-}
-
-impl StorageErrorBase for redb::Error {}
-
-impl DiskStore for RedbStore {
-    type StorageError = redb::Error;
-    type Access = RedbAccess;
-    async fn get_access(&mut self) -> Result<RedbAccess, redb::Error> {
-        let path = self.path.clone();
-        let limit_mb = self.limit_mb;
-        let mb = 2_usize.pow(20);
-        let db = tokio::task::spawn_blocking(move || {
-            let db = redb::Database::builder()
-                .set_cache_size(limit_mb * mb)
-                .create(path)?;
-            Ok::<_, Self::StorageError>(db)
-        })
-        .await
-        .expect("join error")?;
-
-        Ok(RedbAccess { db })
-    }
-}
-
-pub struct RedbAccess {
-    db: redb::Database,
-}
-
-impl DiskAccess for RedbAccess {
-    type StorageError = redb::Error;
-    fn get_writer(&mut self) -> Result<impl DiskWriter<redb::Error>, redb::Error> {
-        let mut tx = self.db.begin_write()?;
-        tx.set_durability(redb::Durability::None)?;
-        Ok(RedbWriter { tx: Some(tx) })
-    }
-    fn get_reader(&self) -> Result<impl DiskReader<StorageError = redb::Error>, redb::Error> {
-        let tx = self.db.begin_read()?;
-        Ok(RedbReader { tx })
-    }
-}
-
-pub struct RedbWriter {
-    tx: Option<redb::WriteTransaction>,
-}
-
-impl DiskWriter<redb::Error> for RedbWriter {
-    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(())
-    }
-}
-
-/// oops careful in async
-impl Drop for RedbWriter {
-    fn drop(&mut self) {
-        let tx = self.tx.take();
-        tx.unwrap().commit().unwrap();
-    }
-}
-
-pub struct RedbReader {
-    tx: redb::ReadTransaction,
-}
-
-impl DiskReader for RedbReader {
-    type StorageError = redb::Error;
-    fn get(&mut self, key: Vec<u8>) -> Result<Option<Vec<u8>>, redb::Error> {
-        let table = self.tx.open_table(REDB_TABLE)?;
-        let rv = table.get(&*key)?.map(|guard| guard.value().to_vec());
-        Ok(rv)
-    }
-}
-
-///// rustcask??
-
-pub struct RustcaskStore {
-    path: PathBuf,
-}
-
-impl RustcaskStore {
-    pub fn new(path: PathBuf) -> Self {
-        Self { path }
-    }
-}
-
-#[derive(Debug, thiserror::Error)]
-pub enum CaskError {
-    #[error(transparent)]
-    OpenError(#[from] rustcask::error::OpenError),
-    #[error(transparent)]
-    SetError(#[from] rustcask::error::SetError),
-    #[error("failed to get key: {0}")]
-    GetError(String),
-    #[error("failed to ensure directory: {0}")]
-    EnsureDirError(std::io::Error),
-}
-
-impl StorageErrorBase for CaskError {}
-
-impl DiskStore for RustcaskStore {
-    type StorageError = CaskError;
-    type Access = RustcaskAccess;
-    async fn get_access(&mut self) -> Result<RustcaskAccess, CaskError> {
-        let path = self.path.clone();
-        let db = tokio::task::spawn_blocking(move || {
-            std::fs::create_dir_all(&path).map_err(CaskError::EnsureDirError)?;
-            let db = rustcask::Rustcask::builder().open(&path)?;
-            Ok::<_, Self::StorageError>(db)
-        })
-        .await
-        .expect("join error")?;
-
-        Ok(RustcaskAccess { db })
-    }
-}
-
-pub struct RustcaskAccess {
-    db: rustcask::Rustcask,
-}
-
-impl DiskAccess for RustcaskAccess {
-    type StorageError = CaskError;
-    fn get_writer(&mut self) -> Result<impl DiskWriter<CaskError>, CaskError> {
-        Ok(RustcaskWriter {
-            db: self.db.clone(),
-        })
-    }
-    fn get_reader(&self) -> Result<impl DiskReader<StorageError = CaskError>, CaskError> {
-        Ok(RustcaskReader {
-            db: self.db.clone(),
-        })
-    }
-}
-
-pub struct RustcaskWriter {
-    db: rustcask::Rustcask,
-}
-
-impl DiskWriter<CaskError> for RustcaskWriter {
-    fn put(&mut self, key: Vec<u8>, val: Vec<u8>) -> Result<(), CaskError> {
-        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 {
-    db: rustcask::Rustcask,
-}
-
-impl DiskReader for RustcaskReader {
-    type StorageError = CaskError;
-    fn get(&mut self, key: Vec<u8>) -> Result<Option<Vec<u8>>, CaskError> {
-        self.db
-            .get(&key)
-            .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(2 * 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);
-        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 tx = self.tx.as_mut().unwrap();
-        self.db.put(tx, &key, &val)?;
-        Ok(())
-    }
-    fn put_many(
-        &mut self,
-        kv: impl Iterator<Item = (Vec<u8>, Vec<u8>)>,
-    ) -> Result<(), heed::Error> {
-        let tx = self.tx.as_mut().unwrap();
-        for (k, v) in kv {
-            self.db.put(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

···
 //! Consume an MST block stream, producing an ordered stream of records
 
-use crate::disk::{DiskAccess, DiskStore, DiskWriter, StorageErrorBase};
+use crate::disk::{SqliteAccess, SqliteStore};
 use ipld_core::cid::Cid;
 use iroh_car::CarReader;
 use serde::de::DeserializeOwned;
···
 }
 
 #[derive(Debug, thiserror::Error)]
-pub enum DiskDriveError<E: StorageErrorBase> {
+pub enum DiskDriveError {
     #[error("Error from iroh_car: {0}")]
     CarReader(#[from] iroh_car::Error),
     #[error("Failed to decode commit block: {0}")]
     BadBlock(#[from] serde_ipld_dagcbor::DecodeError<Infallible>),
     #[error("Storage error")]
-    StorageError(#[from] E),
+    StorageError(#[from] rusqlite::Error),
     #[error("The Commit block reference by the root was not found")]
     MissingCommit,
     #[error("The MST block {0} could not be found")]
···
     #[error("Decode error: {0}")]
     BincodeDecodeError(#[from] bincode::error::DecodeError),
     #[error("disk tripped: {0}")]
-    DiskTripped(#[from] DiskTrip<E>),
+    DiskTripped(#[from] DiskTrip),
 }
 
 pub trait Processable: Clone + Serialize + DeserializeOwned {
···
 }
 
 impl<R: AsyncRead + Unpin, T: Processable + Send + 'static> BigCar<R, T> {
-    pub async fn finish_loading<S: DiskStore>(
+    pub async fn finish_loading(
         mut self,
-        mut store: S,
-    ) -> Result<(Commit, BigCarReady<T, S::Access>), DiskDriveError<S::StorageError>>
-    where
-        S::Access: Send + 'static,
-        S::StorageError: 'static,
-    {
+        mut store: SqliteStore,
+    ) -> Result<(Commit, BigCarReady<T>), DiskDriveError> {
         // set up access for real
         let mut access = store.get_access().await?;
 
···
             writer.put_many(kvs)?;
 
             drop(writer); // cannot outlive access
-            Ok::<_, DiskDriveError<S::StorageError>>(access)
+            Ok::<_, DiskDriveError>(access)
         })
         .await
         .unwrap()?;
···
                 writer.put_many(kvs)?;
 
                 drop(writer); // cannot outlive access
-                Ok::<_, DiskDriveError<S::StorageError>>(access)
+                Ok::<_, DiskDriveError>(access)
             })
             .await
             .unwrap()?; // TODO
···
     }
 }
 
-pub struct BigCarReady<T: Clone, A: DiskAccess> {
+pub struct BigCarReady<T: Clone> {
     process: fn(Vec<u8>) -> T,
-    access: A,
+    access: SqliteAccess,
     walker: Walker,
 }
 
-impl<T: Processable + Send + 'static, A: DiskAccess + Send + 'static> BigCarReady<T, A> {
+impl<T: Processable + Send + 'static> BigCarReady<T> {
     pub async fn next_chunk(
         mut self,
         n: usize,
-    ) -> Result<(Self, Option<Vec<(String, T)>>), DiskDriveError<A::StorageError>>
-    where
-        A::StorageError: Send,
-    {
+    ) -> Result<(Self, Option<Vec<(String, T)>>), DiskDriveError> {
         let mut out = Vec::with_capacity(n);
         (self, out) = tokio::task::spawn_blocking(move || {
             let access = self.access;
···
 
             drop(reader); // cannot outlive access
             self.access = access;
-            Ok::<_, DiskDriveError<A::StorageError>>((self, out))
+            Ok::<_, DiskDriveError>((self, out))
         })
         .await
         .unwrap()?; // TODO

src/walk.rs

···
 //! Depth-first MST traversal
 
-use crate::disk::{DiskReader, StorageErrorBase};
+use crate::disk::SqliteReader;
 use crate::drive::{MaybeProcessedBlock, Processable};
 use crate::mst::Node;
 use ipld_core::cid::Cid;
···
 
 /// Errors that can happen while walking
 #[derive(Debug, thiserror::Error)]
-pub enum DiskTrip<E: StorageErrorBase> {
+pub enum DiskTrip {
     #[error("tripped: {0}")]
     Trip(#[from] Trip),
     #[error("storage error: {0}")]
-    StorageError(#[from] E),
+    StorageError(#[from] rusqlite::Error),
     #[error("Decode error: {0}")]
     BincodeDecodeError(#[from] bincode::error::DecodeError),
 }
···
     }
 
     /// blocking!!!!!!
-    pub fn disk_step<T: Processable, R: DiskReader>(
+    pub fn disk_step<T: Processable>(
         &mut self,
-        reader: &mut R,
+        reader: &mut SqliteReader,
         process: impl Fn(Vec<u8>) -> T,
-    ) -> Result<Step<T>, DiskTrip<R::StorageError>> {
+    ) -> Result<Step<T>, DiskTrip> {
         loop {
             let Some(mut need) = self.stack.last() else {
                 log::trace!("tried to walk but we're actually done.");