Greptime at MDI Summit: Rethinking observability with one platform for metrics, logs & traces. 👉🏻 Register Now

Skip to content

Database Performance Breakthrough! How GreptimeDB Achieved \#1 Ranking in JSONBench

⭐ GitHub | 🌐 Website | 📚 Docs

💬 Slack | 🐦 Twitter | 💼 LinkedIn


GreptimeDB's #1 ranking in JSONBench cold queries represents more than just a benchmark victory - it validates years of architectural decisions optimized for cloud-native workloads. While competitors struggle with object storage latency, GreptimeDB delivers consistent performance whether data resides in memory or cold storage.

The JSONBench Challenge ​

JSONBench processes 1 billion JSON documents from Bluesky social media data, executing complex analytical queries that stress-test database architectures. This benchmark reveals how databases handle:

  • Massive data ingestion (terabytes of nested JSON)
  • Complex analytical workloads across varied query patterns
  • Cold storage performance without memory caching
  • Resource efficiency under sustained load

GreptimeDB's cold query dominance demonstrates superior storage architecture, while strong hot query performance proves the caching strategies work effectively across different access patterns.

Multi-Tiered Storage Architecture ​

GreptimeDB's storage design implements intelligent caching inspired by operating system page cache principles:

Write Cache Layer ​

Recent data optimization:

  • Time-ordered layout enables rapid access to latest entries
  • Configurable retention (hours to days based on workload)
  • Write-through durability ensures data safety

Read Cache Intelligence ​

LRU-based historical data management:

  • Parquet data pages cached on local high-speed storage
  • Dramatically faster than direct object storage access
  • Predictive cache warming for frequently accessed patterns

Metadata and Index Caching ​

Critical system information stays memory-resident:

  • Table schema and routing information
  • Parquet file metadata for efficient query planning
  • Index structures for fast data location

This three-tier approach balances performance with cost efficiency, explaining why GreptimeDB maintains consistent performance regardless of data temperature.

Object Storage Economics vs Performance ​

GreptimeDB's storage economics reflect deep understanding of cloud infrastructure costs:

Cost Analysis (per GB/month) ​

  • Amazon S3 Standard: $0.023
  • Amazon EBS gp3: $0.080
  • Performance advantage: 3.5x cost reduction

Performance Mitigation Strategies ​

Intelligent caching eliminates object storage access latency:

  • 90% of queries hit faster cache tiers
  • Predictive data loading based on access patterns
  • Parallel object retrieval when cold storage access is required

Columnar Storage Optimizations ​

GreptimeDB's columnar architecture provides multiple performance advantages:

Compression Excellence ​

  • Algorithm-specific compression optimized per column type
  • 30-40x compression ratios for time-series data patterns
  • Dictionary encoding for string value optimization
  • Delta encoding for timestamp sequence efficiency

Query Performance Benefits ​

  • Column pruning reads only necessary data columns
  • Vectorized operations leverage modern CPU SIMD instructions
  • Parallel processing across multiple CPU cores

JSON Optimization Strategy ​

Nested JSON structures decompose into efficient columnar representations:

sql
-- Original JSON document
{
  "user": {"id": 123, "name": "alice"},
  "event": {"type": "click", "timestamp": "2024-01-01T10:00:00Z"}
}

-- Becomes optimized columnar structure
user_id: 123
user_name: "alice"
event_type: "click"
event_timestamp: 2024-01-01T10:00:00Z

This automatic flattening improves both compression ratios and query performance significantly.

LSM-Tree Adaptations for Observability ​

GreptimeDB's LSM-tree implementation includes observability-specific optimizations:

Write Buffer Innovation ​

  • Apache Arrow in-memory format reduces serialization overhead
  • Dictionary encoding minimizes memory footprint
  • Time-series aware merging for related metric consolidation

Intelligent Compaction ​

  • Time-based partitioning aligns with typical query patterns
  • Background processing prevents resource conflicts during peak loads
  • Adaptive strategies based on data access characteristics

The Rust Performance Advantage ​

Rust's system-level performance provides foundational benefits:

Memory Management Excellence ​

  • Zero-cost abstractions eliminate runtime performance overhead
  • Memory safety guarantees prevent crashes under high load
  • Predictable performance without garbage collection pauses

Concurrency Optimization ​

  • Fearless concurrency enables efficient parallel processing
  • Actor-based architecture provides component isolation
  • Async/await patterns for non-blocking I/O operations

JSONBench Results Analysis ​

Performance comparison across database systems:

Cold Query Performance ​

  1. GreptimeDB: Consistently fastest across all query types
  2. ClickHouse: Strong but inconsistent performance
  3. VictoriaLogs: Good average but variable results
  4. Traditional systems: Significantly slower overall

The performance gap reflects fundamental architectural differences:

  • GreptimeDB: Cloud-native design from inception
  • ClickHouse: Optimized for high-memory environments
  • Legacy systems: Retrofitted cloud features on traditional architectures

Advanced Features Beyond Benchmarks ​

Pipeline Processing Integration ​

Built-in ETL capabilities eliminate external processing overhead:

yaml
processors:
  - json:
      field: message
      target_field: parsed
  - dissect:
      field: parsed.log
      pattern: "%{timestamp} %{level} %{service} %{message}"

Intelligent Data Lifecycle ​

Automated tiering based on data age and access patterns:

sql
-- Configure automatic data movement
-- Recent data: Hot NVMe storage
-- 30+ days: Warm SSD storage
-- 1+ year: Cold object storage

Operational Excellence ​

Cloud-native operational model:

  • Kubernetes-native deployment with automatic scaling
  • Built-in monitoring with Prometheus metrics export
  • Service mesh integration for distributed observability

Architectural Philosophy Impact ​

GreptimeDB's design principles prioritize:

  1. Cloud-first thinking from initial architecture decisions
  2. Cost efficiency without performance trade-offs
  3. Operational simplicity over feature complexity
  4. Unified data model for all observability workloads

This architectural coherence explains why GreptimeDB outperforms databases that attempt to retrofit cloud capabilities onto legacy designs.

Real-World Performance Validation ​

Production deployments demonstrate benchmark results translate to real-world benefits:

  • 50-80% reduction in observability infrastructure costs
  • Consistent sub-second query response times
  • Linear scalability as data volumes increase
  • Simplified operations compared to multi-database architectures

GreptimeDB's JSONBench victory validates the cloud-native approach to database architecture. By optimizing for modern cloud infrastructure from day one, GreptimeDB delivers the performance and cost efficiency that legacy databases simply cannot match.

Ready to experience next-generation database performance? GreptimeDB's proven architecture represents the future of cloud-native observability databases.


About Greptime ​

GreptimeDB is an open-source, cloud-native database purpose-built for real-time observability. Built in Rust and optimized for cloud-native environments, it provides unified storage and processing for metrics, logs, and traces—delivering sub-second insights from edge to cloud —at any scale.

  • GreptimeDB OSS – The open-sourced database for small to medium-scale observability and IoT use cases, ideal for personal projects or dev/test environments.

  • GreptimeDB Enterprise – A robust observability database with enhanced security, high availability, and enterprise-grade support.

  • GreptimeCloud – A fully managed, serverless DBaaS with elastic scaling and zero operational overhead. Built for teams that need speed, flexibility, and ease of use out of the box.

🚀 We’re open to contributors—get started with issues labeled good first issue and connect with our community.

Join our community

Get the latest updates and discuss with other users.