# QuestDB

> High-performance time-series database with SQL support and built-in web console.

- Category: Database Stacks
- Difficulty: beginner
- Components: questdb
- Tags: questdb, time-series, sql, analytics, fast
- Source: https://docker.recipes/databases/questdb

## Overview

QuestDB is a high-performance, open-source time-series database engineered for fast ingestion and real-time analytics on time-series data. Developed with a focus on speed and efficiency, QuestDB combines the familiar SQL interface with specialized time-series functions, making it accessible to developers while delivering exceptional performance. The database architecture is built from the ground up in Java and C++ to handle millions of rows per second ingestion with sub-millisecond query latencies, positioning it as a modern alternative to traditional time-series databases.

This QuestDB deployment exposes multiple protocols and interfaces to maximize integration flexibility and data ingestion speed. The configuration provides access to QuestDB's web-based console for interactive SQL queries, PostgreSQL wire protocol compatibility for existing applications, InfluxDB line protocol support for high-throughput data ingestion, and a REST API for HTTP-based interactions. This multi-protocol approach allows QuestDB to serve as a drop-in replacement for various database scenarios while maintaining its time-series optimization advantages.

Developers building IoT applications, DevOps teams managing monitoring infrastructure, financial institutions processing market data, and data engineers handling large-scale analytics workloads will find this QuestDB deployment particularly valuable. The combination of SQL familiarity, multiple ingestion protocols, and built-in visualization tools makes it ideal for teams transitioning from traditional databases to time-series optimized solutions without sacrificing ease of use or requiring extensive application rewrites.

## Features

- Native SQL support with time-series specific functions and SAMPLE BY clauses for temporal aggregations
- Multi-protocol data ingestion supporting InfluxDB line protocol, PostgreSQL wire protocol, and REST API
- Built-in web console with interactive SQL editor, query visualization, and real-time data exploration
- Column-oriented storage engine optimized for time-series data compression and query performance
- SIMD-optimized query execution delivering sub-millisecond response times for analytical queries
- Automatic data partitioning by time intervals with configurable retention policies
- Lock-free concurrent writers enabling millions of rows per second ingestion rates
- Built-in monitoring and metrics accessible through the web interface for performance tracking

## Use cases

- IoT sensor data collection and real-time monitoring dashboards for industrial automation systems
- Application performance monitoring (APM) and infrastructure metrics storage for DevOps teams
- Financial market data ingestion and algorithmic trading systems requiring low-latency queries
- Time-series analytics for e-commerce platforms tracking user behavior and conversion metrics
- Energy sector monitoring for smart grid data analysis and predictive maintenance systems
- Cryptocurrency trading platforms requiring high-frequency price data storage and analysis
- Gaming analytics platforms collecting player behavior data and real-time performance metrics

## Prerequisites

- Docker Engine 20.10+ and Docker Compose V2 for container orchestration support
- Minimum 2GB RAM allocation for QuestDB container with 4GB+ recommended for production workloads
- Available ports 8812, 9000, 9003, and 9009 for PostgreSQL, web console, REST API, and InfluxDB protocols
- Basic SQL knowledge for querying time-series data and understanding temporal functions
- Understanding of time-series data concepts including timestamps, measurements, and aggregation patterns
- Sufficient disk space for data persistence with consideration for QuestDB's column storage format

## docker-compose.yml

```yaml
services:
  questdb:
    image: questdb/questdb:latest
    container_name: questdb
    restart: unless-stopped
    volumes:
      - questdb_data:/var/lib/questdb
    ports:
      - "9000:9000"
      - "9009:9009"
      - "8812:8812"
      - "9003:9003"
    networks:
      - questdb-network

volumes:
  questdb_data:

networks:
  questdb-network:
    driver: bridge
```

## .env

```bash
# QuestDB requires no configuration
```

## Usage notes

- Docs: https://questdb.io/docs/
- Web console at http://localhost:9000 - run SQL queries directly
- PostgreSQL wire protocol on port 8812 - use psql or any PG client
- InfluxDB line protocol on port 9009 for high-speed ingestion
- REST API on port 9003 for HTTP-based queries
- Handles millions of rows/sec ingestion with sub-ms queries

## Troubleshooting

- Web console showing 'Connection refused' at localhost:9000: Verify container is running and port mapping is correct, check Docker logs for QuestDB startup errors
- High memory usage during large data ingestion: Increase Docker container memory limits and configure QuestDB's cairo.sql.copy.buffer.size for optimal performance
- PostgreSQL client connection failures on port 8812: Ensure client supports PostgreSQL wire protocol v3 and check for firewall blocking the connection
- InfluxDB line protocol ingestion errors on port 9009: Validate line protocol format syntax and check QuestDB logs for parsing errors or schema conflicts
- Slow query performance on large datasets: Verify proper timestamp indexing, consider data partitioning strategies, and optimize WHERE clauses for time ranges
- Container fails to start with permission errors: Check volume permissions for questdb_data and ensure Docker daemon has write access to the mount point

