From c6b49519ffde956ab20699b228646fb336ca9b02 Mon Sep 17 00:00:00 2001 From: Alexey Milovidov Date: Sun, 26 Jul 2026 02:07:39 +0200 Subject: [PATCH 1/3] Read the dataset from the copy in this machine's region The daily fleet moved from eu-central-1 to us-east-1 on 2026-07-20 (08bab9295, "the region defaults to us-east-1 (cheaper)"), but the public datasets live in clickhouse-public-datasets, which is in eu-central-1. Every entry that reads S3 at query time has been going transatlantic since. clickhouse-web took the worst of it, ~30x on every machine size: machine 2026-07-19 2026-07-25 ratio c6a.large 459 s 10114 s 22.0x c6a.xlarge 170 s 5306 s 31.2x c6a.2xlarge 91 s 2970 s 32.7x c6a.4xlarge 52 s 1730 s 33.4x c8g.4xlarge 50 s 1791 s 35.8x c6a.metal 21 s 754 s 35.6x c7a.metal-48xl 19 s 628 s 32.7x c8g.metal-48xl 21 s 631 s 30.4x The ratio barely moves across machine sizes and is uniform across all 43 queries: this is round-trip latency, not CPU. The web disk issues many small granule-level range reads, and clickhouse-web/query drops the filesystem cache before every try, so all three tries pay it. clickhouse-datalake, whose reads are large and sequential, lost a milder 3.8x on cold (119 s -> 452 s). Entries that download the data first are unaffected and stayed flat. The ClickBench paths are now mirrored in clickhouse-public-datasets--us-east-1. lib/dataset-bucket.sh asks the instance metadata service where we are and picks the nearer copy: eu-* keeps the original bucket, everything else takes the mirror. If IMDS is unreachable (not EC2, or another cloud) we keep the original, which is what every non-EC2 run has always used; CLICKBENCH_DATASET_BUCKET overrides the choice. The create.sql files are rewritten on the way into the client rather than templated, so they stay valid standalone SQL. bench_dataset_sql covers the three forms they use: the virtual-hosted hostname with or without a region, the s3:// scheme, and the region DuckDB's S3 secret signs with. versions/prepare-data/ is left alone: those scripts are one-off tools for regenerating the versions-benchmark files, not part of any benchmark run. The files they produce are mirrored in full, so the versions suite itself runs anywhere. Verified against the live bucket: ClickHouse S3 single-file and {0..99} glob, the web disk, and both DuckDB entries through their real ./load scripts all return 99997497 rows and 630500 for Q1, identical from either bucket. Region mapping checked for seven regions with faked IMDS responses, and sourcing is safe under set -euo pipefail. Co-Authored-By: Claude Opus 5 (1M context) --- .gitignore | 1 + clickhouse-datalake-partitioned/load | 3 +- clickhouse-datalake/load | 3 +- clickhouse-web/install | 6 +-- clickhouse-web/load | 6 ++- duckdb-datalake-partitioned/load | 5 +- duckdb-datalake/load | 5 +- lib/dataset-bucket.sh | 68 ++++++++++++++++++++++++++++ versions/cloud-init.sh.in | 3 +- 9 files changed, 90 insertions(+), 10 deletions(-) create mode 100644 lib/dataset-bucket.sh diff --git a/.gitignore b/.gitignore index b5af5117b5..a824c6a478 100644 --- a/.gitignore +++ b/.gitignore @@ -19,6 +19,7 @@ arc_token.txt data-size.txt .doris_home .sirius_env +create.rewritten.sql # Per-system data files hits.db diff --git a/clickhouse-datalake-partitioned/load b/clickhouse-datalake-partitioned/load index 263d5f1b89..12a4eff9fe 100755 --- a/clickhouse-datalake-partitioned/load +++ b/clickhouse-datalake-partitioned/load @@ -5,6 +5,7 @@ set -e # remote-backed ENGINE = S3 table. Create the table once here; # clickhouse-local persists the metadata in the --path directory so # subsequent ./query invocations can reuse it. +. ../lib/dataset-bucket.sh ./clickhouse local --path . --query="DROP TABLE IF EXISTS hits" -./clickhouse local --path . --query="$(cat create.sql)" +./clickhouse local --path . --query="$(bench_dataset_sql < create.sql)" sync diff --git a/clickhouse-datalake/load b/clickhouse-datalake/load index 72c729cba4..74c46ba538 100755 --- a/clickhouse-datalake/load +++ b/clickhouse-datalake/load @@ -4,6 +4,7 @@ set -e # Data lives in S3; create.sql defines a remote-backed ENGINE = S3 table. # Create the table once here; clickhouse-local persists the metadata in the # --path directory so subsequent ./query invocations can reuse it. +. ../lib/dataset-bucket.sh ./clickhouse local --path . --query="DROP TABLE IF EXISTS hits" -./clickhouse local --path . --query="$(cat create.sql)" +./clickhouse local --path . --query="$(bench_dataset_sql < create.sql)" sync diff --git a/clickhouse-web/install b/clickhouse-web/install index 5f29ba5ee9..dcfae3db1f 100755 --- a/clickhouse-web/install +++ b/clickhouse-web/install @@ -1,9 +1,9 @@ #!/bin/bash set -e -o pipefail -# Note: this benchmark expects to run in eu-central-1 (Frankfurt) on an -# n-class network-optimized machine (e.g. c5n.4xlarge), since data is fetched -# over HTTP from a public ClickHouse-hosted dataset. +# Note: every read is remote, so this benchmark wants an n-class +# network-optimized machine (e.g. c5n.4xlarge) and a dataset copy in the same +# region. ./load picks the copy via lib/dataset-bucket.sh. if [ ! -x /usr/bin/clickhouse ]; then curl -fsSL --retry 10 --retry-delay 60 --retry-all-errors https://clickhouse.com/ | sh diff --git a/clickhouse-web/load b/clickhouse-web/load index 8b928b8f5b..6909558ea5 100755 --- a/clickhouse-web/load +++ b/clickhouse-web/load @@ -3,6 +3,8 @@ set -e # create.sql is an ATTACH TABLE that points to a remote web disk; nothing is # downloaded or written here, the table is materialized on-demand at query -# time, with /dev/shm/clickhouse/ as a local cache. -clickhouse-client < create.sql +# time, with /dev/shm/clickhouse/ as a local cache. Every read is remote, so +# the endpoint has to be the dataset copy in this machine's part of the world. +. ../lib/dataset-bucket.sh +bench_dataset_sql < create.sql | clickhouse-client sync diff --git a/duckdb-datalake-partitioned/load b/duckdb-datalake-partitioned/load index 03aecdd6fc..17aeb8d6c1 100755 --- a/duckdb-datalake-partitioned/load +++ b/duckdb-datalake-partitioned/load @@ -3,6 +3,9 @@ set -e # create.sql installs httpfs and defines a VIEW directly over S3 partitioned # parquet — no local data is loaded. Persist the view in hits.db. +. ../lib/dataset-bucket.sh rm -f hits.db -duckdb hits.db -f create.sql +trap 'rm -f create.rewritten.sql' EXIT +bench_dataset_sql < create.sql > create.rewritten.sql +duckdb hits.db -f create.rewritten.sql sync diff --git a/duckdb-datalake/load b/duckdb-datalake/load index 376474284c..0d0a09b867 100755 --- a/duckdb-datalake/load +++ b/duckdb-datalake/load @@ -3,6 +3,9 @@ set -e # create.sql installs httpfs and defines a VIEW directly over S3 — no local # data is loaded. Persist the view in hits.db. +. ../lib/dataset-bucket.sh rm -f hits.db -duckdb hits.db -f create.sql +trap 'rm -f create.rewritten.sql' EXIT +bench_dataset_sql < create.sql > create.rewritten.sql +duckdb hits.db -f create.rewritten.sql sync diff --git a/lib/dataset-bucket.sh b/lib/dataset-bucket.sh new file mode 100644 index 0000000000..d7d3f93712 --- /dev/null +++ b/lib/dataset-bucket.sh @@ -0,0 +1,68 @@ +#!/bin/bash +# Selects the copy of the public dataset bucket closest to this machine. +# +# The datasets live in clickhouse-public-datasets (eu-central-1). The paths +# ClickBench reads are mirrored byte-for-byte in +# clickhouse-public-datasets--us-east-1. +# +# Reading them across the Atlantic is ruinous for the entries that query S3 at +# query time. When the daily fleet moved from eu-central-1 to us-east-1 on +# 2026-07-20, clickhouse-web got ~30x slower on every machine size: the web +# disk issues many small range reads, so it is bound by round-trip latency +# rather than bandwidth. clickhouse-datalake, whose reads are large and +# sequential, lost a milder ~3.8x. +# +# Sourcing this file sets: +# DATASET_BUCKET bucket name, for s3:// URLs +# DATASET_REGION the bucket's region, for clients that need it stated +# DATASET_HOST virtual-hosted-style hostname, for https:// URLs +# and defines bench_dataset_sql, a stdin->stdout filter that rewrites +# references to the eu-central-1 bucket into the selected one. +# +# Selection: EU regions keep the original bucket, everything else takes the +# us-east-1 mirror. The machine's region comes from the EC2 instance metadata +# service; if that is unreachable (not EC2, or a different cloud) we keep the +# original bucket, which is what every non-EC2 run has always used. Set +# CLICKBENCH_DATASET_BUCKET= to force a choice. + +bench_detect_region() { + local token + token=$(curl -fsS --connect-timeout 1 --max-time 2 -X PUT \ + -H 'X-aws-ec2-metadata-token-ttl-seconds: 60' \ + 'http://169.254.169.254/latest/api/token' 2>/dev/null) || return 1 + curl -fsS --connect-timeout 1 --max-time 2 \ + -H "X-aws-ec2-metadata-token: ${token}" \ + 'http://169.254.169.254/latest/meta-data/placement/region' 2>/dev/null +} + +if [ -n "${CLICKBENCH_DATASET_BUCKET:-}" ]; then + DATASET_BUCKET="${CLICKBENCH_DATASET_BUCKET}" +else + _bench_region=$(bench_detect_region) || _bench_region='' + case "${_bench_region}" in + # eu-west-* and friends are far closer to Frankfurt than us-east-1 is, + # so the whole EU keeps the original bucket. An empty region means + # detection failed. + eu-*|'') DATASET_BUCKET='clickhouse-public-datasets' ;; + *) DATASET_BUCKET='clickhouse-public-datasets--us-east-1' ;; + esac + unset _bench_region +fi + +case "${DATASET_BUCKET}" in + *--us-east-1) DATASET_REGION='us-east-1' ;; + *) DATASET_REGION='eu-central-1' ;; +esac +DATASET_HOST="${DATASET_BUCKET}.s3.${DATASET_REGION}.amazonaws.com" + +export DATASET_BUCKET DATASET_REGION DATASET_HOST + +# Rewrites the three forms the create.sql files use: the virtual-hosted +# hostname with or without a region, the s3:// scheme, and the region a client +# is told to sign with (DuckDB's S3 secret). Leaving the original bucket +# selected makes every rule a no-op. +bench_dataset_sql() { + sed -e "s|clickhouse-public-datasets\.s3\(\.[a-z0-9-]*\)\?\.amazonaws\.com|${DATASET_HOST}|g" \ + -e "s|s3://clickhouse-public-datasets/|s3://${DATASET_BUCKET}/|g" \ + -e "s|\(REGION '\)eu-central-1\('\)|\1${DATASET_REGION}\2|g" +} diff --git a/versions/cloud-init.sh.in b/versions/cloud-init.sh.in index c97fdc3c0a..54a210ca77 100644 --- a/versions/cloud-init.sh.in +++ b/versions/cloud-init.sh.in @@ -37,7 +37,8 @@ export LOAD_DATASETS="${DATASETS}" DATADIR=prepare-data/data mkdir -p "${DATADIR}" -BUCKET='https://clickhouse-public-datasets.s3.amazonaws.com/versions-benchmark' +. ../lib/dataset-bucket.sh +BUCKET="https://${DATASET_HOST}/versions-benchmark" # Download the files for the datasets we will load, in parallel. A missing file # (e.g. ssb/taxi not uploaded yet) just fails its own wget and is skipped, so From db43d2a1b50f18064cbb547b50ac7aa24ebb949d Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Sun, 26 Jul 2026 00:57:15 +0000 Subject: [PATCH 2/3] Add benchmark results for clickhouse-datalake, clickhouse-datalake-partitioned, clickhouse-web, duckdb-datalake, duckdb-datalake-partitioned (c6a.2xlarge, c6a.4xlarge, c6a.large, c6a.metal, c6a.xlarge, c7a.metal-48xl, c8g.4xlarge, c8g.metal-48xl) --- .../results/20260726/c6a.2xlarge.json | 60 +++++++++++++++++++ .../results/20260726/c6a.4xlarge.json | 60 +++++++++++++++++++ .../results/20260726/c6a.metal.json | 60 +++++++++++++++++++ .../results/20260726/c6a.xlarge.json | 60 +++++++++++++++++++ .../results/20260726/c7a.metal-48xl.json | 60 +++++++++++++++++++ .../results/20260726/c8g.4xlarge.json | 60 +++++++++++++++++++ .../results/20260726/c8g.metal-48xl.json | 60 +++++++++++++++++++ .../results/20260726/c6a.2xlarge.json | 60 +++++++++++++++++++ .../results/20260726/c6a.4xlarge.json | 60 +++++++++++++++++++ .../results/20260726/c6a.metal.json | 60 +++++++++++++++++++ .../results/20260726/c6a.xlarge.json | 60 +++++++++++++++++++ .../results/20260726/c7a.metal-48xl.json | 60 +++++++++++++++++++ .../results/20260726/c8g.4xlarge.json | 60 +++++++++++++++++++ .../results/20260726/c8g.metal-48xl.json | 60 +++++++++++++++++++ .../results/20260726/c6a.2xlarge.json | 60 +++++++++++++++++++ .../results/20260726/c6a.4xlarge.json | 60 +++++++++++++++++++ .../results/20260726/c6a.metal.json | 60 +++++++++++++++++++ .../results/20260726/c6a.xlarge.json | 60 +++++++++++++++++++ .../results/20260726/c7a.metal-48xl.json | 60 +++++++++++++++++++ .../results/20260726/c8g.4xlarge.json | 60 +++++++++++++++++++ .../results/20260726/c8g.metal-48xl.json | 60 +++++++++++++++++++ .../results/20260726/c6a.2xlarge.json | 60 +++++++++++++++++++ .../results/20260726/c6a.4xlarge.json | 60 +++++++++++++++++++ .../results/20260726/c6a.metal.json | 60 +++++++++++++++++++ .../results/20260726/c6a.xlarge.json | 60 +++++++++++++++++++ .../results/20260726/c7a.metal-48xl.json | 60 +++++++++++++++++++ .../results/20260726/c8g.4xlarge.json | 60 +++++++++++++++++++ .../results/20260726/c8g.metal-48xl.json | 60 +++++++++++++++++++ .../results/20260726/c6a.2xlarge.json | 60 +++++++++++++++++++ .../results/20260726/c6a.4xlarge.json | 60 +++++++++++++++++++ .../results/20260726/c6a.large.json | 60 +++++++++++++++++++ .../results/20260726/c6a.metal.json | 60 +++++++++++++++++++ .../results/20260726/c6a.xlarge.json | 60 +++++++++++++++++++ .../results/20260726/c7a.metal-48xl.json | 60 +++++++++++++++++++ .../results/20260726/c8g.4xlarge.json | 60 +++++++++++++++++++ .../results/20260726/c8g.metal-48xl.json | 60 +++++++++++++++++++ 36 files changed, 2160 insertions(+) create mode 100644 clickhouse-datalake-partitioned/results/20260726/c6a.2xlarge.json create mode 100644 clickhouse-datalake-partitioned/results/20260726/c6a.4xlarge.json create mode 100644 clickhouse-datalake-partitioned/results/20260726/c6a.metal.json create mode 100644 clickhouse-datalake-partitioned/results/20260726/c6a.xlarge.json create mode 100644 clickhouse-datalake-partitioned/results/20260726/c7a.metal-48xl.json create mode 100644 clickhouse-datalake-partitioned/results/20260726/c8g.4xlarge.json create mode 100644 clickhouse-datalake-partitioned/results/20260726/c8g.metal-48xl.json create mode 100644 clickhouse-datalake/results/20260726/c6a.2xlarge.json create mode 100644 clickhouse-datalake/results/20260726/c6a.4xlarge.json create mode 100644 clickhouse-datalake/results/20260726/c6a.metal.json create mode 100644 clickhouse-datalake/results/20260726/c6a.xlarge.json create mode 100644 clickhouse-datalake/results/20260726/c7a.metal-48xl.json create mode 100644 clickhouse-datalake/results/20260726/c8g.4xlarge.json create mode 100644 clickhouse-datalake/results/20260726/c8g.metal-48xl.json create mode 100644 clickhouse-web/results/20260726/c6a.2xlarge.json create mode 100644 clickhouse-web/results/20260726/c6a.4xlarge.json create mode 100644 clickhouse-web/results/20260726/c6a.metal.json create mode 100644 clickhouse-web/results/20260726/c6a.xlarge.json create mode 100644 clickhouse-web/results/20260726/c7a.metal-48xl.json create mode 100644 clickhouse-web/results/20260726/c8g.4xlarge.json create mode 100644 clickhouse-web/results/20260726/c8g.metal-48xl.json create mode 100644 duckdb-datalake-partitioned/results/20260726/c6a.2xlarge.json create mode 100644 duckdb-datalake-partitioned/results/20260726/c6a.4xlarge.json create mode 100644 duckdb-datalake-partitioned/results/20260726/c6a.metal.json create mode 100644 duckdb-datalake-partitioned/results/20260726/c6a.xlarge.json create mode 100644 duckdb-datalake-partitioned/results/20260726/c7a.metal-48xl.json create mode 100644 duckdb-datalake-partitioned/results/20260726/c8g.4xlarge.json create mode 100644 duckdb-datalake-partitioned/results/20260726/c8g.metal-48xl.json create mode 100644 duckdb-datalake/results/20260726/c6a.2xlarge.json create mode 100644 duckdb-datalake/results/20260726/c6a.4xlarge.json create mode 100644 duckdb-datalake/results/20260726/c6a.large.json create mode 100644 duckdb-datalake/results/20260726/c6a.metal.json create mode 100644 duckdb-datalake/results/20260726/c6a.xlarge.json create mode 100644 duckdb-datalake/results/20260726/c7a.metal-48xl.json create mode 100644 duckdb-datalake/results/20260726/c8g.4xlarge.json create mode 100644 duckdb-datalake/results/20260726/c8g.metal-48xl.json diff --git a/clickhouse-datalake-partitioned/results/20260726/c6a.2xlarge.json b/clickhouse-datalake-partitioned/results/20260726/c6a.2xlarge.json new file mode 100644 index 0000000000..c1cd2e12f9 --- /dev/null +++ b/clickhouse-datalake-partitioned/results/20260726/c6a.2xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "ClickHouse (data lake, partitioned)", + "date": "2026-07-26", + "machine": "c6a.2xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","embedded","stateless","ClickHouse derivative"], + "load_time": 2, + "data_size": 14737666736, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.665, 0.048, 0.044], + [2.233, 0.074, 0.07], + [2.646, 1.435, 0.137], + [4.758, 0.466, 0.123], + [2.644, 0.917, 0.634], + [3.12, 1.561, 1.231], + [2.951, 0.071, 0.073], + [1.84, 0.076, 0.072], + [2.976, 1.325, 0.769], + [4.03, 4.614, 3.86], + [3.662, 3.467, 3.167], + [3.593, 3.402, 3.455], + [2.831, 1.189, 0.818], + [4.322, 4.326, 4.45], + [2.946, 1.413, 1.017], + [2.743, 1.065, 0.815], + [5.042, 6.638, 4.924], + [4.189, 3.958, 4.292], + [8.217, 8.651, 8.808], + [1.901, 0.116, 0.11], + [6.587, 5.849, 5.97], + [7.454, 7.797, 7.589], + [12.507, 11.34, 11.163], + [21.518, 22.245, 22.156], + [4.689, 4.258, 3.986], + [2.392, 0.761, 0.304], + [4.182, 4.158, 4.157], + [6.814, 6.931, 6.52], + [6.172, 6.298, 6.341], + [2.08, 0.106, 0.111], + [4.904, 4.69, 4.759], + [6.359, 6.602, 6.537], + [15.205, 14.485, 13.874], + [8.195, 10.888, 10.546], + [8.078, 10.765, 10.7], + [2.366, 0.59, 0.577], + [0.85, 0.127, 0.136], + [0.772, 0.133, 0.089], + [0.835, 0.084, 0.076], + [1.057, 0.236, 0.253], + [0.845, 0.063, 0.062], + [0.764, 0.067, 0.07], + [0.718, 0.048, 0.05] +] + } + \ No newline at end of file diff --git a/clickhouse-datalake-partitioned/results/20260726/c6a.4xlarge.json b/clickhouse-datalake-partitioned/results/20260726/c6a.4xlarge.json new file mode 100644 index 0000000000..2d133017d8 --- /dev/null +++ b/clickhouse-datalake-partitioned/results/20260726/c6a.4xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "ClickHouse (data lake, partitioned)", + "date": "2026-07-26", + "machine": "c6a.4xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","embedded","stateless","ClickHouse derivative"], + "load_time": 2, + "data_size": 14737666736, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.364, 0.044, 0.039], + [1.166, 0.065, 0.06], + [1.686, 0.106, 0.104], + [1.468, 0.112, 0.11], + [1.568, 0.379, 0.378], + [1.723, 0.721, 0.734], + [1.391, 0.112, 0.064], + [1.233, 0.064, 0.062], + [1.851, 0.559, 0.556], + [3.165, 0.832, 0.683], + [2.286, 0.212, 0.224], + [2.344, 0.236, 0.236], + [1.733, 0.661, 0.632], + [2.885, 0.955, 0.949], + [1.814, 0.746, 0.764], + [1.677, 0.528, 0.531], + [3.293, 2.105, 1.84], + [2.683, 1.272, 1.247], + [5.313, 4.18, 3.618], + [1.335, 0.103, 0.104], + [6.387, 1.673, 1.124], + [5.876, 4.216, 2.775], + [9.477, 6.29, 5.607], + [13.425, 9.92, 10.125], + [2.665, 0.556, 0.382], + [1.555, 0.267, 0.269], + [2.644, 0.509, 0.38], + [4.36, 2.547, 1.913], + [3.867, 2.519, 2.469], + [1.42, 0.085, 0.092], + [2.941, 0.859, 0.662], + [4.276, 3.952, 4.702], + [6.412, 5.417, 4.54], + [5.214, 3.624, 3.026], + [4.831, 3.564, 2.99], + [1.503, 0.383, 0.376], + [0.671, 0.134, 0.132], + [0.629, 0.086, 0.095], + [0.649, 0.081, 0.072], + [0.846, 0.228, 0.234], + [0.578, 0.064, 0.068], + [0.581, 0.062, 0.076], + [0.58, 0.049, 0.053] +] + } + \ No newline at end of file diff --git a/clickhouse-datalake-partitioned/results/20260726/c6a.metal.json b/clickhouse-datalake-partitioned/results/20260726/c6a.metal.json new file mode 100644 index 0000000000..3e80d5b931 --- /dev/null +++ b/clickhouse-datalake-partitioned/results/20260726/c6a.metal.json @@ -0,0 +1,60 @@ +{ + "system": "ClickHouse (data lake, partitioned)", + "date": "2026-07-26", + "machine": "c6a.metal", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","embedded","stateless","ClickHouse derivative"], + "load_time": 2, + "data_size": 14737666736, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.298, 0.073, 0.073], + [0.528, 0.121, 0.116], + [0.924, 0.159, 0.138], + [0.675, 0.158, 0.153], + [0.777, 0.222, 0.218], + [0.81, 0.264, 0.245], + [0.524, 0.121, 0.117], + [0.544, 0.114, 0.129], + [0.92, 0.435, 0.456], + [1.315, 0.501, 0.499], + [1.293, 0.499, 0.51], + [1.322, 0.247, 0.246], + [1.199, 0.282, 0.309], + [1.231, 0.369, 0.391], + [0.96, 0.315, 0.292], + [1.06, 0.247, 0.253], + [1.364, 0.552, 0.643], + [1.219, 0.483, 0.471], + [1.848, 0.908, 0.939], + [0.549, 0.154, 0.13], + [2.111, 0.493, 0.483], + [2.356, 0.482, 0.478], + [3.039, 1.074, 0.614], + [6.929, 1.2, 1.204], + [0.984, 0.226, 0.227], + [0.691, 0.173, 0.202], + [1.024, 0.241, 0.234], + [2.478, 0.569, 0.566], + [1.98, 0.612, 0.631], + [0.722, 0.142, 0.141], + [1.254, 0.325, 0.318], + [1.746, 0.417, 0.445], + [2.328, 1.469, 1.573], + [2.608, 0.856, 0.881], + [2.101, 0.932, 0.964], + [0.726, 0.222, 0.175], + [0.675, 0.159, 0.187], + [0.505, 0.109, 0.116], + [0.629, 0.117, 0.119], + [0.826, 0.252, 0.208], + [0.574, 0.102, 0.121], + [0.58, 0.11, 0.111], + [0.485, 0.094, 0.093] +] + } + \ No newline at end of file diff --git a/clickhouse-datalake-partitioned/results/20260726/c6a.xlarge.json b/clickhouse-datalake-partitioned/results/20260726/c6a.xlarge.json new file mode 100644 index 0000000000..0fffd82c88 --- /dev/null +++ b/clickhouse-datalake-partitioned/results/20260726/c6a.xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "ClickHouse (data lake, partitioned)", + "date": "2026-07-26", + "machine": "c6a.xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","embedded","stateless","ClickHouse derivative"], + "load_time": 0, + "data_size": 14737666736, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.993, 0.054, 0.06], + [3.592, 2.977, 3.018], + [9.132, 4.951, 4.913], + [9.163, 4.375, 4.787], + [4.724, 6.1, 5.255], + [5.719, 5.367, 5.501], + [4.119, 3.788, 3.821], + [3.525, 3.291, 2.69], + [5.382, 4.744, 4.988], + [7.328, 6.715, 6.292], + [6.502, 6.541, 6.764], + [7.766, 6.673, 6.829], + [5.518, 5.115, 4.959], + [8.526, 8.486, 9.186], + [5.724, 5.357, 5.168], + [6.142, 5.034, 4.856], + [10.299, 10.09, 10.219], + [8.889, 8.76, 8.718], + [15.228, 15.743, 16.006], + [3.481, 3.27, 3.526], + [11.274, 11.029, 11.018], + [14.998, 18.292, 14.866], + [25.27, 22.617, 23.285], + [45.121, 42.398, 43.825], + [8.122, 8.439, 8.231], + [5.297, 4.455, 4.501], + [8.453, 8.127, 8.062], + [12.692, 12.598, 12.876], + [12.297, 11.621, 11.072], + [3.816, 3.804, 3.696], + [9.395, 9.782, 9.87], + [12.924, 13.009, 12.059], + [23.042, 23.17, 22.824], + [19.146, 19.148, 18.627], + [19.862, 19.279, 19.301], + [4.66, 4.215, 4.404], + [1.468, 0.164, 0.17], + [1.285, 0.098, 0.098], + [1.439, 0.088, 0.118], + [2.031, 0.271, 0.278], + [1.4, 0.088, 0.075], + [1.243, 0.073, 0.091], + [1.184, 0.063, 0.064] +] + } + \ No newline at end of file diff --git a/clickhouse-datalake-partitioned/results/20260726/c7a.metal-48xl.json b/clickhouse-datalake-partitioned/results/20260726/c7a.metal-48xl.json new file mode 100644 index 0000000000..540456c769 --- /dev/null +++ b/clickhouse-datalake-partitioned/results/20260726/c7a.metal-48xl.json @@ -0,0 +1,60 @@ +{ + "system": "ClickHouse (data lake, partitioned)", + "date": "2026-07-26", + "machine": "c7a.metal-48xl", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","embedded","stateless","ClickHouse derivative"], + "load_time": 2, + "data_size": 14737666736, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.322, 0.089, 0.086], + [0.662, 0.134, 0.141], + [0.656, 0.153, 0.141], + [0.613, 0.154, 0.16], + [0.606, 0.206, 0.232], + [0.772, 0.253, 0.259], + [0.513, 0.129, 0.127], + [0.605, 0.133, 0.14], + [0.893, 0.405, 0.416], + [1.241, 0.516, 0.463], + [1.369, 0.473, 0.514], + [1.032, 0.263, 0.236], + [0.776, 0.281, 0.274], + [1.067, 0.338, 0.327], + [0.782, 0.278, 0.272], + [1.189, 0.238, 0.228], + [1.33, 0.505, 0.489], + [1.034, 0.474, 0.502], + [1.39, 0.92, 0.789], + [0.632, 0.138, 0.131], + [1.999, 0.538, 0.506], + [2.353, 0.51, 0.511], + [2.693, 1.132, 0.627], + [4.329, 1.487, 1.436], + [1.03, 0.218, 0.248], + [0.928, 0.221, 0.228], + [0.971, 0.248, 0.277], + [1.985, 0.581, 0.553], + [2.975, 0.496, 0.534], + [1.064, 0.17, 0.175], + [1.055, 0.327, 0.297], + [1.358, 0.43, 0.434], + [1.555, 0.881, 0.901], + [2.021, 0.782, 0.756], + [1.895, 0.768, 0.828], + [1.077, 0.184, 0.213], + [0.664, 0.143, 0.152], + [0.553, 0.152, 0.135], + [0.614, 0.12, 0.109], + [0.795, 0.214, 0.214], + [0.531, 0.102, 0.116], + [0.533, 0.116, 0.107], + [0.456, 0.091, 0.092] +] + } + \ No newline at end of file diff --git a/clickhouse-datalake-partitioned/results/20260726/c8g.4xlarge.json b/clickhouse-datalake-partitioned/results/20260726/c8g.4xlarge.json new file mode 100644 index 0000000000..f1f4e8a9f3 --- /dev/null +++ b/clickhouse-datalake-partitioned/results/20260726/c8g.4xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "ClickHouse (data lake, partitioned)", + "date": "2026-07-26", + "machine": "c8g.4xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","embedded","stateless","ClickHouse derivative"], + "load_time": 2, + "data_size": 14737666736, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.369, 0.038, 0.049], + [1.133, 0.05, 0.059], + [1.667, 0.08, 0.077], + [1.415, 0.067, 0.067], + [1.342, 0.219, 0.223], + [1.417, 0.352, 0.356], + [1.028, 0.051, 0.055], + [1.043, 0.058, 0.12], + [1.479, 0.31, 0.305], + [2.403, 0.556, 0.36], + [2.124, 0.166, 0.162], + [1.99, 0.166, 0.184], + [1.405, 0.358, 0.328], + [2.34, 0.476, 0.471], + [1.464, 0.373, 0.367], + [1.385, 0.253, 0.264], + [2.473, 0.865, 0.743], + [2.168, 0.617, 0.733], + [3.188, 1.867, 1.542], + [0.977, 0.068, 0.063], + [3.326, 1.448, 0.457], + [4.432, 4.376, 2.617], + [6.466, 5.773, 5.719], + [11.34, 9.214, 9.237], + [2.347, 0.453, 0.233], + [1.313, 0.159, 0.155], + [2.278, 0.517, 0.237], + [3.425, 2.071, 0.564], + [3.358, 1.094, 0.92], + [1.138, 0.077, 0.078], + [2.495, 0.697, 0.404], + [3.514, 3.948, 2.954], + [3.873, 2.853, 1.66], + [4.16, 1.985, 1.309], + [5.632, 1.922, 1.201], + [1.369, 0.218, 0.216], + [0.574, 0.095, 0.104], + [0.521, 0.072, 0.065], + [0.641, 0.061, 0.067], + [0.732, 0.147, 0.138], + [0.54, 0.056, 0.055], + [0.542, 0.065, 0.055], + [0.496, 0.062, 0.052] +] + } + \ No newline at end of file diff --git a/clickhouse-datalake-partitioned/results/20260726/c8g.metal-48xl.json b/clickhouse-datalake-partitioned/results/20260726/c8g.metal-48xl.json new file mode 100644 index 0000000000..08759d6310 --- /dev/null +++ b/clickhouse-datalake-partitioned/results/20260726/c8g.metal-48xl.json @@ -0,0 +1,60 @@ +{ + "system": "ClickHouse (data lake, partitioned)", + "date": "2026-07-26", + "machine": "c8g.metal-48xl", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","embedded","stateless","ClickHouse derivative"], + "load_time": 2, + "data_size": 14737666736, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.423, 0.059, 0.063], + [0.407, 0.1, 0.097], + [0.899, 0.116, 0.122], + [0.607, 0.108, 0.105], + [0.494, 0.16, 0.146], + [0.811, 0.197, 0.181], + [0.441, 0.09, 0.104], + [0.418, 0.104, 0.099], + [1.137, 0.305, 0.317], + [1.183, 0.355, 0.36], + [0.942, 0.281, 0.299], + [0.953, 0.219, 0.177], + [0.608, 0.197, 0.213], + [0.961, 0.339, 0.267], + [0.867, 0.225, 0.223], + [0.637, 0.191, 0.186], + [1.095, 0.347, 0.362], + [0.923, 0.308, 0.345], + [1.174, 0.686, 0.665], + [0.644, 0.115, 0.111], + [1.696, 0.345, 0.345], + [2.068, 0.37, 0.399], + [2.548, 0.877, 0.485], + [4.269, 1.398, 1.178], + [0.98, 0.191, 0.187], + [0.834, 0.139, 0.153], + [1.052, 0.195, 0.181], + [1.711, 0.438, 0.463], + [1.406, 0.451, 0.423], + [0.552, 0.16, 0.153], + [0.955, 0.258, 0.218], + [1.226, 0.347, 0.311], + [1.577, 0.875, 0.87], + [1.938, 0.639, 0.597], + [1.926, 0.618, 0.624], + [0.558, 0.176, 0.17], + [0.569, 0.131, 0.144], + [0.43, 0.106, 0.109], + [0.531, 0.117, 0.11], + [0.683, 0.164, 0.16], + [0.481, 0.101, 0.088], + [0.46, 0.088, 0.103], + [0.456, 0.093, 0.089] +] + } + \ No newline at end of file diff --git a/clickhouse-datalake/results/20260726/c6a.2xlarge.json b/clickhouse-datalake/results/20260726/c6a.2xlarge.json new file mode 100644 index 0000000000..a778d0566e --- /dev/null +++ b/clickhouse-datalake/results/20260726/c6a.2xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "ClickHouse (data lake, single)", + "date": "2026-07-26", + "machine": "c6a.2xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","embedded","stateless","ClickHouse derivative"], + "load_time": 2, + "data_size": 14779976446, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.359, 0.166, 0.167], + [1.48, 0.1, 0.113], + [2.978, 0.211, 0.22], + [2.306, 0.195, 0.193], + [2.494, 0.667, 0.677], + [4.965, 1.248, 1.263], + [2.027, 0.147, 0.116], + [1.419, 0.116, 0.096], + [5.477, 0.767, 0.785], + [9.063, 8.659, 8.583], + [3.497, 2.65, 0.364], + [3.372, 2.303, 0.429], + [2.987, 0.905, 0.937], + [4.16, 3.741, 3.674], + [2.789, 1.141, 1.141], + [2.57, 0.852, 0.804], + [7.399, 6.764, 5.394], + [6.637, 5.641, 3.828], + [12.538, 12.408, 12.062], + [1.79, 0.179, 0.163], + [8.914, 8.643, 9.158], + [9.035, 8.322, 8.109], + [13.017, 11.929, 11.337], + [29.995, 28.504, 29.03], + [3.84, 3.636, 3.27], + [2.461, 0.498, 0.497], + [4.281, 3.47, 3.118], + [10.494, 11.536, 10.408], + [7.304, 7.834, 7.294], + [1.665, 0.16, 0.159], + [4.894, 4.834, 4.633], + [8.255, 7.184, 7.244], + [18.962, 18.183, 18.972], + [11.009, 10.269, 10.13], + [10.611, 10.45, 10.805], + [2.134, 0.497, 0.516], + [0.818, 0.208, 0.199], + [0.715, 0.127, 0.139], + [0.757, 0.114, 0.118], + [1.048, 0.208, 0.209], + [0.579, 0.097, 0.103], + [0.718, 0.101, 0.101], + [0.602, 0.091, 0.089] +] + } + \ No newline at end of file diff --git a/clickhouse-datalake/results/20260726/c6a.4xlarge.json b/clickhouse-datalake/results/20260726/c6a.4xlarge.json new file mode 100644 index 0000000000..950b7609ab --- /dev/null +++ b/clickhouse-datalake/results/20260726/c6a.4xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "ClickHouse (data lake, single)", + "date": "2026-07-26", + "machine": "c6a.4xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","embedded","stateless","ClickHouse derivative"], + "load_time": 2, + "data_size": 14779976446, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.333, 0.15, 0.154], + [1.138, 0.102, 0.098], + [2.371, 0.156, 0.169], + [1.398, 0.14, 0.131], + [1.373, 0.459, 0.412], + [1.833, 0.7, 0.726], + [1.172, 0.103, 0.098], + [1.211, 0.109, 0.103], + [2.647, 0.603, 0.568], + [6.762, 0.679, 0.668], + [2.422, 0.273, 0.277], + [2.227, 0.312, 0.309], + [2.061, 0.663, 0.635], + [2.683, 0.958, 0.948], + [1.805, 0.762, 0.754], + [1.706, 0.565, 0.55], + [3.586, 1.809, 1.806], + [2.992, 1.217, 1.217], + [6.212, 3.554, 3.579], + [1.221, 0.138, 0.139], + [4.461, 1.501, 1.116], + [5.362, 4.089, 1.252], + [7.97, 7.002, 6.214], + [21.9, 17.51, 20.717], + [2.629, 0.543, 0.498], + [1.662, 0.296, 0.296], + [2.797, 0.499, 0.492], + [5.29, 3.18, 1.804], + [4.434, 2.425, 2.453], + [1.13, 0.119, 0.122], + [3.227, 0.832, 0.828], + [4.656, 3.931, 1.172], + [8.955, 5.598, 4.545], + [6.81, 3.345, 2.98], + [5.861, 3.527, 3.016], + [1.526, 0.408, 0.399], + [0.74, 0.184, 0.177], + [0.589, 0.114, 0.119], + [0.694, 0.107, 0.119], + [0.849, 0.175, 0.181], + [0.55, 0.107, 0.107], + [0.576, 0.088, 0.088], + [0.522, 0.095, 0.08] +] + } + \ No newline at end of file diff --git a/clickhouse-datalake/results/20260726/c6a.metal.json b/clickhouse-datalake/results/20260726/c6a.metal.json new file mode 100644 index 0000000000..fc124f5f6d --- /dev/null +++ b/clickhouse-datalake/results/20260726/c6a.metal.json @@ -0,0 +1,60 @@ +{ + "system": "ClickHouse (data lake, single)", + "date": "2026-07-26", + "machine": "c6a.metal", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","embedded","stateless","ClickHouse derivative"], + "load_time": 2, + "data_size": 14779976446, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.313, 0.15, 0.149], + [0.723, 0.118, 0.124], + [0.719, 0.147, 0.15], + [1.012, 0.154, 0.164], + [0.742, 0.208, 0.209], + [1.108, 0.241, 0.247], + [0.533, 0.107, 0.1], + [0.593, 0.122, 0.104], + [1.047, 0.462, 0.456], + [1.378, 0.531, 0.483], + [0.892, 0.257, 0.243], + [1.193, 0.236, 0.235], + [0.86, 0.303, 0.362], + [1.204, 0.342, 0.355], + [0.876, 0.292, 0.278], + [0.706, 0.235, 0.253], + [1.333, 0.475, 0.462], + [1.418, 0.362, 0.385], + [1.7, 1.006, 0.994], + [0.59, 0.128, 0.129], + [2.01, 0.575, 0.619], + [2.477, 1.182, 1.225], + [4.859, 1.873, 1.298], + [23.185, 7.065, 5.802], + [1.026, 0.231, 0.219], + [0.885, 0.197, 0.191], + [1.09, 0.211, 0.22], + [3.302, 1.483, 1.196], + [2.093, 0.613, 0.612], + [0.673, 0.149, 0.152], + [1.25, 0.303, 0.32], + [1.817, 0.417, 0.414], + [2.352, 1.257, 1.255], + [2.564, 0.911, 0.902], + [2.475, 0.958, 0.982], + [0.849, 0.214, 0.204], + [0.79, 0.182, 0.185], + [0.593, 0.135, 0.142], + [0.689, 0.118, 0.128], + [0.816, 0.19, 0.196], + [0.602, 0.118, 0.12], + [0.683, 0.122, 0.099], + [0.521, 0.097, 0.112] +] + } + \ No newline at end of file diff --git a/clickhouse-datalake/results/20260726/c6a.xlarge.json b/clickhouse-datalake/results/20260726/c6a.xlarge.json new file mode 100644 index 0000000000..049c2c4f59 --- /dev/null +++ b/clickhouse-datalake/results/20260726/c6a.xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "ClickHouse (data lake, single)", + "date": "2026-07-26", + "machine": "c6a.xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","embedded","stateless","ClickHouse derivative"], + "load_time": 1, + "data_size": 14779976446, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.363, 0.157, 0.153], + [2.409, 0.544, 0.14], + [3.752, 3.317, 3.21], + [15.055, 7.413, 2.157], + [8.853, 7.912, 3.036], + [10.81, 10.137, 8.691], + [2.003, 0.79, 0.142], + [2.029, 0.528, 0.146], + [9.786, 9.31, 5.676], + [11.247, 11.28, 10.984], + [5.44, 5.419, 5.224], + [5.079, 4.954, 5.073], + [9.421, 8.453, 7.555], + [7.823, 7.282, 7.017], + [4.289, 3.919, 3.223], + [8.445, 7.326, 2.833], + [14.015, 13.776, 13.063], + [13.339, 11.526, 10.856], + [26.305, 21.336, 22.858], + [7.425, 3.937, 0.276], + [25.065, 25.437, 26.451], + [27.822, 24.786, 26.866], + [33.586, 31.74, 29.457], + [67.131, 51.458, 53.572], + [7.21, 6.69, 6.377], + [8.326, 8.564, 7.269], + [7.457, 6.526, 6.295], + [14.431, 14.253, 13.833], + [24.143, 25.376, 26.345], + [2.655, 1.361, 0.216], + [8.041, 8.631, 7.8], + [13.068, 11.768, 11.979], + [27.855, 28.246, 27.431], + [35.017, 35.038, 33.896], + [33.902, 34.535, 34.67], + [3.24, 2.932, 0.878], + [1.202, 0.213, 0.218], + [0.889, 0.163, 0.148], + [1.106, 0.138, 0.138], + [1.42, 0.287, 0.293], + [0.821, 0.128, 0.122], + [0.905, 0.108, 0.1], + [0.751, 0.089, 0.12] +] + } + \ No newline at end of file diff --git a/clickhouse-datalake/results/20260726/c7a.metal-48xl.json b/clickhouse-datalake/results/20260726/c7a.metal-48xl.json new file mode 100644 index 0000000000..e88dfff78e --- /dev/null +++ b/clickhouse-datalake/results/20260726/c7a.metal-48xl.json @@ -0,0 +1,60 @@ +{ + "system": "ClickHouse (data lake, single)", + "date": "2026-07-26", + "machine": "c7a.metal-48xl", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","embedded","stateless","ClickHouse derivative"], + "load_time": 2, + "data_size": 14779976446, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.376, 0.153, 0.154], + [0.997, 0.103, 0.103], + [0.71, 0.141, 0.147], + [0.54, 0.162, 0.164], + [1.036, 0.216, 0.218], + [0.782, 0.261, 0.267], + [0.985, 0.111, 0.109], + [0.53, 0.151, 0.149], + [0.968, 0.432, 0.431], + [1.166, 0.431, 0.502], + [1.024, 0.561, 0.497], + [1.078, 0.247, 0.449], + [1.123, 0.321, 0.299], + [1.013, 0.384, 0.385], + [1.076, 0.286, 0.262], + [0.719, 0.237, 0.23], + [1.021, 0.419, 0.409], + [0.989, 0.415, 0.408], + [1.412, 0.577, 0.61], + [1.008, 0.135, 0.143], + [1.951, 0.506, 0.538], + [2.377, 1.385, 1.317], + [4.831, 2.138, 1.735], + [20.322, 10.197, 8.498], + [0.933, 0.247, 0.328], + [0.664, 0.206, 0.226], + [1.203, 0.228, 0.233], + [2.792, 1.192, 1.076], + [1.553, 0.523, 0.521], + [0.556, 0.157, 0.156], + [1.115, 0.446, 0.314], + [1.6, 0.557, 0.698], + [1.724, 0.84, 0.843], + [2.034, 2.775, 1.065], + [1.978, 0.776, 0.744], + [0.804, 0.206, 0.196], + [0.727, 0.195, 0.198], + [0.601, 0.168, 0.16], + [0.708, 0.143, 0.152], + [0.848, 0.189, 0.193], + [0.571, 0.135, 0.139], + [0.578, 0.14, 0.137], + [0.602, 0.139, 0.123] +] + } + \ No newline at end of file diff --git a/clickhouse-datalake/results/20260726/c8g.4xlarge.json b/clickhouse-datalake/results/20260726/c8g.4xlarge.json new file mode 100644 index 0000000000..951598e375 --- /dev/null +++ b/clickhouse-datalake/results/20260726/c8g.4xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "ClickHouse (data lake, single)", + "date": "2026-07-26", + "machine": "c8g.4xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","embedded","stateless","ClickHouse derivative"], + "load_time": 2, + "data_size": 14779976446, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.245, 0.091, 0.1], + [1.04, 0.087, 0.08], + [1.967, 0.14, 0.134], + [1.1, 0.101, 0.101], + [1.606, 0.23, 0.252], + [1.363, 0.374, 0.368], + [1.297, 0.091, 0.082], + [1.606, 0.087, 0.088], + [2.244, 0.311, 0.328], + [5.748, 0.403, 0.385], + [2.253, 0.223, 0.217], + [3.791, 0.25, 0.236], + [1.507, 0.356, 0.354], + [2.28, 0.492, 0.516], + [1.368, 0.431, 0.429], + [1.216, 0.263, 0.286], + [2.578, 0.729, 0.746], + [2.334, 0.544, 0.536], + [3.66, 1.347, 1.34], + [1.072, 0.101, 0.093], + [4.33, 1.155, 0.656], + [5.012, 3.775, 0.888], + [7.168, 10.998, 6.006], + [20.589, 16.556, 16.651], + [2.874, 0.368, 0.367], + [1.333, 0.229, 0.236], + [2.234, 0.383, 0.359], + [4.77, 2.99, 0.827], + [3.183, 0.91, 0.91], + [0.923, 0.116, 0.111], + [2.8, 0.554, 0.547], + [3.769, 2.917, 0.655], + [7.445, 3.557, 1.587], + [4.44, 1.578, 1.248], + [4.494, 1.686, 1.286], + [1.101, 0.231, 0.225], + [0.604, 0.14, 0.127], + [0.498, 0.092, 0.096], + [0.554, 0.097, 0.093], + [0.681, 0.127, 0.119], + [0.453, 0.095, 0.093], + [0.468, 0.078, 0.088], + [0.408, 0.081, 0.068] +] + } + \ No newline at end of file diff --git a/clickhouse-datalake/results/20260726/c8g.metal-48xl.json b/clickhouse-datalake/results/20260726/c8g.metal-48xl.json new file mode 100644 index 0000000000..c8bb907089 --- /dev/null +++ b/clickhouse-datalake/results/20260726/c8g.metal-48xl.json @@ -0,0 +1,60 @@ +{ + "system": "ClickHouse (data lake, single)", + "date": "2026-07-26", + "machine": "c8g.metal-48xl", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","embedded","stateless","ClickHouse derivative"], + "load_time": 2, + "data_size": 14779976446, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.277, 0.098, 0.112], + [0.471, 0.083, 0.097], + [0.719, 0.111, 0.118], + [0.629, 0.14, 0.125], + [0.928, 0.162, 0.146], + [0.984, 0.184, 0.175], + [0.502, 0.095, 0.091], + [0.719, 0.136, 0.115], + [0.82, 0.337, 0.312], + [1.165, 0.352, 0.339], + [0.93, 0.355, 0.331], + [0.931, 0.295, 0.286], + [0.721, 0.225, 0.294], + [0.948, 0.323, 0.281], + [0.597, 0.221, 0.206], + [0.586, 0.185, 0.181], + [0.833, 0.32, 0.363], + [0.866, 0.335, 0.323], + [1.293, 0.493, 0.524], + [0.73, 0.112, 0.099], + [1.768, 0.528, 0.305], + [2.537, 1.142, 1.052], + [4.783, 1.945, 1.727], + [16.985, 5.886, 4.576], + [0.866, 0.254, 0.226], + [0.709, 0.148, 0.148], + [0.921, 0.194, 0.187], + [2.513, 1.056, 0.868], + [1.324, 0.432, 1.804], + [1.057, 0.154, 0.141], + [0.979, 0.26, 0.228], + [1.462, 0.451, 0.407], + [1.439, 0.796, 0.817], + [1.875, 0.627, 0.999], + [1.838, 0.627, 1.175], + [0.624, 0.153, 0.202], + [0.689, 0.153, 0.163], + [0.528, 0.138, 0.151], + [0.636, 0.149, 0.138], + [0.743, 0.149, 0.141], + [0.548, 0.144, 0.144], + [0.547, 0.126, 0.121], + [0.485, 0.117, 0.113] +] + } + \ No newline at end of file diff --git a/clickhouse-web/results/20260726/c6a.2xlarge.json b/clickhouse-web/results/20260726/c6a.2xlarge.json new file mode 100644 index 0000000000..c4867a5058 --- /dev/null +++ b/clickhouse-web/results/20260726/c6a.2xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "ClickHouse (web)", + "date": "2026-07-26", + "machine": "c6a.2xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","ClickHouse derivative","stateless"], + "load_time": 1, + "data_size": 14557009492, + "concurrent_qps": 0.72, + "concurrent_error_ratio": 0.597, + "result": [ + [0.002, 0.001, 0.001], + [0.128, 0.14, 0.071], + [0.277, 0.24, 0.228], + [0.438, 0.391, 0.326], + [0.883, 0.693, 0.703], + [1.739, 1.535, 1.575], + [0.078, 0.047, 0.043], + [0.134, 0.087, 0.079], + [1.082, 0.972, 0.946], + [1.325, 1.164, 1.103], + [1.088, 1.261, 1.27], + [2.89, 1.444, 1.404], + [1.302, 1.147, 1.136], + [2.209, 1.978, 2.018], + [1.729, 1.663, 1.943], + [0.996, 0.713, 0.695], + [3.405, 3.143, 3.226], + [2.603, 2.157, 2.48], + [7.897, 7.102, 7.381], + [1.086, 0.206, 0.168], + [7.944, 7.464, 7.306], + [7.948, 2.959, 2.75], + [8.346, 6.761, 6.325], + [4.531, 2.673, 2.593], + [1.406, 1.219, 1.227], + [0.836, 0.863, 0.763], + [1.084, 1.128, 1.225], + [7.241, 7.328, 7.067], + [5.887, 5.703, 5.518], + [0.28, 0.301, 0.406], + [2.206, 2.128, 1.972], + [3.962, 4.046, 3.968], + [12.094, 12.53, 12.109], + [9.769, 9.751, 9.842], + [10.029, 16.464, 9.709], + [0.764, 0.59, 0.591], + [0.388, 0.391, 0.225], + [0.298, 0.131, 0.109], + [0.416, 0.241, 0.207], + [0.545, 0.355, 0.308], + [0.307, 0.174, 0.137], + [0.231, 0.117, 0.126], + [0.262, 0.225, 0.114] +] + } + \ No newline at end of file diff --git a/clickhouse-web/results/20260726/c6a.4xlarge.json b/clickhouse-web/results/20260726/c6a.4xlarge.json new file mode 100644 index 0000000000..0d656dfec1 --- /dev/null +++ b/clickhouse-web/results/20260726/c6a.4xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "ClickHouse (web)", + "date": "2026-07-26", + "machine": "c6a.4xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","ClickHouse derivative","stateless"], + "load_time": 1, + "data_size": 14557009492, + "concurrent_qps": 1.1280000000000001, + "concurrent_error_ratio": 0.027, + "result": [ + [0.002, 0.001, 0.001], + [0.138, 0.042, 0.083], + [0.355, 0.199, 0.182], + [0.32, 0.269, 0.263], + [0.54, 0.475, 0.442], + [1.187, 0.889, 0.869], + [0.067, 0.034, 0.042], + [0.122, 0.09, 0.084], + [0.816, 0.69, 0.675], + [0.963, 0.781, 0.752], + [0.652, 0.608, 0.658], + [0.588, 0.597, 0.606], + [0.904, 0.798, 0.76], + [1.391, 1.283, 1.241], + [1.136, 1.279, 1.056], + [0.738, 0.549, 0.561], + [2.328, 2.395, 2.07], + [1.655, 1.5, 1.455], + [3.931, 3.479, 3.55], + [0.675, 0.469, 0.413], + [6.639, 4.05, 3.82], + [4.602, 1.95, 1.814], + [7.708, 4.827, 4.335], + [5.368, 2.259, 2.162], + [0.654, 0.592, 0.583], + [0.663, 1.145, 0.515], + [0.622, 1.452, 0.542], + [3.891, 3.84, 3.714], + [3.813, 3.515, 3.692], + [0.223, 0.19, 0.161], + [1.257, 1.191, 1.201], + [2.964, 2.655, 2.605], + [4.971, 4.875, 4.788], + [5.264, 5.209, 5.311], + [5.241, 5.318, 5.283], + [0.531, 0.46, 0.501], + [0.364, 0.163, 0.14], + [0.24, 0.134, 0.124], + [0.574, 0.198, 0.154], + [0.487, 0.207, 0.282], + [0.288, 0.136, 0.109], + [0.212, 0.094, 0.112], + [0.236, 0.134, 0.15] +] + } + \ No newline at end of file diff --git a/clickhouse-web/results/20260726/c6a.metal.json b/clickhouse-web/results/20260726/c6a.metal.json new file mode 100644 index 0000000000..0c8da71d8a --- /dev/null +++ b/clickhouse-web/results/20260726/c6a.metal.json @@ -0,0 +1,60 @@ +{ + "system": "ClickHouse (web)", + "date": "2026-07-26", + "machine": "c6a.metal", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","ClickHouse derivative","stateless"], + "load_time": 1, + "data_size": 14557009492, + "concurrent_qps": 5.788, + "concurrent_error_ratio": 0, + "result": [ + [0.001, 0.001, 0.001], + [0.113, 0.074, 0.079], + [0.428, 0.221, 0.244], + [0.246, 0.224, 0.208], + [0.313, 0.258, 0.252], + [0.59, 0.511, 0.553], + [0.084, 0.049, 0.045], + [0.14, 0.085, 0.091], + [0.557, 0.495, 0.499], + [0.818, 0.604, 0.533], + [0.652, 0.658, 0.765], + [0.683, 0.579, 0.787], + [0.644, 0.869, 0.549], + [0.691, 0.626, 0.602], + [0.663, 0.554, 0.56], + [0.284, 0.242, 0.248], + [0.827, 0.644, 0.637], + [0.658, 0.83, 0.465], + [1.039, 1.513, 0.903], + [0.579, 0.347, 0.418], + [1.166, 1.306, 1.491], + [1.349, 1.597, 1.425], + [1.251, 1.98, 1.753], + [5.716, 1.04, 1.079], + [0.359, 0.306, 0.274], + [0.54, 0.491, 0.893], + [0.299, 0.41, 0.293], + [1.087, 1.131, 1.119], + [6.384, 1.235, 1.322], + [0.249, 0.175, 0.197], + [1.009, 0.83, 0.652], + [0.99, 0.906, 0.823], + [1.589, 1.506, 1.685], + [1.737, 1.992, 1.676], + [1.882, 1.635, 2.245], + [0.295, 0.249, 0.215], + [0.286, 0.252, 0.196], + [0.171, 0.238, 0.235], + [0.362, 0.2, 0.132], + [0.6, 0.292, 0.267], + [0.277, 0.102, 0.097], + [0.229, 0.141, 0.124], + [0.221, 0.13, 0.121] +] + } + \ No newline at end of file diff --git a/clickhouse-web/results/20260726/c6a.xlarge.json b/clickhouse-web/results/20260726/c6a.xlarge.json new file mode 100644 index 0000000000..a47a0d1283 --- /dev/null +++ b/clickhouse-web/results/20260726/c6a.xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "ClickHouse (web)", + "date": "2026-07-26", + "machine": "c6a.xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","ClickHouse derivative","stateless"], + "load_time": 0, + "data_size": 14557009492, + "concurrent_qps": 0.44, + "concurrent_error_ratio": 0.831, + "result": [ + [0.002, 0.001, 0.001], + [0.114, 0.118, 0.086], + [0.323, 0.286, 0.279], + [0.618, 0.529, 0.548], + [1.334, 1.345, 1.219], + [3.018, 2.736, 2.873], + [0.148, 0.06, 0.061], + [0.17, 0.128, 0.095], + [1.85, 1.688, 1.616], + [2.353, 2.149, 2.259], + [2.159, 2.437, 2.023], + [2.397, 2.558, 2.422], + [2.067, 1.994, 1.745], + [4.07, 3.764, 3.701], + [3.36, 2.908, 2.863], + [1.511, 1.33, 1.361], + [8.32, 8.066, 7.984], + [6.352, 6.481, 6.252], + [13.095, 12.86, 13.345], + [1.003, 0.147, 0.144], + [13.365, 12.964, 12.735], + [15.883, 4.456, 4.372], + [17.48, 12.976, 12.712], + [5.614, 3.593, 3.305], + [1.569, 1.52, 1.426], + [1.374, 1.299, 1.301], + [1.678, 1.471, 1.412], + [13.941, 13.591, 13.637], + [12.243, 12.005, 11.552], + [0.265, 0.247, 0.226], + [3.646, 3.58, 3.398], + [7.883, 8.143, 7.802], + [20.935, 21.496, 21.603], + [23.067, 22.778, 23.424], + [23.462, 23.555, 22.628], + [1.092, 1.028, 0.864], + [0.341, 0.285, 0.321], + [0.274, 0.126, 0.158], + [0.448, 0.285, 0.281], + [0.503, 0.328, 0.328], + [0.228, 0.206, 0.135], + [0.203, 0.123, 0.083], + [0.218, 0.119, 0.121] +] + } + \ No newline at end of file diff --git a/clickhouse-web/results/20260726/c7a.metal-48xl.json b/clickhouse-web/results/20260726/c7a.metal-48xl.json new file mode 100644 index 0000000000..929c2237c9 --- /dev/null +++ b/clickhouse-web/results/20260726/c7a.metal-48xl.json @@ -0,0 +1,60 @@ +{ + "system": "ClickHouse (web)", + "date": "2026-07-26", + "machine": "c7a.metal-48xl", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","ClickHouse derivative","stateless"], + "load_time": 1, + "data_size": 14557009492, + "concurrent_qps": 7.515, + "concurrent_error_ratio": 0, + "result": [ + [0.001, 0.001, 0.001], + [0.143, 0.062, 0.091], + [0.261, 0.179, 0.168], + [0.243, 0.183, 0.181], + [0.292, 0.265, 0.218], + [0.38, 0.311, 0.472], + [0.113, 0.04, 0.042], + [0.17, 0.105, 0.076], + [0.703, 0.467, 0.485], + [0.604, 0.515, 0.682], + [1.053, 1, 1.122], + [0.87, 0.73, 0.49], + [0.397, 0.348, 0.34], + [0.49, 0.373, 0.373], + [0.415, 0.312, 0.298], + [0.312, 0.265, 0.322], + [0.548, 0.451, 0.416], + [0.521, 0.43, 0.45], + [1.619, 0.581, 0.509], + [0.559, 0.313, 0.33], + [1.339, 0.807, 0.858], + [1.54, 1.482, 1.832], + [1.398, 1.729, 1.492], + [3.225, 1.674, 1.445], + [0.263, 0.247, 0.258], + [0.664, 0.291, 0.456], + [0.4, 0.311, 0.218], + [3.725, 1.365, 1.63], + [0.819, 1.351, 1.473], + [0.316, 0.214, 0.236], + [0.533, 0.403, 0.437], + [1.521, 0.571, 0.506], + [0.91, 0.6, 0.584], + [1.622, 1.573, 1.583], + [1.406, 1.205, 1.212], + [0.256, 0.237, 0.187], + [0.33, 0.219, 0.171], + [0.155, 0.121, 0.123], + [0.317, 0.123, 0.169], + [0.382, 0.242, 0.335], + [0.25, 0.083, 0.092], + [0.187, 0.096, 0.154], + [0.238, 0.134, 0.104] +] + } + \ No newline at end of file diff --git a/clickhouse-web/results/20260726/c8g.4xlarge.json b/clickhouse-web/results/20260726/c8g.4xlarge.json new file mode 100644 index 0000000000..e08de9758d --- /dev/null +++ b/clickhouse-web/results/20260726/c8g.4xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "ClickHouse (web)", + "date": "2026-07-26", + "machine": "c8g.4xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","ClickHouse derivative","stateless"], + "load_time": 1, + "data_size": 14557009492, + "concurrent_qps": 1.968, + "concurrent_error_ratio": 0.807, + "result": [ + [0.001, 0.001, 0.001], + [0.173, 0.078, 0.131], + [0.251, 0.203, 0.188], + [0.302, 0.306, 0.254], + [0.432, 0.366, 0.341], + [0.685, 0.568, 0.575], + [0.063, 0.035, 0.035], + [0.165, 0.095, 0.058], + [0.622, 0.594, 0.556], + [0.805, 0.641, 0.682], + [0.653, 0.928, 0.847], + [0.644, 0.568, 0.598], + [0.722, 0.6, 0.569], + [1.35, 1.182, 1.189], + [0.969, 0.926, 0.822], + [0.429, 0.42, 0.37], + [1.375, 1.353, 1.338], + [1.166, 1.009, 0.938], + [2.004, 1.737, 1.729], + [0.552, 0.349, 0.365], + [3.902, 3.945, 3.966], + [4.927, 1.633, 2.405], + [5.728, 4.919, 5.311], + [4.285, 2.243, 2.069], + [0.708, 0.609, 0.606], + [0.746, 1.12, 0.474], + [0.644, 0.585, 1.185], + [4.808, 4.481, 4.711], + [3.134, 3.068, 3.185], + [0.217, 0.184, 0.193], + [1.312, 1.014, 1.09], + [2.29, 2.243, 2.207], + [2.66, 2.401, 2.466], + [6.057, 5.334, 5.261], + [5.122, 4.935, 4.854], + [0.424, 0.425, 0.375], + [0.353, 0.207, 0.184], + [0.273, 0.186, 0.153], + [0.233, 0.177, 0.179], + [0.465, 0.287, 0.254], + [0.249, 0.101, 0.18], + [0.205, 0.098, 0.088], + [0.234, 0.125, 0.357] +] + } + \ No newline at end of file diff --git a/clickhouse-web/results/20260726/c8g.metal-48xl.json b/clickhouse-web/results/20260726/c8g.metal-48xl.json new file mode 100644 index 0000000000..d199f1834e --- /dev/null +++ b/clickhouse-web/results/20260726/c8g.metal-48xl.json @@ -0,0 +1,60 @@ +{ + "system": "ClickHouse (web)", + "date": "2026-07-26", + "machine": "c8g.metal-48xl", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","ClickHouse derivative","stateless"], + "load_time": 1, + "data_size": 14557009492, + "concurrent_qps": 7.622, + "concurrent_error_ratio": 0, + "result": [ + [0.003, 0.001, 0.001], + [0.131, 0.123, 0.083], + [0.24, 0.188, 0.213], + [0.295, 0.266, 0.255], + [0.372, 0.383, 0.375], + [0.338, 0.291, 0.305], + [0.109, 0.038, 0.035], + [0.149, 0.124, 0.076], + [0.495, 0.427, 0.416], + [0.584, 0.519, 0.487], + [0.83, 0.68, 0.683], + [0.598, 1.36, 0.778], + [0.372, 0.29, 0.305], + [0.659, 0.496, 0.427], + [0.437, 0.383, 0.363], + [0.284, 0.208, 0.231], + [0.552, 0.488, 0.466], + [0.495, 0.431, 0.423], + [0.688, 0.525, 0.559], + [0.57, 0.348, 0.335], + [1.203, 0.848, 0.994], + [0.975, 1.597, 1.436], + [1.797, 1.575, 1.432], + [3.804, 1.485, 1.466], + [0.316, 0.362, 0.238], + [0.324, 0.288, 0.247], + [0.322, 0.363, 0.259], + [1.067, 1.467, 1.272], + [1.288, 1.317, 1.362], + [0.28, 0.239, 0.239], + [0.533, 0.393, 0.46], + [0.626, 0.559, 0.54], + [0.961, 0.714, 0.666], + [1.313, 1.127, 1.125], + [1.236, 1.367, 1.163], + [0.28, 0.217, 0.219], + [0.367, 0.186, 0.305], + [0.243, 0.117, 0.099], + [0.304, 0.148, 0.174], + [0.493, 0.189, 0.239], + [0.304, 0.137, 0.129], + [0.241, 0.098, 0.087], + [0.199, 0.14, 0.139] +] + } + \ No newline at end of file diff --git a/duckdb-datalake-partitioned/results/20260726/c6a.2xlarge.json b/duckdb-datalake-partitioned/results/20260726/c6a.2xlarge.json new file mode 100644 index 0000000000..46ff5c0825 --- /dev/null +++ b/duckdb-datalake-partitioned/results/20260726/c6a.2xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (data lake, partitioned)", + "date": "2026-07-26", + "machine": "c6a.2xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 2, + "data_size": 14737666736, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [1.095, 1.053, 1.444], + [2.406, 12.494, 2.725], + [4.067, 3.983, 3.642], + [2.911, 2.778, 2.912], + [3.351, 3.375, 3.789], + [3.857, 3.598, 3.794], + [2.629, 2.455, 2.632], + [2.487, 2.469, 2.287], + [3.956, 3.756, 3.73], + [5.737, 5.721, 5.925], + [3.86, 3.997, 4.08], + [5.203, 4.813, 4.869], + [3.58, 3.591, 3.596], + [5.377, 5.334, 5.329], + [4.624, 4.637, 4.897], + [3.369, 3.713, 3.956], + [5.764, 5.541, 5.883], + [5.277, 5.194, 5.229], + [8.765, 8.323, 8.066], + [2.386, 2.575, 2.69], + [7.29, 7.191, 7.21], + [8.564, 8.435, 8.348], + [14.649, 14.364, 14.31], + [25.519, 4.093, 4.184], + [2.079, 1.74, 1.688], + [3.35, 3.328, 3.27], + [1.799, 1.775, 1.663], + [7.996, 7.759, 7.886], + [20.496, 20.328, 20.442], + [2.76, 2.732, 2.724], + [8.067, 7.892, 8.275], + [8.557, 9.398, 8.664], + [9.863, 9.301, 10.206], + [9.017, 9.004, 9.026], + [9.032, 8.956, 8.993], + [3.72, 3.607, 3.837], + [1.115, 1.119, 1.138], + [1.153, 1.326, 1.164], + [1.599, 1.204, 1.051], + [1.365, 1.333, 1.277], + [1.118, 1.129, 1.293], + [1.162, 1.141, 1.249], + [1.221, 1.226, 1.118] +] + } + \ No newline at end of file diff --git a/duckdb-datalake-partitioned/results/20260726/c6a.4xlarge.json b/duckdb-datalake-partitioned/results/20260726/c6a.4xlarge.json new file mode 100644 index 0000000000..152af7e3a4 --- /dev/null +++ b/duckdb-datalake-partitioned/results/20260726/c6a.4xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (data lake, partitioned)", + "date": "2026-07-26", + "machine": "c6a.4xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 2, + "data_size": 14737666736, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.829, 0.792, 0.719], + [1.586, 1.412, 1.336], + [2.177, 2.067, 2.029], + [1.736, 1.826, 1.717], + [1.948, 1.849, 1.91], + [2.163, 2.128, 2.136], + [1.911, 1.678, 1.508], + [1.518, 1.429, 1.44], + [2.117, 2.006, 1.995], + [3.493, 3.291, 3.218], + [2.298, 2.172, 2.151], + [3.248, 3.011, 2.689], + [2.237, 2.672, 2.326], + [3.108, 3.26, 3.093], + [2.89, 2.672, 2.975], + [1.892, 2.095, 1.92], + [3.311, 3.29, 3.129], + [2.92, 2.925, 2.803], + [4.985, 5.007, 4.811], + [1.561, 1.494, 1.491], + [3.945, 3.949, 3.885], + [4.6, 4.605, 4.802], + [7.592, 7.403, 7.435], + [2.615, 2.81, 2.977], + [1.206, 1.123, 1.167], + [1.88, 1.789, 1.778], + [1.411, 1.298, 1.244], + [4.309, 4.282, 4.408], + [10.942, 10.711, 10.829], + [1.587, 1.457, 1.423], + [4.238, 4.219, 4.343], + [4.719, 4.586, 4.673], + [5.386, 5.177, 5.177], + [5.15, 5.135, 5.409], + [5.218, 5.175, 5.368], + [2.233, 2.042, 2.032], + [0.953, 0.831, 0.817], + [0.851, 1.196, 1.172], + [1.039, 1.092, 0.826], + [1.127, 1.085, 1.095], + [0.871, 0.784, 0.787], + [0.881, 0.851, 0.941], + [0.813, 0.743, 0.821] +] + } + \ No newline at end of file diff --git a/duckdb-datalake-partitioned/results/20260726/c6a.metal.json b/duckdb-datalake-partitioned/results/20260726/c6a.metal.json new file mode 100644 index 0000000000..4e99588ce9 --- /dev/null +++ b/duckdb-datalake-partitioned/results/20260726/c6a.metal.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (data lake, partitioned)", + "date": "2026-07-26", + "machine": "c6a.metal", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 1, + "data_size": 14737666736, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.73, 0.654, 0.646], + [5.744, 0.851, 0.86], + [5.845, 1.298, 1.21], + [5.787, 0.93, 1.164], + [5.8, 5.813, 5.766], + [1.337, 5.8, 1.081], + [0.882, 1.051, 0.911], + [0.889, 5.695, 0.867], + [5.771, 1.483, 1.147], + [5.837, 1.163, 1.32], + [5.97, 0.96, 0.95], + [1.232, 1.169, 1.119], + [1.299, 1.401, 5.829], + [1.259, 1.11, 1.378], + [5.876, 5.848, 5.9], + [1.137, 1.033, 1.086], + [5.994, 1.2, 1.284], + [1.358, 1.204, 1.336], + [2.065, 2.17, 1.784], + [5.755, 0.938, 5.706], + [2.102, 1.882, 2.026], + [1.772, 1.728, 1.962], + [2.379, 6.537, 2.437], + [2.902, 2.885, 3.166], + [1.105, 1.122, 1.242], + [0.995, 0.988, 0.983], + [5.838, 0.923, 0.785], + [1.766, 1.846, 1.775], + [2.407, 6.32, 2.477], + [0.953, 0.885, 0.893], + [1.232, 1.238, 1.191], + [1.649, 1.558, 6.093], + [6.29, 1.832, 6.222], + [2.054, 6.239, 1.973], + [2.126, 6.564, 6.195], + [1.336, 1.099, 5.845], + [1.089, 0.959, 0.906], + [0.913, 1.014, 0.868], + [0.974, 0.907, 0.876], + [1.256, 1.096, 1.084], + [0.83, 1.358, 0.817], + [0.807, 0.758, 0.797], + [0.852, 0.76, 0.718] +] + } + \ No newline at end of file diff --git a/duckdb-datalake-partitioned/results/20260726/c6a.xlarge.json b/duckdb-datalake-partitioned/results/20260726/c6a.xlarge.json new file mode 100644 index 0000000000..3adc3aace0 --- /dev/null +++ b/duckdb-datalake-partitioned/results/20260726/c6a.xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (data lake, partitioned)", + "date": "2026-07-26", + "machine": "c6a.xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 1, + "data_size": 14737666736, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [1.772, 2.042, 1.575], + [4.883, 4.864, 5.181], + [7.696, 7.329, 7.385], + [5.764, 5.711, 5.468], + [6.515, 6.322, 6.201], + [7.347, 7.314, 7.506], + [4.925, 5.006, 4.784], + [4.432, 4.24, 4.398], + [6.575, 6.369, 7.102], + [11.107, 11.265, 11.139], + [7.801, 7.848, 7.741], + [9.648, 9.422, 9.6], + [7.05, 6.675, 6.845], + [10.108, 10.217, 10.273], + [8.909, 8.783, 9.136], + [6.518, 6.118, 6.509], + [11.476, 11.26, 10.464], + [9.769, 9.887, 9.629], + [16.601, 16.367, 16.792], + [4.58, 4.358, 5], + [13.815, 13.677, 13.663], + [16.366, 16.339, 16.828], + [27.988, 28.164, 27.518], + [7.956, 7.697, 7.989], + [3.1, 2.972, 3.086], + [6.267, 6.25, 6.102], + [3.103, 2.896, 2.78], + [15.154, 15.673, 15.664], + [39.654, 39.813, 39.681], + [5.001, 4.941, 4.876], + [15.657, 15.508, 15.382], + [17.27, 16.942, 17.762], + [19.093, 19.673, 18.985], + [16.987, 16.915, 17.174], + [17.468, 17.051, 17.286], + [6.99, 6.628, 6.745], + [1.91, 1.943, 1.765], + [1.77, 1.687, 1.708], + [2.116, 2.171, 1.861], + [2.033, 2.033, 2.021], + [1.809, 1.905, 1.942], + [2.117, 1.803, 1.712], + [1.848, 1.69, 1.671] +] + } + \ No newline at end of file diff --git a/duckdb-datalake-partitioned/results/20260726/c7a.metal-48xl.json b/duckdb-datalake-partitioned/results/20260726/c7a.metal-48xl.json new file mode 100644 index 0000000000..9130308630 --- /dev/null +++ b/duckdb-datalake-partitioned/results/20260726/c7a.metal-48xl.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (data lake, partitioned)", + "date": "2026-07-26", + "machine": "c7a.metal-48xl", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 1, + "data_size": 14737666736, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.657, 0.708, 0.656], + [5.679, 0.943, 0.859], + [1.048, 1.223, 5.673], + [0.932, 0.86, 0.844], + [0.894, 1.18, 5.703], + [1.023, 5.762, 1.033], + [1.031, 0.972, 0.875], + [0.936, 5.645, 0.867], + [0.949, 0.925, 0.987], + [1.046, 1.079, 1.087], + [0.94, 0.902, 0.911], + [1.018, 1.034, 1.054], + [1.296, 1.09, 1.029], + [1.145, 1.319, 1.455], + [1.066, 0.977, 1.025], + [1.095, 1.013, 0.954], + [1.156, 5.863, 1.078], + [1.2, 1.176, 1.079], + [1.489, 1.371, 1.376], + [1.049, 5.725, 0.852], + [1.719, 2.373, 1.719], + [1.768, 5.814, 1.779], + [2.034, 2.139, 2.158], + [2.862, 2.427, 2.493], + [0.931, 1.019, 0.978], + [0.97, 1.167, 0.93], + [0.942, 0.796, 5.733], + [1.763, 6.444, 2.139], + [2.009, 2.045, 1.926], + [0.858, 0.809, 0.864], + [1.767, 1.606, 5.913], + [1.424, 5.939, 1.353], + [1.55, 1.584, 1.753], + [1.834, 1.863, 1.894], + [2.085, 2.016, 2.031], + [1.197, 1.492, 6.026], + [0.897, 0.865, 0.882], + [0.838, 0.788, 0.833], + [0.857, 0.865, 0.896], + [1.193, 1.102, 1.154], + [0.774, 0.804, 0.804], + [0.752, 0.73, 0.729], + [0.722, 0.776, 0.896] +] + } + \ No newline at end of file diff --git a/duckdb-datalake-partitioned/results/20260726/c8g.4xlarge.json b/duckdb-datalake-partitioned/results/20260726/c8g.4xlarge.json new file mode 100644 index 0000000000..7f679336a8 --- /dev/null +++ b/duckdb-datalake-partitioned/results/20260726/c8g.4xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (data lake, partitioned)", + "date": "2026-07-26", + "machine": "c8g.4xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 1, + "data_size": 14737666736, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [1.024, 20.769, 0.833], + [1.445, 1.477, 1.351], + [1.957, 1.932, 1.949], + [1.67, 1.575, 1.534], + [1.917, 1.946, 1.842], + [1.935, 1.833, 1.844], + [1.376, 1.295, 1.384], + [1.285, 1.393, 1.323], + [1.855, 1.79, 1.966], + [3.156, 3.034, 2.947], + [2.36, 2.214, 2.117], + [2.684, 2.68, 2.553], + [1.895, 2.087, 1.843], + [2.745, 2.844, 2.579], + [2.441, 2.286, 2.437], + [1.696, 1.706, 3.244], + [2.814, 2.73, 2.884], + [2.609, 2.624, 2.708], + [3.745, 3.891, 3.84], + [1.432, 1.618, 1.354], + [3.56, 3.551, 3.754], + [4.105, 4.118, 4.519], + [7.228, 7.083, 7.325], + [2.465, 2.961, 2.361], + [1.151, 1.109, 1.05], + [1.673, 1.64, 1.657], + [1.163, 1.142, 1.396], + [3.834, 3.845, 3.896], + [7.461, 7.459, 7.457], + [1.474, 1.368, 1.403], + [3.964, 3.98, 4.068], + [4.734, 4.312, 4.312], + [4.189, 7.568, 4.176], + [3.996, 4.029, 4.09], + [4.415, 4.168, 4.076], + [1.84, 1.775, 1.771], + [0.842, 0.856, 0.85], + [1.302, 0.906, 0.834], + [0.827, 0.877, 0.926], + [1.343, 1.364, 1.524], + [0.87, 0.826, 0.751], + [0.9, 0.7, 0.783], + [0.824, 0.762, 0.804] +] + } + \ No newline at end of file diff --git a/duckdb-datalake-partitioned/results/20260726/c8g.metal-48xl.json b/duckdb-datalake-partitioned/results/20260726/c8g.metal-48xl.json new file mode 100644 index 0000000000..5700fc522c --- /dev/null +++ b/duckdb-datalake-partitioned/results/20260726/c8g.metal-48xl.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (data lake, partitioned)", + "date": "2026-07-26", + "machine": "c8g.metal-48xl", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 1, + "data_size": 14737666736, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.619, 0.566, 1.1], + [0.871, 0.884, 0.879], + [0.963, 1.024, 5.645], + [0.878, 0.911, 0.783], + [0.83, 5.69, 5.634], + [0.937, 0.997, 0.87], + [0.951, 0.791, 0.873], + [0.858, 0.804, 0.732], + [5.692, 1.189, 0.879], + [5.831, 0.995, 5.742], + [0.83, 0.803, 0.858], + [1.166, 1.416, 1.068], + [1.196, 0.971, 0.912], + [0.94, 0.929, 0.94], + [0.916, 6.047, 1.198], + [1.244, 0.932, 0.834], + [0.956, 0.97, 5.929], + [1.415, 5.823, 1.007], + [1.312, 1.196, 1.333], + [0.766, 0.786, 5.578], + [1.959, 1.522, 1.664], + [1.512, 1.658, 1.522], + [2.39, 2.008, 2.075], + [2.553, 2.566, 2.384], + [1.348, 0.979, 0.91], + [5.777, 5.656, 0.817], + [5.675, 0.796, 0.745], + [1.501, 1.509, 1.47], + [1.894, 1.88, 1.866], + [5.609, 0.953, 1.033], + [1.107, 1.081, 1.161], + [1.216, 2.472, 1.189], + [1.447, 1.409, 6.196], + [2.226, 6.404, 1.732], + [1.696, 2.562, 6.028], + [5.765, 1.041, 5.796], + [0.856, 0.826, 0.766], + [0.815, 0.86, 0.733], + [0.855, 0.848, 0.857], + [1.146, 1.208, 1.006], + [0.784, 0.73, 0.725], + [0.769, 0.699, 0.698], + [0.731, 0.713, 0.745] +] + } + \ No newline at end of file diff --git a/duckdb-datalake/results/20260726/c6a.2xlarge.json b/duckdb-datalake/results/20260726/c6a.2xlarge.json new file mode 100644 index 0000000000..4bca8a6d13 --- /dev/null +++ b/duckdb-datalake/results/20260726/c6a.2xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (data lake, single)", + "date": "2026-07-26", + "machine": "c6a.2xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 1, + "data_size": 14779976446, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.169, 0.153, 0.166], + [0.932, 0.928, 0.895], + [1.767, 1.712, 1.729], + [1.197, 1.184, 1.107], + [1.678, 1.594, 1.499], + [2.064, 2.032, 1.944], + [1.354, 0.937, 0.941], + [0.941, 0.878, 0.92], + [1.864, 1.828, 1.752], + [3.298, 3.394, 3.54], + [2.171, 2.094, 2.073], + [2.807, 2.814, 2.747], + [2.007, 2.024, 1.94], + [3.371, 3.494, 3.344], + [2.833, 2.867, 2.754], + [1.705, 1.649, 1.699], + [3.599, 3.64, 3.574], + [3.362, 3.199, 3.258], + [6.012, 5.851, 5.794], + [1.03, 1.069, 1.075], + [5.863, 5.708, 6.324], + [6.558, 6.458, 6.547], + [12.487, 12.617, 12.288], + [2.907, 2.861, 2.836], + [0.927, 0.839, 0.878], + [1.7, 1.589, 1.707], + [1.048, 0.965, 0.8], + [6.183, 6.021, 6.091], + [19.501, 19.552, 19.412], + [1.046, 0.975, 0.95], + [5.085, 5.038, 5.058], + [5.867, 5.751, 5.745], + [7.055, 6.756, 6.828], + [7.254, 7.176, 7.381], + [7.537, 7.417, 7.391], + [1.802, 1.719, 1.731], + [0.647, 0.607, 0.613], + [0.456, 0.456, 0.485], + [0.617, 0.578, 0.675], + [0.947, 0.935, 0.991], + [0.471, 0.406, 0.413], + [0.411, 0.401, 0.44], + [0.388, 0.355, 0.339] +] + } + \ No newline at end of file diff --git a/duckdb-datalake/results/20260726/c6a.4xlarge.json b/duckdb-datalake/results/20260726/c6a.4xlarge.json new file mode 100644 index 0000000000..0416503ee6 --- /dev/null +++ b/duckdb-datalake/results/20260726/c6a.4xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (data lake, single)", + "date": "2026-07-26", + "machine": "c6a.4xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 1, + "data_size": 14779976446, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.174, 0.144, 0.147], + [0.794, 0.516, 0.569], + [0.996, 0.993, 0.987], + [0.84, 0.827, 0.978], + [1.009, 1.028, 0.937], + [1.19, 1.154, 1.245], + [0.685, 0.603, 0.588], + [0.653, 0.517, 0.58], + [1.186, 1.045, 1.054], + [1.919, 1.915, 2.014], + [1.375, 1.167, 1.243], + [1.547, 1.437, 1.454], + [1.245, 1.414, 1.196], + [2.107, 1.952, 1.92], + [1.613, 1.617, 1.607], + [1.101, 1.011, 0.997], + [2.085, 2.04, 2.024], + [1.93, 1.863, 1.925], + [4.064, 3.746, 3.647], + [0.647, 0.62, 0.61], + [5.795, 4.001, 3.42], + [3.605, 3.702, 3.735], + [8.805, 7.414, 7.004], + [2.599, 2.245, 2.224], + [0.623, 0.634, 0.542], + [0.991, 0.95, 0.952], + [0.606, 0.657, 0.638], + [3.367, 3.356, 3.309], + [10.231, 10.297, 10.174], + [0.72, 0.709, 0.873], + [2.816, 2.714, 2.736], + [3.748, 3.105, 3.301], + [4.218, 3.812, 3.827], + [4.36, 4.315, 4.317], + [4.419, 4.452, 4.382], + [1.131, 1.126, 1.089], + [0.712, 0.962, 0.621], + [0.512, 0.427, 0.456], + [0.622, 0.564, 0.589], + [1.056, 0.97, 0.941], + [0.439, 0.372, 0.399], + [0.424, 0.372, 0.372], + [0.375, 0.326, 0.332] +] + } + \ No newline at end of file diff --git a/duckdb-datalake/results/20260726/c6a.large.json b/duckdb-datalake/results/20260726/c6a.large.json new file mode 100644 index 0000000000..6dbec98c81 --- /dev/null +++ b/duckdb-datalake/results/20260726/c6a.large.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (data lake, single)", + "date": "2026-07-26", + "machine": "c6a.large", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 1, + "data_size": 14779976446, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.183, 0.143, 0.148], + [3.725, 4.395, 2.9], + [8.308, 6.361, 6.17], + [14.639, 4.039, 4.058], + [6.985, 6.617, 6.831], + [7.375, 7.3, 7.733], + [3.202, 3.17, 4.106], + [3.294, 3.275, 3.531], + [8.876, 7.681, 8.132], + [14.878, 13.804, 13.963], + [7.368, 7.139, 7.344], + [10.326, 10.603, 11.088], + [7.32, 8.323, 7.182], + [13.414, 13.325, 12.904], + [10.268, 10.252, 10.392], + [7.467, 7.159, 7.326], + [14.27, 14.424, 14.232], + [13.323, 13.98, 13.174], + [31.332, 30.623, 31.672], + [3.454, 4.005, 3.555], + [21.258, 21.547, 22.534], + [24.631, 24.57, 24.182], + [48.504, 52.116, 48.664], + [9.076, 8.61, 8.888], + [2.439, 2.24, 2.237], + [5.909, 5.897, 5.721], + [3.794, 2.459, 2.432], + [23.407, 23.02, 22.879], + [78.056, 77.152, 77.08], + [3.598, 3.416, 3.243], + [19.114, 19.176, 19.395], + [24.35, 25.093, 25.121], + [35.675, 36.101, 36.501], + [58.964, 34.698, 34.384], + [35.337, 36.135, 46.951], + [7.151, 6.973, 6.951], + [0.824, 0.776, 0.767], + [0.564, 0.545, 0.551], + [0.838, 0.802, 0.765], + [1.277, 1.232, 1.257], + [0.642, 0.515, 0.505], + [0.577, 0.606, 0.541], + [0.536, 0.502, 0.479] +] + } + \ No newline at end of file diff --git a/duckdb-datalake/results/20260726/c6a.metal.json b/duckdb-datalake/results/20260726/c6a.metal.json new file mode 100644 index 0000000000..a6b6f3d85f --- /dev/null +++ b/duckdb-datalake/results/20260726/c6a.metal.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (data lake, single)", + "date": "2026-07-26", + "machine": "c6a.metal", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 2, + "data_size": 14779976446, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.185, 0.127, 0.156], + [0.528, 0.478, 0.449], + [5.576, 0.702, 0.534], + [5.383, 0.519, 0.519], + [0.64, 0.591, 5.379], + [0.754, 0.672, 5.375], + [5.318, 0.478, 0.562], + [5.293, 0.501, 0.512], + [0.646, 5.38, 5.352], + [0.793, 0.712, 0.686], + [0.584, 0.578, 0.559], + [5.387, 0.812, 1.077], + [5.542, 5.359, 0.655], + [1.009, 0.947, 0.886], + [0.715, 0.75, 5.525], + [0.667, 0.727, 5.576], + [5.845, 0.906, 0.964], + [0.918, 0.885, 0.838], + [1.149, 1.484, 1.085], + [5.296, 5.343, 5.332], + [5.679, 1.317, 1.414], + [1.632, 6.114, 5.41], + [6.118, 5.672, 2.071], + [2.719, 2.841, 2.677], + [0.906, 5.397, 5.403], + [0.615, 0.98, 1.221], + [5.498, 0.823, 0.829], + [1.449, 5.493, 1.189], + [2.119, 2.201, 2.109], + [0.484, 0.485, 0.489], + [0.822, 0.79, 5.613], + [1.294, 5.613, 5.672], + [1.345, 5.827, 5.814], + [1.621, 1.705, 5.893], + [6.013, 1.707, 5.675], + [0.743, 0.666, 0.691], + [0.654, 0.583, 0.576], + [0.466, 0.495, 0.414], + [0.572, 0.562, 0.566], + [0.956, 0.982, 0.885], + [0.449, 0.394, 0.413], + [0.455, 0.409, 0.371], + [0.475, 0.314, 0.358] +] + } + \ No newline at end of file diff --git a/duckdb-datalake/results/20260726/c6a.xlarge.json b/duckdb-datalake/results/20260726/c6a.xlarge.json new file mode 100644 index 0000000000..91dc70e3d3 --- /dev/null +++ b/duckdb-datalake/results/20260726/c6a.xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (data lake, single)", + "date": "2026-07-26", + "machine": "c6a.xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 1, + "data_size": 14779976446, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.188, 0.165, 0.146], + [1.619, 1.701, 1.63], + [3.325, 3.589, 3.202], + [3.908, 2.207, 2.118], + [2.808, 2.853, 2.84], + [4.085, 3.867, 3.941], + [1.802, 1.77, 1.649], + [1.642, 1.641, 1.626], + [3.178, 3.156, 3.45], + [6.703, 6.365, 6.441], + [3.994, 3.745, 3.862], + [5.343, 5.379, 5.232], + [3.723, 3.714, 3.695], + [6.462, 6.489, 6.389], + [5.251, 5.366, 5.256], + [2.978, 3.057, 3.4], + [6.612, 6.737, 6.798], + [6.282, 6.253, 6.808], + [12.304, 12.234, 12.129], + [1.833, 1.9, 1.769], + [11.081, 11.431, 10.925], + [12.81, 12.656, 12.655], + [23.811, 24.288, 23.723], + [4.895, 4.995, 4.913], + [1.477, 1.42, 1.567], + [3.197, 3.127, 3.359], + [1.385, 1.46, 1.41], + [11.988, 11.822, 11.89], + [38.744, 38.35, 38.736], + [1.876, 1.73, 1.752], + [9.846, 9.67, 10.023], + [11.993, 11.348, 11.628], + [13.354, 13.52, 13.661], + [14.603, 14.429, 14.67], + [15.17, 14.66, 14.854], + [3.36, 3.172, 3.24], + [0.7, 0.63, 0.632], + [0.517, 0.688, 0.488], + [0.65, 0.582, 0.607], + [1.011, 0.932, 0.968], + [0.471, 0.379, 0.384], + [0.42, 0.39, 0.373], + [0.418, 0.353, 0.332] +] + } + \ No newline at end of file diff --git a/duckdb-datalake/results/20260726/c7a.metal-48xl.json b/duckdb-datalake/results/20260726/c7a.metal-48xl.json new file mode 100644 index 0000000000..059ec9cc7a --- /dev/null +++ b/duckdb-datalake/results/20260726/c7a.metal-48xl.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (data lake, single)", + "date": "2026-07-26", + "machine": "c7a.metal-48xl", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 2, + "data_size": 14779976446, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.163, 0.14, 0.131], + [5.358, 0.962, 0.85], + [0.678, 0.729, 0.833], + [5.374, 0.721, 0.608], + [0.693, 0.742, 0.522], + [0.648, 0.69, 0.598], + [0.501, 5.267, 5.298], + [5.297, 0.463, 0.455], + [5.403, 0.588, 0.568], + [0.686, 0.693, 0.8], + [0.581, 0.519, 0.556], + [5.411, 0.624, 0.61], + [0.69, 0.624, 5.468], + [0.853, 0.833, 0.765], + [5.424, 0.726, 5.479], + [0.689, 5.323, 0.651], + [5.574, 0.796, 5.61], + [0.861, 0.842, 0.792], + [1.011, 1.035, 1.064], + [0.524, 0.495, 0.513], + [5.832, 1.412, 1.284], + [1.519, 1.313, 1.802], + [1.862, 1.849, 1.994], + [2.608, 2.6, 2.78], + [0.816, 5.5, 0.774], + [0.659, 0.67, 0.549], + [5.424, 0.694, 0.628], + [1.263, 1.373, 1.329], + [6.386, 1.626, 6.195], + [0.483, 0.653, 5.268], + [5.474, 5.6, 0.9], + [1.126, 0.951, 0.928], + [5.859, 1.407, 1.215], + [1.529, 1.474, 5.663], + [5.666, 1.386, 1.489], + [0.703, 0.694, 0.63], + [0.655, 0.602, 0.603], + [0.486, 0.44, 0.488], + [0.661, 0.575, 0.604], + [0.95, 0.881, 0.888], + [0.423, 0.37, 0.724], + [0.495, 0.403, 0.454], + [0.427, 0.392, 0.433] +] + } + \ No newline at end of file diff --git a/duckdb-datalake/results/20260726/c8g.4xlarge.json b/duckdb-datalake/results/20260726/c8g.4xlarge.json new file mode 100644 index 0000000000..affe0d1c5c --- /dev/null +++ b/duckdb-datalake/results/20260726/c8g.4xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (data lake, single)", + "date": "2026-07-26", + "machine": "c8g.4xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 1, + "data_size": 14779976446, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.145, 0.12, 0.155], + [0.547, 0.575, 0.544], + [1.006, 0.92, 0.973], + [0.894, 0.811, 0.721], + [0.839, 0.787, 0.819], + [0.961, 0.927, 0.949], + [0.607, 0.612, 0.573], + [0.591, 0.514, 0.512], + [0.97, 0.859, 0.871], + [1.692, 1.755, 1.657], + [1.064, 1.074, 1.279], + [1.559, 1.422, 1.441], + [0.971, 0.973, 0.982], + [1.597, 1.583, 1.673], + [1.862, 1.47, 1.419], + [0.857, 0.807, 0.783], + [1.91, 1.659, 1.673], + [1.821, 1.615, 1.636], + [2.781, 2.569, 2.611], + [0.634, 0.596, 0.6], + [2.885, 2.93, 2.84], + [3.309, 3.223, 3.209], + [5.931, 5.895, 5.854], + [2.038, 2.035, 2.141], + [0.671, 0.572, 0.607], + [0.946, 0.865, 0.858], + [0.552, 0.487, 0.512], + [3.132, 3.041, 3.01], + [6.732, 6.713, 6.908], + [0.623, 0.59, 0.575], + [2.678, 2.696, 2.53], + [2.987, 2.939, 2.88], + [2.886, 2.936, 2.862], + [3.348, 3.309, 3.31], + [3.388, 3.348, 3.36], + [1.011, 0.857, 0.83], + [0.571, 0.561, 0.566], + [0.451, 0.391, 0.399], + [0.568, 0.545, 0.535], + [0.881, 0.82, 0.842], + [0.403, 0.317, 0.323], + [0.373, 0.315, 0.339], + [0.322, 0.275, 0.29] +] + } + \ No newline at end of file diff --git a/duckdb-datalake/results/20260726/c8g.metal-48xl.json b/duckdb-datalake/results/20260726/c8g.metal-48xl.json new file mode 100644 index 0000000000..d615af3ee2 --- /dev/null +++ b/duckdb-datalake/results/20260726/c8g.metal-48xl.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (data lake, single)", + "date": "2026-07-26", + "machine": "c8g.metal-48xl", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 1, + "data_size": 14779976446, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.155, 0.12, 0.137], + [5.282, 0.531, 0.476], + [0.444, 0.402, 0.38], + [5.445, 0.43, 0.454], + [0.465, 0.618, 0.616], + [0.607, 5.476, 5.304], + [0.428, 0.367, 0.408], + [5.291, 5.247, 0.347], + [0.535, 0.496, 0.499], + [5.441, 0.545, 0.582], + [5.39, 0.447, 0.481], + [0.494, 0.523, 0.511], + [0.633, 6.563, 5.356], + [0.908, 0.68, 0.705], + [5.406, 0.617, 0.682], + [5.341, 5.329, 0.631], + [5.661, 0.699, 0.719], + [0.886, 0.719, 0.757], + [0.909, 0.873, 1.022], + [5.293, 0.417, 0.411], + [1.181, 1.97, 1.679], + [1.178, 1.216, 1.161], + [1.949, 1.971, 2.543], + [2.456, 2.558, 2.731], + [5.446, 5.62, 0.742], + [0.715, 0.639, 5.23], + [5.456, 0.656, 0.725], + [5.777, 5.375, 1.327], + [6.407, 1.542, 1.636], + [5.276, 0.369, 0.348], + [1.097, 5.513, 0.994], + [1.151, 0.963, 0.858], + [1.124, 1.151, 1.121], + [1.427, 1.289, 5.605], + [1.321, 6.388, 1.403], + [0.701, 5.39, 5.387], + [0.581, 0.578, 0.55], + [0.451, 0.423, 0.482], + [0.581, 0.537, 0.545], + [0.9, 0.902, 0.843], + [0.427, 0.382, 0.348], + [0.353, 0.365, 0.345], + [0.348, 0.312, 0.31] +] + } + \ No newline at end of file From cc83bb31772f62730a68d746a3b8bec28d536cc0 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Sun, 26 Jul 2026 01:46:04 +0000 Subject: [PATCH 3/3] Add benchmark results for clickhouse-datalake, clickhouse-datalake-partitioned, clickhouse-web, duckdb-datalake, duckdb-datalake-partitioned (c6a.large, t3a.small) --- .../results/20260726/c6a.large.json | 60 +++++++++++++++++++ .../results/20260726/c6a.large.json | 60 +++++++++++++++++++ .../results/20260726/t3a.small.json | 60 +++++++++++++++++++ .../results/20260726/c6a.large.json | 60 +++++++++++++++++++ .../results/20260726/t3a.small.json | 60 +++++++++++++++++++ .../results/20260726/c6a.large.json | 60 +++++++++++++++++++ .../results/20260726/t3a.small.json | 60 +++++++++++++++++++ .../results/20260726/t3a.small.json | 60 +++++++++++++++++++ 8 files changed, 480 insertions(+) create mode 100644 clickhouse-datalake-partitioned/results/20260726/c6a.large.json create mode 100644 clickhouse-datalake/results/20260726/c6a.large.json create mode 100644 clickhouse-datalake/results/20260726/t3a.small.json create mode 100644 clickhouse-web/results/20260726/c6a.large.json create mode 100644 clickhouse-web/results/20260726/t3a.small.json create mode 100644 duckdb-datalake-partitioned/results/20260726/c6a.large.json create mode 100644 duckdb-datalake-partitioned/results/20260726/t3a.small.json create mode 100644 duckdb-datalake/results/20260726/t3a.small.json diff --git a/clickhouse-datalake-partitioned/results/20260726/c6a.large.json b/clickhouse-datalake-partitioned/results/20260726/c6a.large.json new file mode 100644 index 0000000000..2760614d8e --- /dev/null +++ b/clickhouse-datalake-partitioned/results/20260726/c6a.large.json @@ -0,0 +1,60 @@ +{ + "system": "ClickHouse (data lake, partitioned)", + "date": "2026-07-26", + "machine": "c6a.large", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","embedded","stateless","ClickHouse derivative"], + "load_time": 0, + "data_size": 14737666736, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [8.642, 0.159, 0.154], + [14.791, 5.781, 5.561], + [10.689, 9.582, 9.215], + [10.622, 9.498, 8.485], + [10.275, 10.907, 9.85], + [12.525, 13.053, 11.694], + [6.099, 5.924, 5.622], + [5.929, 5.774, 5.474], + [11.899, 11.485, 11.107], + [14.957, 14.943, 14.569], + [14.461, 14.203, 13.514], + [13.744, 14.003, 14.778], + [12.339, 14.822, 12.246], + [23.809, 24.426, 23.697], + [16.635, 16.268, 16.684], + [10.858, 11.994, 10.796], + [32.138, 30.242, 30.057], + [24.095, 23.508, 24.738], + [49.813, 50.508, 50.624], + [7.426, 7.429, 7.514], + [25.849, 33.018, 26.017], + [33.608, 32.843, 32.611], + [52.693, 93.766, 94.756], + [108.793, 156.099, 155.577], + [19.038, 18.037, 17.547], + [10.536, 9.893, 9.896], + [17.875, 17.803, 17.343], + [34.537, 34.934, 34.932], + [37.796, 34.525, 34.53], + [6.911, 6.446, 6.816], + [20.094, 19.553, 19.582], + [30.1, 30.816, 30.026], + [58.867, 60.659, 61.462], + [53.025, 52.141, 51.87], + [51.363, 52.03, 51.482], + [9.353, 8.939, 8.872], + [2.756, 0.423, 0.436], + [2.449, 0.232, 0.241], + [2.448, 0.185, 0.182], + [3.09, 0.698, 0.687], + [2.416, 0.173, 0.172], + [2.436, 0.163, 0.205], + [2.418, 0.151, 0.149] +] + } + \ No newline at end of file diff --git a/clickhouse-datalake/results/20260726/c6a.large.json b/clickhouse-datalake/results/20260726/c6a.large.json new file mode 100644 index 0000000000..0521a25f38 --- /dev/null +++ b/clickhouse-datalake/results/20260726/c6a.large.json @@ -0,0 +1,60 @@ +{ + "system": "ClickHouse (data lake, single)", + "date": "2026-07-26", + "machine": "c6a.large", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","embedded","stateless","ClickHouse derivative"], + "load_time": 0, + "data_size": 14779976446, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.353, 0.175, 0.177], + [7.505, 4.32, 3.098], + [11.432, 5.876, 8.388], + [11.954, 9.6, 8.853], + [9.496, 9.435, 8.767], + [13.116, 12.983, 12.548], + [3.577, 3.545, 3.358], + [3.377, 3.092, 3.188], + [10.957, 11.092, 11.236], + [14.13, 13.078, 13.716], + [10.247, 10.043, 10.558], + [11.466, 10.668, 10.175], + [12.842, 13.08, 12.682], + [20.289, 20.649, 21.077], + [14.14, 10.065, 10.01], + [10.814, 10.392, 10.193], + [27.909, 26.138, 31.906], + [21.94, 20.277, 19.698], + [47.447, 45.411, 44.715], + [7.103, 6.876, 7.517], + [39.186, 40.774, 38.826], + [44.203, 39.617, 43.51], + [60.692, 60.32, 59.8], + [112.731, 103.955, 105.371], + [14.329, 14.005, 14.358], + [11.117, 10.699, 12.713], + [14.354, 14.494, 15.339], + [33.579, 36.047, 33.849], + [41.719, 41.619, 41.568], + [4.073, 3.695, 3.793], + [17.067, 16.831, 17.513], + [29.778, 25.059, 24.384], + [56.439, 57.15, 56.539], + [62.103, 61.568, 61.3], + [59.691, 62.578, 62.911], + [5.807, 5.926, 5.635], + [1.767, 0.437, 0.397], + [1.066, 0.23, 0.23], + [1.162, 0.18, 0.179], + [1.792, 0.62, 0.637], + [1.088, 0.153, 0.158], + [1.176, 0.14, 0.137], + [0.778, 0.136, 0.127] +] + } + \ No newline at end of file diff --git a/clickhouse-datalake/results/20260726/t3a.small.json b/clickhouse-datalake/results/20260726/t3a.small.json new file mode 100644 index 0000000000..8a1e38021d --- /dev/null +++ b/clickhouse-datalake/results/20260726/t3a.small.json @@ -0,0 +1,60 @@ +{ + "system": "ClickHouse (data lake, single)", + "date": "2026-07-26", + "machine": "t3a.small", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","embedded","stateless","ClickHouse derivative"], + "load_time": 0, + "data_size": 14779976446, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.56, 0.298, 0.282], + [10.573, 4.49, 4.096], + [9.77, 7.796, 7.145], + [10.681, 8.546, 8.434], + [12.451, 12.061, 12.021], + [16.693, 16.905, 17.379], + [4.443, 4.395, 4.286], + [4.277, 3.764, 4.386], + [16.498, 17.355, 16.785], + [23.591, 21.295, 22.213], + [13.341, 11.586, 13.597], + [12.89, 13.508, 12.486], + [24.818, 26.215, 25.336], + [36.034, 36.011, 35.919], + [25, 24.668, 24.263], + [16.214, 18.057, 17.584], + [58.397, 58.208, 58.276], + [41.539, 41.135, 42.076], + [107.44, 105.263, 103.023], + [7.811, 8.031, 7.796], + [47.304, 47.462, 47.08], + [54.515, 51.744, 51.282], + [74.534, 75.037, 69.961], + [null, null, null], + [18.192, 17.093, 17.392], + [14.292, 13.778, 14.125], + [18.281, 17.88, 17.239], + [45.17, 44.38, 43.917], + [68.693, 69.111, 67.918], + [5.162, 4.5, 4.59], + [22.137, 23.93, 25.153], + [40.911, 41.861, 41.282], + [131.171, 142.273, 141.037], + [116.395, 117.336, 119.112], + [116.339, 117.878, 116.507], + [11.718, 10.836, 10.499], + [2.075, 0.693, 0.68], + [1.408, 0.365, 0.364], + [1.276, 0.336, 0.297], + [2.458, 1.27, 1.286], + [1.242, 0.263, 0.25], + [1.157, 0.263, 0.25], + [0.818, 0.238, 0.225] +] + } + \ No newline at end of file diff --git a/clickhouse-web/results/20260726/c6a.large.json b/clickhouse-web/results/20260726/c6a.large.json new file mode 100644 index 0000000000..8b754662ca --- /dev/null +++ b/clickhouse-web/results/20260726/c6a.large.json @@ -0,0 +1,60 @@ +{ + "system": "ClickHouse (web)", + "date": "2026-07-26", + "machine": "c6a.large", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","ClickHouse derivative","stateless"], + "load_time": 0, + "data_size": 14557009492, + "concurrent_qps": 0.207, + "concurrent_error_ratio": 0.924, + "result": [ + [0.002, 0.002, 0.002], + [0.338, 0.203, 0.233], + [0.675, 0.643, 0.563], + [1.46, 1.491, 1.478], + [3.293, 3.693, 3.284], + [7.15, 6.429, 6.593], + [0.2, 0.175, 0.177], + [0.35, 0.227, 0.218], + [4.792, 4.975, 4.903], + [5.988, 6.688, 6.313], + [4.706, 4.736, 4.771], + [4.869, 4.958, 5.014], + [6.286, 6.018, 6.573], + [14.311, 14.028, 14.472], + [11.228, 11.632, 11.268], + [3.836, 3.69, 3.49], + [25.127, 25.097, 24.886], + [18.182, 17.306, 18.385], + [46.867, 45.999, 45.639], + [1.542, 0.228, 0.23], + [31.366, 29.214, 31.214], + [34.25, 8.227, 8.193], + [36.134, 25.066, 24.504], + [10.14, 6.406, 6.245], + [3.181, 3.493, 3.262], + [3.551, 3.863, 3.593], + [2.937, 3.023, 2.993], + [34.811, 33.374, 32.499], + [39.575, 37.512, 38.008], + [0.468, 0.431, 0.438], + [7.485, 7.121, 7.095], + [19.296, 19.221, 19.82], + [59.212, 57.16, 57.22], + [61.283, 60.073, null], + [60.906, 61.213, null], + [2.366, 2.235, 2.564], + [0.579, 0.474, 0.492], + [0.333, 0.215, 0.198], + [0.452, 0.498, 0.431], + [1.198, 0.858, 0.888], + [0.296, 0.183, 0.138], + [0.206, 0.227, 0.134], + [0.271, 0.164, 0.165] +] + } + \ No newline at end of file diff --git a/clickhouse-web/results/20260726/t3a.small.json b/clickhouse-web/results/20260726/t3a.small.json new file mode 100644 index 0000000000..743eb98df7 --- /dev/null +++ b/clickhouse-web/results/20260726/t3a.small.json @@ -0,0 +1,60 @@ +{ + "system": "ClickHouse (web)", + "date": "2026-07-26", + "machine": "t3a.small", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","ClickHouse derivative","stateless"], + "load_time": 0, + "data_size": 14557009492, + "concurrent_qps": 0.108, + "concurrent_error_ratio": 0.978, + "result": [ + [0.003, 0.002, 0.002], + [0.561, 0.312, 0.319], + [1.301, 1.191, 1.256], + [2.885, 3.194, 3.002], + [6.86, 6.372, 6.741], + [15.963, 15.233, 15.497], + [0.438, 0.35, 0.307], + [0.512, 0.406, 0.413], + [13.96, 13.929, 13.439], + [17.766, 16.41, 16.987], + [7.29, 6.736, 6.616], + [8.85, 8.671, 7.275], + [20.626, 20.819, 20.251], + [33.327, 33.079, 33.421], + [26.141, 26.171, 25.258], + [13.818, 11.677, 12.275], + [60.71, 61.369, 60.083], + [43.027, 42.771, null], + [null, null, null], + [3.299, 0.207, 0.183], + [64.424, 58.206, 60.132], + [72.114, 19.085, 18.42], + [82.971, 55.695, 57.49], + [null, 11.196, 11.033], + [6.447, 5.773, 6.019], + [8.9, 8.338, 8.677], + [6.435, 6.189, 6.168], + [65.14, 63.411, 61.328], + [null, null, null], + [1.072, 1.023, 1.05], + [18.622, null, 18.608], + [null, null, null], + [null, null, null], + [null, null, null], + [null, null, null], + [9.28, 7.88, 8.065], + [1.055, 1.01, 1.001], + [0.504, 0.433, 0.449], + [0.749, 0.676, 0.934], + [1.876, 1.96, 1.849], + [0.385, 0.24, 0.263], + [0.327, 0.236, 0.235], + [0.379, 0.258, 0.193] +] + } + \ No newline at end of file diff --git a/duckdb-datalake-partitioned/results/20260726/c6a.large.json b/duckdb-datalake-partitioned/results/20260726/c6a.large.json new file mode 100644 index 0000000000..ca08cd4b95 --- /dev/null +++ b/duckdb-datalake-partitioned/results/20260726/c6a.large.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (data lake, partitioned)", + "date": "2026-07-26", + "machine": "c6a.large", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 1, + "data_size": 14737666736, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [3.252, 2.715, 2.864], + [8.647, 8.345, 8.4], + [14.121, 13.587, 13.714], + [10.293, 9.854, 9.97], + [12.796, 12.788, 12.496], + [13.25, 12.9, 12.966], + [8.745, 8.381, 8.283], + [7.827, 7.415, 7.451], + [13.517, 12.798, 13.069], + [21.817, 21.772, 21.897], + [14.727, 13.829, 13.911], + [18.651, 18.48, 18.003], + [12.457, 12.462, 12.37], + [19.572, 19.428, 19.887], + [17.176, 17.036, 16.852], + [12.773, 12.358, 12.317], + [21.542, 21.985, 21.779], + [21.172, 20.424, 21.078], + [41.653, 40.268, 40.071], + [8.66, 8.361, 8.018], + [26.136, 27.596, 26.261], + [31.471, 31.382, 30.804], + [61.813, 55.833, 55.34], + [15.216, 14.445, 14.365], + [5.406, 5.189, 5.198], + [11.832, 11.771, 11.631], + [5.226, 4.875, 4.955], + [29.381, 28.632, 28.509], + [82.283, 80.305, 82.055], + [9.058, 8.941, 8.613], + [29.521, 29.961, 29.618], + [35.712, 35.207, 35.243], + [45.686, 45.553, 45.85], + [68.51, 41.977, 43.133], + [41.277, 40.992, 40.983], + [13.386, 13.819, 13.908], + [3.386, 3.37, 3.135], + [3.042, 3.113, 3.111], + [3.293, 3.333, 3.393], + [3.772, 3.626, 3.497], + [3.186, 2.952, 2.802], + [3.193, 3.084, 2.901], + [2.935, 2.932, 2.947] +] + } + \ No newline at end of file diff --git a/duckdb-datalake-partitioned/results/20260726/t3a.small.json b/duckdb-datalake-partitioned/results/20260726/t3a.small.json new file mode 100644 index 0000000000..7df4c62457 --- /dev/null +++ b/duckdb-datalake-partitioned/results/20260726/t3a.small.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (data lake, partitioned)", + "date": "2026-07-26", + "machine": "t3a.small", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 1, + "data_size": 14737666736, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [3.663, 4.061, 3.69], + [10.069, 9.668, 10.308], + [15.167, 15.138, 15.302], + [12.086, 12.145, 11.995], + [16.851, 16.727, 16.427], + [16.914, 16.583, 16.459], + [10.475, 9.816, 9.912], + [9.447, 8.905, 9.501], + [17.615, 17.501, 17.268], + [26.404, 26.82, 26.689], + [15.248, 16.424, 15.722], + [20.008, 20.221, 20.594], + [17.083, 17.152, 17.214], + [26.847, 26.586, 26.51], + [21.837, 22.653, 21.782], + [16.744, 17.126, 16.497], + [36.137, 40.033, 36.084], + [29.602, 29.005, 28.771], + [63.925, 64.135, 65.619], + [9.917, 9.584, 9.585], + [39.232, 40.612, 38.075], + [46.01, 46.806, 47.458], + [84.426, 88.249, 83.286], + [17.613, 17.039, 17.077], + [6.368, 6.699, 6.447], + [14.714, 14.565, 14.101], + [6.053, 6.123, 6.056], + [46.364, 41.65, 39.653], + [187.311, 182.601, 184.127], + [10.692, 11.129, 10.61], + [34.118, 34.341, 34.271], + [42.652, 40.961, 40.289], + [67.369, 65.797, 66.163], + [90.808, 88.993, 87.613], + [88.493, 83.493, 84.896], + [19.028, 19.313, 19.019], + [3.989, 4.06, 3.875], + [3.995, 3.911, 4.027], + [3.971, 3.876, 4.138], + [5, 4.583, 4.606], + [4.115, 3.766, 3.8], + [3.823, 4.202, 3.738], + [3.959, 3.64, 3.9] +] + } + \ No newline at end of file diff --git a/duckdb-datalake/results/20260726/t3a.small.json b/duckdb-datalake/results/20260726/t3a.small.json new file mode 100644 index 0000000000..80242eaada --- /dev/null +++ b/duckdb-datalake/results/20260726/t3a.small.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (data lake, single)", + "date": "2026-07-26", + "machine": "t3a.small", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 1, + "data_size": 14779976446, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.274, 0.223, 0.232], + [3.186, 3.358, 3.139], + [6.723, 6.806, 6.448], + [11.189, 4.545, 4.401], + [9.776, 9.695, 9.576], + [11.191, 11.273, 10.508], + [3.641, 3.39, 3.606], + [3.625, 3.523, 3.168], + [11.142, 10.555, 10.419], + [18.444, 16.865, 16.825], + [7.979, 7.702, 8.233], + [11.324, 10.973, 11.606], + [10.699, 10.379, 10.469], + [21.307, 22.087, 19.552], + [13.661, 14.606, 13.574], + [11.468, 9.931, 10.019], + [30.93, 28.29, 27.349], + [30.911, 19.486, 21.66], + [67.952, 57.444, 56.593], + [4.092, 3.772, 3.804], + [37.239, 37.549, 35.114], + [43.911, 44.098, 43.304], + [89.028, 86.49, 87.742], + [10.594, 10.468, 11.028], + [3.024, 2.763, 2.692], + [7.458, 7.188, 7.403], + [2.866, 3.081, 2.837], + [39.148, 37.681, 38.972], + [183.193, 177.724, 179.53], + [3.716, 3.718, 3.512], + [21.874, 23.244, 22.915], + [29.754, 28.121, 29.867], + [57.056, 58.769, 57.103], + [80.786, 91.547, 92.821], + [97.039, 91.992, 86.306], + [11.697, 11.127, 11.163], + [1.163, 0.952, 0.912], + [0.907, 0.672, 0.674], + [1.053, 0.9, 0.98], + [1.898, 1.499, 1.563], + [0.76, 0.653, 0.631], + [0.729, 0.624, 0.678], + [0.721, 0.603, 0.606] +] + } + \ No newline at end of file