QuestDB

One SQL engine spans ingestion, stream processing and tiered storage in QuestDB, a low-latency time-series database built on open formats. That removes the usual split between a hot store for recent events and somewhere else for everything older.

The engine is zero-garbage-collection Java with C++ and Rust on the hot paths, and data lives in memory-mapped, time-partitioned columns. Queries run across all cores with SIMD and JIT-compiled filters, and nothing third-party sits on the data path. Storage is tiered across a parallel write-ahead log, native columnar partitions and Apache Parquet.

One engine covers the whole life of a series.

• Capture: ordered and out-of-order events in the millions per second, with deduplication and out-of-order correction built in.
• Compute: materialized views that aggregate by time slice, and live views running window functions on an in-memory tier.
• Query: time-series SQL extensions including SAMPLE BY, LATEST ON, ASOF JOIN, WINDOW JOIN and n-dimensional arrays.
• Retain: native partitions and Parquet queried through the same SQL, with Iceberg and Arrow keeping the data open to other tools.
• QWP: a binary columnar protocol over WebSocket that writes rows in and streams results back out as Arrow columns.

Docker starts an instance in one command, and Homebrew covers Apple silicon, though the bundled native libraries mean Intel Macs should use the image instead. Published benchmarks measure 19 million rows per second on ingestion and 220 million rows per second streamed into Arrow.