questdb/questdb

QuestDB is a high performance, open-source, time-series database

16,807 stars Java 9 components 3 connections

4-stage pipeline · 9 components

High-performance columnar time-series database written in Java and Rust

Data flows from ingestion through WAL to columnar storage, then to query execution with vectorized processing

Under the hood, the system uses 2 feedback loops, 3 data pools, 3 control points to manage its runtime behavior.

A 9-component dashboard with 3 connections. 5291 files analyzed. Data flows through 4 distinct pipeline stages.

How Data Flows Through the System

Data flows from ingestion through WAL to columnar storage, then to query execution with vectorized processing

Data Ingestion — Incoming data written to Write-Ahead Log (WAL) for durability
Columnar Storage — WAL data compacted into native columnar format using Rust drivers
Query Processing — SQL queries executed with vectorized operations and SIMD acceleration
Result Generation — Query results returned via Postgres protocol or REST API

System Behavior

How the system operates at runtime — where data accumulates, what loops, what waits, and what controls what.

Data Pools

Write-Ahead Log (buffer)
Durability buffer for incoming data before columnar compaction

Columnar Storage (file-store)
Time-partitioned columnar data files managed by Rust drivers

Symbol Tables (in-memory)
String deduplication and symbol mapping for efficient storage

Feedback Loops

WAL Compaction (scheduled-job, balancing) — Trigger: WAL size threshold or time interval. Action: Convert WAL entries to columnar format. Exit: WAL fully processed.
Cache Eviction (cache-invalidation, balancing) — Trigger: Memory pressure or TTL expiry. Action: Remove cached query results and metadata. Exit: Memory usage within limits.

Delays

WAL Flush (async-processing, ~configurable interval) — Data durability vs performance trade-off
Columnar Compaction (batch-window, ~based on data volume or time) — Query performance optimization window

Control Points

WAL Flush Interval (threshold) — Controls: Durability vs performance balance in write operations
Compaction Threshold (threshold) — Controls: When WAL data gets converted to columnar format
SIMD Acceleration (feature-flag) — Controls: Vectorized query execution enabling/disabling

Technology Stack

Java (framework)
Core database engine and SQL processing

Rust (framework)
High-performance columnar storage operations

Maven (build)
Build system and dependency management

JMH (testing)
Microbenchmarking framework

Go (testing)
Compatibility testing client

PostgreSQL Wire Protocol (library)
SQL client connectivity

SIMD (library)
Vectorized query execution

Key Components

ColumnDriver (module) — Handles columnar storage operations for different data types with optimized drivers core/rust/qdb-core/src/col_driver/mod.rs
TestRunner (class) — Executes compatibility tests across different database drivers using YAML test definitions compat/src/test/golang/main.go
AbsBenchmark (class) — Base class for JMH performance benchmarks with common configuration benchmarks/src/main/java/org/questdb/AbsBenchmark.java
try_lookup_driver (function) — Maps column types to their corresponding storage drivers based on type and timestamp designation core/rust/qdb-core/src/col_driver/mod.rs
TestConfig (type-def) — YAML structure for defining database compatibility tests with variables and test cases compat/src/test/golang/main.go
ArrayBinarySearchBenchmark (class) — Benchmarks binary search performance on different array types and sizes benchmarks/src/main/java/org/questdb/ArrayBinarySearchBenchmark.java
AssociativeCacheBenchmark (class) — Performance testing for concurrent and simple associative cache implementations benchmarks/src/main/java/org/questdb/AssociativeCacheBenchmark.java
Loop (type-def) — Represents iterative test execution over ranges or collections in test definitions compat/src/test/golang/main.go
substituteVariables (function) — Replaces variable placeholders in test queries with actual values from test context compat/src/test/golang/main.go

Explore the interactive analysis

See the full architecture map, data flow, and code patterns visualization.

Analyze on CodeSea

Related Dashboard Repositories

Frequently Asked Questions

What is questdb used for?

High-performance columnar time-series database written in Java and Rust questdb/questdb is a 9-component dashboard written in Java. Data flows through 4 distinct pipeline stages. The codebase contains 5291 files.

How is questdb architected?

questdb is organized into 4 architecture layers: Core Engine, Native Storage, Compatibility Layer, Performance Testing. Data flows through 4 distinct pipeline stages. This layered structure keeps concerns separated and modules independent.

How does data flow through questdb?

Data moves through 4 stages: Data Ingestion → Columnar Storage → Query Processing → Result Generation. Data flows from ingestion through WAL to columnar storage, then to query execution with vectorized processing This pipeline design keeps the data transformation process straightforward.

What technologies does questdb use?

The core stack includes Java (Core database engine and SQL processing), Rust (High-performance columnar storage operations), Maven (Build system and dependency management), JMH (Microbenchmarking framework), Go (Compatibility testing client), PostgreSQL Wire Protocol (SQL client connectivity), and 1 more. A focused set of dependencies that keeps the build manageable.

What system dynamics does questdb have?

questdb exhibits 3 data pools (Write-Ahead Log, Columnar Storage), 2 feedback loops, 3 control points, 2 delays. The feedback loops handle scheduled-job and cache-invalidation. These runtime behaviors shape how the system responds to load, failures, and configuration changes.

What design patterns does questdb use?

4 design patterns detected: Multi-language FFI, Driver Pattern, YAML-driven Testing, JMH Benchmarking.

Analyzed on March 31, 2026 by CodeSea. Written by Karolina Sarna.