CedarDB Blog

Yep, and the work on https://www.cs.cit.tum.de/dis/research/leanstore/ that preceded it. And CedarDB https://cedardb.com/ the more commercialized product that is following up on some of this research, including employing many of the key researchers.

Impressive, love it, many thanks! CedrarDB [0] (commercialization of Umbra [1] research DB) would be an interesting contender. The group creating Umbra researches on JSON representations in column stores, see [2]. [0] https://cedardb.com/ (commerciUmbra) [1] https://umbra-db.com/ [2] https://db.in.tum.de/~durner/papers/json-tiles-sigmod21.pdf

Great heads up. I wonder about graph databases. He mentioned <https://umbra-db.com/> and <https://cedardb.com/> both include the graph use case and I wonder how they compare to <https://neo4j.com/>.

I like "just use postgres" but postgres is getting a bit long in the tooth in some ways, so I'm pretty helpful that CedarDb sticks the landing. https://cedardb.com/ I suspect it not being open source may prevent a certain level of proliferation unfortunately.

I think the upcoming CedarDB is HTAP? https://cedardb.com/ Clickhouse performance for Postgres workloads?

I'm really curious about the capabilities of https://cedardb.com/ they claim that they can make a single DB that does both OLTP and OLAP. It's basically the production version of umbra.

Depends on your use case. Redis is a key-value store that is optimized for simpler workloads and is designed as a caching layer. Umbra, on the other hand, is a full fledged, ACID compliant relational database systems with all bells and whistles. However, Umbra can process multiple 100ks of transactions per second. If you're interested in more details, take a look at Figure 6 in this research paper: https://db.in.tum.de/~freitag/papers/p2797-freitag.pdf Disclosure: I work for CedarDB (https://cedardb.com), the commercial spinoff of Umbra.

It seems to be a quote from https://cedardb.com/blog/german_strings/ which is about this German Strings type (implemented in Polars) But yeah, it's pretty ignorant to assume Rust can't do this since the best available examples (as with many things) are in Rust. CompactString is really nice. On a typical modern (64-bit) computer CompactString takes 24 bytes and holds up to 24 bytes of UTF-8 text inline, while also having a niche. I guess the confusion arises because C++ people tend to assume that anywhere Rust differs from the practice in the C++ community it's a mistake, even though that's often because C++ made the wrong choice? Rust's &str is "just" &[u8] plus a rule about the meaning of these bytes, and Rust's String is correspondingly "just" Vec<u8> plus a rule about the meaning of those bytes. C++ couldn't have done the former because it only belatedly got the fat pointer slice reference (as the troubled std::span) years after having a string data type. Rust didn't do this in the stdlib, but not because it's impossible, because it's a trade off and they wanted the provided stdlib type to be straightforward. If you need or even just want the trade off, you can just cargo add compact_str

I think this question mixes up two orthogonal dimensions: transactionality (i.e., OLTP vs. OLAP) and data model (relational, document-based, graph, vector, ...). Regarding transactionality: There is an entire area of research on "hybrid transactional and analytical processing" (HTAP) systems that unifies OLAP and OLTP systems. Hyper [1] pioneered this path at TU Munich, it's successor Umbra [2] recently incorporated as CedarDB [3]. There are lots of others. Most of these systems, AFAIK, are relational. Regarding data model: What we've seen in the past few decades is that non-relational DBMS (excluding key-value stores) only make sense in rare edge cases that require huge scale. There has, e.g. been research [4] that shows that graph databases are still, well, lacking, compared to relational systems. The common pattern seems to be: unless you need to service very specific workloads at huge scales, SQL is probably enough [5]. Then again, it really comes down to intrinsics. If you were to, for example, implement distributed locking using Postgres, you would likely run into problems with MVCC and Xids very quickly. So, as you already mentioned, there is no silver bullet. But even today, unless you are Meta or Google, SQL is probably enough for a long time and lots of use cases. (Full disclosure: I'm working on Hyper full-time). [1]: https://hyper-db.de/ [2]: https://umbra-db.com/ [3]: https://cedardb.com/ [4]: https://homepages.cwi.nl/~boncz/edbt2022.pdf [5]:…

Vector instructions usually don't have overflow flags, so a compiler can't easily vectorize loops containing overflow checks. However, detecting overflows in integer operations requires only a bit of bitwise arithmetic. In my experiments, this lead to an overhead of only 7% for vectorized additions with overflow checks: https://cedardb.com/blog/vectorized_overflows/

There are definitely hybrid OLTP-OLAP databases, or HTAP (Hybrid Transaction and Analytical Processing). Microsoft and, I believe, Oracle both have HTAP tech. The most novel design, I think, is CedarDB (developed by Thomas Neumann's database group at TUM), which adaptively stores both row and column versions of the data [1], where some data is permanently compressed to columnar format and hot rows are converted "just in time" to columnar data as needed. [1] https://cedardb.com/blog/colibri/

Never heard of CedarDB. Seems to be another commercial cloud-hosted thing offering a Postgres API? https://dbdb.io/db/cedardb https://cedardb.com/blog/ode_to_postgres/

After decompression, with the performance characteristics you'd expect. If it has to come off disk it's still a win or at least usually breaks even in their measurements. https://cedardb.com/blog/string_compression/#query-runtime The paper suggests that you could rework string matching to work on the compressed data but they haven't done it.

This is a clever ad! I had not heard of them so I looked up the technology behind it: https://cedardb.com/docs/technology/ A Postgresql-compatible HTAP. It appears to be single server and closed source. Roadmap: https://cedardb.com/docs/roadmap/

Here is the paper in question: Umbra: A Disk-Based System with In-Memory Performance https://db.in.tum.de/~freitag/papers/p29-neumann-cidr20.pdf Section 3.1 covers string handling. This article (also linked from tfa) explains German strings in more detail. https://cedardb.com/blog/german_strings

This recent post resonated with me: https://cedardb.com/blog/exceptions_vs_errors/ There are certain obvious (and some less obvious) benefits to both exceptions and results, but I get the impression a lot of programmers have overreacted against exceptions. Exceptions "just work" the same in every codebase and require little boilerplate in most languages. I think results really shine for internal business logic where errors are more "invalid" than "exceptional."

It looks a lot like cedarDB's "german strings". <https://cedardb.com/blog/german_strings/> You could probably write a C++ implementation based on the article. Note that it's not all that useful if you don't plan on searching for text based on their prefix. From my understanding, this is mostly a better way to store SStables in RAM/partially on disk if you mmap.

Slightly off-topic but CedarDB is extremely exciting. It's the commercialization of the widely cited Umbra research DBMS [0] that has been in the works for several years, which benchmarks faster than DuckDB for OLAP [1] whilst simultaneously being really strong for transactional workloads. Also discussed recently here [2]. [0] https://umbra-db.com/ [1] https://cedardb.com/blog/ode_to_postgres/ [2] https://news.ycombinator.com/item?id=40241150

There are TPC-H numbers in another post: https://cedardb.com/blog/simple_efficient_hash_tables/

https://cedardb.com/docs/technology talks about the technical details on how they maximize their usage of available cores and RAM, and their query optimizer.

Kind of, with caveats. For one "extensions can interfere with each other and cause incorrect behavior" [1], and the practicallity of implementations varies. Say, Cypher queries using AGE can be order of magnitude slower than using a dedicated graph DB [2]. Yes, you can drive a Ford Falcon coast-to-coast, but how much gas are you going to spend? Postgres is a solid database but has roots in the 80s. Optimizing for modern hardware would reduce hosting costs and improve efficiency. [3] This isn’t criticism of Postgres as a database but of the idea that it’s inherently sufficient for all use cases. -- 1: https://www.cs.cmu.edu/~pavlo/blog/2025/01/2024-databases-retrospectiv… 2: https://blog.kuzudb.com/post/what-every-gdbms-should-do-and-vision/ 3: https://cedardb.com/blog/ode_to_postgres/#why-is-everyone-still-talkin…

- Data-Oriented Design Revisited: Type Safety in the Zig Compiler - Matthew Lugg - https://youtu.be/KOZcJwGdQok?si=YDal2Gwb0IJPFgrI - Andrew Kelley Practical Data Oriented Design (DoD) - https://youtu.be/IroPQ150F6c?si=F1Z0pLO2W5hbQgpM - CppCon 2014: Mike Acton "Data-Oriented Design and C++" - https://youtu.be/rX0ItVEVjHc?si=jv4hhTSBh3XH--xQ - Why You Shouldn’t Forget to Optimize the Data Layout - https://cedardb.com/blog/optimizing_data_layouts/ - Handles are the better pointers - https://floooh.github.io/2018/06/17/handles-vs-pointers.html - Enum of Arrays - https://tigerbeetle.com/blog/2024-12-19-enum-of-arrays/ - Data oriented design book - https://www.dataorienteddesign.com/dodbook/ - Data-oriented design in practice - Stoyan Nikolov - https://youtu.be/_N5-JjogNXU?si=vhaxYcfE6tl11Sux - Programming without Pointers - Andrew Kelley - https://www.hytradboi.com/2025/05c72e39-c07e-41bc-ac40-85e8308f2917-pr… - More Speed & Simplicity: Practical Data-Oriented Design in C++ - Vittorio Romeo - CppCon 2025 - https://youtu.be/SzjJfKHygaQ?si=jafavSl2YJWk4vIx - Rust Handle - https://taintedcoders.com/rust/handles