3 comments

  • gdcbe a day ago

    Hi HN, I'm the author.

    This project started about three years ago as a small piece of a proxy project (ramaproxy.org): on every request we pick a random upstream proxy that matches a handful of flags and a country or city. The data barely changes, the queries happen constantly. Scanning a Vec got slow, and SQLite felt like a lot of database for "give me a random row with these flags".

    VennDB is a Rust library: you add a derive macro to a struct, and it generates a database type and a query builder for it. Bools become bitmasks, filter values become sets of rows, and a query is the intersection of those sets. It can pick a random match without finding all of them first.

    It is mostly a bitmap index, generated from your struct so you don't have to write and maintain it yourself. It is also narrow on purpose: append-only and in-memory, with no updates or deletes. As such it is not really a database in the traditional sense of the word, but as I was not sure how to name it differently given it does fulfill a niche subset of usecases that I would otherwise use an (in-memory) database for it seemed fitting.

    We just released 0.7, which rewrote the engine. In the README compares it with a hand-written roaring bitmap index, SQLite and a plain Vec. roaring gets close on some queries. We're not database experts, so if the benchmarks look unfair or there's prior art we missed, I'd like to hear it.

    • AlotOfReading 38 minutes ago

      I noticed some prior art when I wrote a similar library in C++ earlier this year, but unfortunately it's pretty much all deeply theoretical. The magic search term is "monadic unions of conjunctive queries", which is the class of queries this kind of system can express.

      I'm still surprised there aren't more implementations out there, because it's a very useful class in application programming. For example, gameplay tags in unreal engine are queries in this class [0], and Intel ships a library using them for binary message parsing. It can also be done almost completely in SIMD, which is the route my shitty library takes. If you add recursion on top, you get queries that can express regular languages / monadic datalog.

      My library quickly bottlenecked on memory bandwidth though. It doesn't seem like you're ordering joins by selectivity or a bitmap index to avoid reading unnecessary memory, so is this a direction you plan to explore more in the future?

      [0] https://dev.epicgames.com/documentation/unreal-engine/using-...

    • gopalv an hour ago

      > It is mostly a bitmap index, generated from your struct so you don't have to write and maintain it yourself.

      That explanation makes complete sense, because with this in mind, I can compare it to Apache Druid which does the same thing for data spilled onto S3.

      Since this is immutable, you only had to solve "naming things", since the caches didn't need to be invalidated.

      Druid is technically mutable, since it lets you mutate whole segments & then cache these bitmasks without having the original data in memory.

      But if your dataset is already in memory, this is a neat implementation of an index and it should be faster than Roaring since you can skip the extra translation to the row-id that requires.

      Druid uses Roaring - https://dl.acm.org/doi/10.1145/2938503.2938515