questdb / questdb

English |
 简体中文 
---
QuestDB is the open-source, low-latency time-series database on open formats.
It ingests millions of events per second, computes on live data in
milliseconds, and keeps years of history queryable. One SQL engine spans
ingestion, stream processing, and tiered storage.
The engine is zero-GC Java with C++ and Rust on the hot paths. Data lives in
memory-mapped, time-partitioned columns. Queries run across all cores with SIMD
and JIT-compiled filters. There are no third-party dependencies on the data
path.
Storage is tiered: a parallel write-ahead log, native columnar partitions,
and Apache Parquet. In open source you convert partitions to Parquet with
`ALTER TABLE`, or create a table in Parquet directly. QuestDB Enterprise
converts cold partitions automatically and tiers them to object storage.
Parquet, Apache Iceberg, and Apache Arrow keep the data open to any tool.
Measured on QuestDB 10.0 over QWP:
| | | Source |
|---|---|---|
| Peak ingestion per instance | 19M rows/sec | QWP vs ILP ingestion benchmark |
| Query results streamed to Arrow | 220M rows/sec | Streaming 500 million rows into Arrow |
| 500M rows streamed | 2.3 s | same post |
| First Arrow batch | 32 ms | same post |
## Get started
Use Docker to start quickly:
 [code] 
Or macOS users on Apple Silicon can use Homebrew:
 [code] 
 [code] 
QuestDB bundles native libraries for Apple Silicon only. On an Intel Mac, use
the Docker image above.
For the full walkthrough, start with the
quick start guide.
 QuestDB Web Console - click to launch demo 
> **New in QuestDB 10.0:** the QuestDB Wire Protocol (QWP), one binary
> columnar protocol for writes and for Arrow reads, plus native arrays and
> live views in beta.
> Release notes.
## Ingress and egress over QWP
QWP is a binary columnar protocol over WebSocket. The same connection writes
rows in and streams query results back out as columns. The Python client
returns those columns as Apache Arrow by default, and Rust and C/C++ can
enable it with a flag.
On the way in, the
QWP vs ILP ingestion benchmark
measures 19M rows/sec over the network, and that peak holds from one
thousand to one million series. On the way out,
Streaming 500 million rows into Arrow
measures 220M rows/sec with eight readers, with the first batch after 32 ms
and client memory flat however large the result. The
QWP overview
covers the protocol design.
## What QuestDB does
One engine covers the full lifecycle of the data:
- **Capture.** Ingest millions of ordered and out-of-order events per second
 without pre-aggregation. Deduplication and out-of-order correction are built
 in.
- **Compute.** Transform, enrich, and aggregate events as they arrive.
 Materialized views
 aggregate by time slice, many rows in and one row out.
 Live views run window
 functions such as indicators, one row in and one row out, on an in-memory
 tier.
- **Query.** Run time-series SQL across live and historical data with
 predictable low latency.
- **Retain.** Keep the complete record