1. Docker

Check if Docker is installed and the daemon is running:

docker --version && docker info --format '{{.ServerVersion}}'

If Docker is not installed, install it (Ubuntu/Debian):

sudo apt-get update -qq
sudo apt-get install -y -qq ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update -qq
sudo apt-get install -y -qq docker-ce docker-ce-cli containerd.io docker-buildx-plugin

2. Go (needed to build TSBS)

Check if Go is installed:

go version

If Go is not installed, install Go 1.22.5:

curl -fsSL https://go.dev/dl/go1.22.5.linux-amd64.tar.gz -o /tmp/go.tar.gz
sudo rm -rf /usr/local/go && sudo tar -C /usr/local -xzf /tmp/go.tar.gz && rm /tmp/go.tar.gz
export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin

3. Build tools

sudo apt-get install -y -qq make gcc gzip

Step 1: Start QuestDB in Docker

Stop and remove any existing QuestDB container first to start clean:

sudo docker rm -f questdb 2>/dev/null || true

Pull latest image and start:

sudo docker pull questdb/questdb:latest
sudo docker run -d --name questdb \
  -p 9000:9000 -p 9009:9009 -p 8812:8812 -p 9003:9003 \
  questdb/questdb:latest

Verify it is running:

sudo docker ps --filter name=questdb --format '{{.Status}}'

Step 2: Clone And Build TSBS

cd /home/ubuntu
git clone https://github.com/questdb/tsbs.git
cd /home/ubuntu/tsbs
export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin
make tsbs_generate_data tsbs_generate_queries tsbs_load_questdb tsbs_run_queries_questdb

Build only the four binaries needed for QuestDB benchmarking into bin/.

Step 3: Generate Benchmark Data

IMPORTANT: Do not compress (gzip) the data file. Compression/decompression adds CPU overhead that skews benchmark results, especially on smaller machines.

/home/ubuntu/tsbs/bin/tsbs_generate_data \
  --use-case="cpu-only" \
  --seed=123 \
  --scale=4000 \
  --timestamp-start="2016-01-01T00:00:00Z" \
  --timestamp-end="2016-01-02T00:00:00Z" \
  --log-interval="10s" \
  --format="questdb" \
  > /tmp/questdb-data.txt

This generates approximately 12GB of uncompressed data (34.5M rows, 345.6M metrics).

Step 4: Load Data Into QuestDB

Use as many workers as CPU cores available (up to 32). Capture the load summary and report ingestion throughput in rows/s (and metrics/s):

WORKERS=$(nproc)
if [ "$WORKERS" -gt 32 ]; then WORKERS=32; fi

/home/ubuntu/tsbs/bin/tsbs_load_questdb \
  --file=/tmp/questdb-data.txt \
  --workers=$WORKERS \
  2>&1 | tee /tmp/questdb-load.log

# Report ingestion throughput from TSBS summary
# Example output line includes: "overall row/s"
grep -E "loaded .*metrics|loaded .*rows" /tmp/questdb-load.log

Expected summary lines include the mean rates, e.g. overall row/s for rows/second and overall metric/s for metrics/second.

Step 5: Generate Query Files

Generate 1000 queries for all 16 cpu-only query types. Keep all query files uncompressed:

TSBS_BIN=/home/ubuntu/tsbs/bin
COMMON_ARGS="--use-case=cpu-only --seed=123 --scale=4000 --timestamp-start=2016-01-01T00:00:00Z --timestamp-end=2016-01-02T00:00:01Z --queries=1000 --format=questdb"

for QTYPE in \
  cpu-max-all-1 cpu-max-all-8 cpu-max-all-32-24 \
  single-groupby-1-1-1 single-groupby-1-1-12 single-groupby-1-8-1 \
  single-groupby-5-1-1 single-groupby-5-1-12 single-groupby-5-8-1 \
  double-groupby-1 double-groupby-5 double-groupby-all \
  high-cpu-1 high-cpu-all \
  lastpoint groupby-orderby-limit; do
  $TSBS_BIN/tsbs_generate_queries $COMMON_ARGS --query-type="$QTYPE" > "/tmp/questdb-queries-${QTYPE}.txt"
done

Step 6: Run Query Benchmarks

IMPORTANT: Use one worker for queries. QuestDB parallelizes queries internally (multi-threaded execution), so multiple client workers over-subscribe CPU and produce misleading results.

TSBS_BIN=/home/ubuntu/tsbs/bin

for QTYPE in \
  cpu-max-all-1 cpu-max-all-8 cpu-max-all-32-24 \
  single-groupby-1-1-1 single-groupby-1-1-12 single-groupby-1-8-1 \
  single-groupby-5-1-1 single-groupby-5-1-12 single-groupby-5-8-1 \
  double-groupby-1 double-groupby-5 double-groupby-all \
  high-cpu-1 high-cpu-all \
  lastpoint groupby-orderby-limit; do
  echo "=== $QTYPE ==="
  $TSBS_BIN/tsbs_run_queries_questdb \
    --file="/tmp/questdb-queries-${QTYPE}.txt" \
    --workers=1 \
    --print-interval=0
  echo ""
done

Cleanup

When done benchmarking:

sudo docker rm -f questdb
rm -f /tmp/questdb-data.txt /tmp/questdb-queries-*.txt

Notes

cpu-only with scale=4000 and a 1-day window is a solid general benchmark.
For --use-case, also try devops or iot (each has different query types).
Run tsbs_generate_queries --help to see the full matrix of use-case + query-type combinations.
Port 9000 is Web Console (HTTP), 9009 is ILP (line protocol), and 8812 is PostgreSQL wire.
The data loading step uses ILP (9009); queries use PostgreSQL wire (8812).

questdb-tsbs-benchmark

TSBS Benchmark for QuestDB

Prerequisites Check And Install