update: parseable version upgrade to v3.0.0

lib/download-hits-json

@@ -0,0 +1,13 @@
+#!/bin/bash
+# Standalone version: the ClickBench Playground bakes a pre-decompressed
+# hits.json into /opt/clickbench/datasets_ro and symlinks to it here. Outside
+# the Playground that path doesn't exist, and parseable/load already falls
+# back to downloading+decompressing hits.json.gz itself, so this script is a
+# no-op there. Kept as a stub only so bench_download() has something to call.
+set -e
+if [ -d /opt/clickbench/datasets_ro ]; then
+    dir="${1:-.}"
+    mkdir -p "$dir"
+    cd "$dir"
+    ln -sf /opt/clickbench/datasets_ro/hits.json hits.json
+fi

parseable/benchmark.sh

@@ -1,3 +1,4 @@
 #!/bin/bash
 export BENCH_DOWNLOAD_SCRIPT="download-hits-json"
+chmod +x ../lib/download-hits-json
 exec ../lib/benchmark-common.sh

parseable/data-size

@@ -1,4 +1,4 @@
 #!/bin/bash
 set -eu
 
-du -bcs local-store | grep total | awk '{print $1}'
+du -bcs data | grep total | awk '{print $1}'

parseable/install

@@ -13,7 +13,7 @@ if [ ! -x ./parseable ]; then
     # v2.7.2 fixes the inference; verified locally end-to-end against
     # the bundled static_schema.json and hits.json.
     wget --continue --progress=dot:giga \
-        https://github.com/parseablehq/parseable/releases/download/v2.7.2/Parseable_OSS_x86_64-unknown-linux-gnu
+        https://github.com/parseablehq/parseable/releases/download/v3.0.0/Parseable_OSS_x86_64-unknown-linux-gnu
     mv Parseable_OSS_x86_64-unknown-linux-gnu parseable
     chmod +x parseable
 fi

parseable/load

@@ -51,8 +51,14 @@ fi
 # subsequent chunk fails. 3 × 1000 lines is ~4x lower peak pressure
 # and empirically clears without 408s. curl --retry survives short
 # stalls so a briefly-saturated parseable doesn't fail the load.
-LINES_PER_CHUNK=1000
-INGEST_JOBS=3
+NUM_CORES=$(nproc)
+if [ "$NUM_CORES" -ge 190 ]; then
+    LINES_PER_CHUNK=2500
+    INGEST_JOBS=20
+else
+    LINES_PER_CHUNK=1000
+    INGEST_JOBS=3
+fi
 pv hits.json | parallel --pipe -N$LINES_PER_CHUNK --block 10M \
     --jobs "$INGEST_JOBS" --halt-on-error 0 '
         awk "BEGIN{print \"[\"} NR>1{print prev \",\"} {prev=\$0} END{if (prev) print prev; print \"]\"}" |

parseable/query

@@ -7,16 +7,44 @@ set -e
 
 query=$(cat)
 
-# Parseable filters every query by [startTime, endTime] against the
-# row's ingest timestamp. The original benchmark used today's calendar
-# day, which only works if the dataset was loaded today. In the
-# playground the data is ingested during initial provisioning and
-# then frozen into a snapshot, so "today" from the query script's
-# point of view drifts past the load day and every row falls outside
-# the window → all queries return zero. Use a wide window that
-# covers any plausible load + query date.
-START_TIME="2000-01-01T00:00:00.000Z"
-END_TIME="2099-12-31T23:59:00.000Z"
+# Derive Parseable's mandatory query window from the stream itself. Keep a
+# five-minute margin so events exactly at either reported boundary are not
+# lost to timestamp precision or boundary semantics. This lookup happens
+# before the query timer starts.
+stream_info=$(curl -sS --fail-with-body \
+    -u "admin:admin" 'http://localhost:8000/api/v1/logstream/hits/info')
+
+mapfile -t time_range < <(
+    printf '%s' "$stream_info" | python3 -c '
+import json
+import sys
+from datetime import datetime, timedelta, timezone
+
+info = json.load(sys.stdin)
+
+def parse_timestamp(field):
+    value = info.get(field)
+    if not value:
+        raise ValueError(f"stream info has no {field}")
+    return datetime.fromisoformat(value.replace("Z", "+00:00")).astimezone(timezone.utc)
+
+def format_timestamp(value):
+    return value.isoformat(timespec="milliseconds").replace("+00:00", "Z")
+
+print(format_timestamp(parse_timestamp("firstEventAt") - timedelta(minutes=5)))
+print(format_timestamp(parse_timestamp("latestEventAt") + timedelta(minutes=5)))
+'
+)
+
+if [ "${#time_range[@]}" -ne 2 ]; then
+    echo "could not derive query time range from hits stream info" >&2
+    exit 1
+fi
+
+START_TIME=${time_range[0]}
+END_TIME=${time_range[1]}
+
+echo "==> query time range: $START_TIME .. $END_TIME" >&2
 
 # JSON-escape quotes inside the query.
 escaped=$(printf '%s' "$query" | sed 's/"/\\"/g')

parseable/results/20260818/c6a.4xlarge.json

@@ -0,0 +1,60 @@
+{
+      "system": "Parseable (Parquet, partitioned)",
+      "date": "2026-08-18",
+      "machine": "c6a.4xlarge",
+      "cluster_size": 1,
+      "proprietary": "no",
+      "hardware": "cpu",
+      "tuned": "no",
+      "tags": ["Rust","column-oriented","lukewarm-cold-run"],
+      "load_time": 4931,
+      "data_size": 14023558981,
+      "concurrent_qps": 0.88,
+      "concurrent_error_ratio": 0,
+      "result": [
+        [0.477, 0.068, 0.065],
+        [0.321, 0.06, 0.059],
+        [0.79, 0.106, 0.118],
+        [1.036, 0.118, 0.112],
+        [1.148, 0.513, 0.509],
+        [1.569, 0.694, 0.72],
+        [0.313, 0.048, 0.042],
+        [0.353, 0.074, 0.076],
+        [1.626, 0.83, 0.861],
+        [2.234, 0.927, 0.954],
+        [1.317, 0.251, 0.242],
+        [1.35, 0.274, 0.276],
+        [1.66, 0.798, 0.795],
+        [3.182, 1.38, 1.373],
+        [1.651, 0.908, 0.946],
+        [1.324, 0.615, 0.673],
+        [3.065, 1.552, 1.539],
+        [2.96, 1.538, 1.536],
+        [5.412, 2.636, 2.649],
+        [0.672, 0.088, 0.09],
+        [9.009, 2, 1.995],
+        [10.67, 2.762, 2.698],
+        [15.419, 4.219, 4.185],
+        [13.271, 1.074, 0.873],
+        [3.111, 0.231, 0.255],
+        [1.422, 0.442, 0.428],
+        [3.458, 0.364, 0.324],
+        [9.095, 2.894, 2.867],
+        [9.497, 8.115, 8.389],
+        [0.872, 0.519, 0.5],
+        [3.284, 0.854, 0.884],
+        [6.862, 1.068, 1.086],
+        [5.168, 3.15, 3.153],
+        [9.669, 4.369, 4.466],
+        [9.658, 4.382, 4.402],
+        [1.489, 1.222, 1.184],
+        [0.584, 0.109, 0.114],
+        [0.514, 0.081, 0.071],
+        [0.541, 0.056, 0.057],
+        [0.703, 0.191, 0.189],
+        [0.492, 0.04, 0.038],
+        [0.482, 0.037, 0.035],
+        [0.476, 0.033, 0.031]
+]
+  } 
+

parseable/results/20260827/c6a.2xlarge.json

@@ -0,0 +1,60 @@
+{
+      "system": "Parseable (Parquet, partitioned)",
+      "date": "2026-08-27",
+      "machine": "c6a.2xlarge",
+      "cluster_size": 1,
+      "proprietary": "no",
+      "hardware": "cpu",
+      "tuned": "no",
+      "tags": ["Rust","column-oriented","lukewarm-cold-run"],
+      "load_time": 5321,
+      "data_size": 14018829670,
+      "concurrent_qps": 0.178,
+      "concurrent_error_ratio": 0,
+      "result": [
+        [0.507, 0.108, 0.097],
+        [0.487, 0.084, 0.082],
+        [0.69, 0.268, 0.269],
+        [1.266, 0.233, 0.228],
+        [1.585, 0.991, 1.009],
+        [1.839, 1.206, 1.211],
+        [0.449, 0.05, 0.044],
+        [0.536, 0.119, 0.11],
+        [2.142, 1.533, 1.537],
+        [2.408, 1.347, 1.338],
+        [1.392, 0.434, 0.449],
+        [1.433, 0.481, 0.472],
+        [1.877, 1.255, 1.248],
+        [3.934, 1.977, 1.996],
+        [1.958, 1.37, 1.401],
+        [1.66, 1.12, 1.13],
+        [3.799, 2.571, 2.656],
+        [3.358, 2.142, 2.107],
+        [6.831, 4.624, 4.754],
+        [0.813, 0.142, 0.135],
+        [9.204, 2.218, 2.188],
+        [10.715, 2.753, 2.839],
+        [16.971, 5.253, 5.275],
+        [9.713, 1.078, 1.007],
+        [2.394, 0.396, 0.314],
+        [1.582, 0.727, 0.709],
+        [2.691, 0.492, 0.51],
+        [9.187, 2.981, 2.922],
+        [15.877, 15.521, 16.644],
+        [1.624, 1.103, 1.241],
+        [3.408, 1.372, 1.367],
+        [6.982, 1.491, 1.504],
+        [8.092, 4.826, 4.843],
+        [10.621, 5.56, 5.636],
+        [10.607, 5.482, 5.929],
+        [2.378, 2.004, 2.041],
+        [0.58, 0.126, 0.105],
+        [0.546, 0.1, 0.105],
+        [0.518, 0.06, 0.086],
+        [0.704, 0.237, 0.188],
+        [0.467, 0.037, 0.037],
+        [0.456, 0.044, 0.038],
+        [0.452, 0.036, 0.035]
+]
+  } 
+

parseable/results/20260827/c6a.4xlarge.json

@@ -0,0 +1,60 @@
+{
+      "system": "Parseable (Parquet, partitioned)",
+      "date": "2026-08-27",
+      "machine": "c6a.4xlarge",
+      "cluster_size": 1,
+      "proprietary": "no",
+      "hardware": "cpu",
+      "tuned": "no",
+      "tags": ["Rust","column-oriented","lukewarm-cold-run"],
+      "load_time": 4903,
+      "data_size": 8013513979,
+      "concurrent_qps": 1.56,
+      "concurrent_error_ratio": 0,
+      "result": [
+        [0.406, 0.05, 0.047],
+        [0.403, 0.036, 0.034],
+        [0.43, 0.068, 0.07],
+        [0.51, 0.071, 0.068],
+        [0.68, 0.274, 0.288],
+        [0.795, 0.385, 0.376],
+        [0.398, 0.027, 0.03],
+        [0.459, 0.047, 0.045],
+        [0.869, 0.465, 0.464],
+        [1.079, 0.551, 0.542],
+        [0.556, 0.154, 0.154],
+        [0.578, 0.169, 0.163],
+        [0.896, 0.441, 0.436],
+        [1.656, 0.804, 0.807],
+        [0.966, 0.502, 0.51],
+        [0.768, 0.34, 0.333],
+        [1.459, 0.848, 0.838],
+        [1.419, 0.823, 0.818],
+        [2.857, 1.531, 1.537],
+        [0.479, 0.051, 0.05],
+        [5.12, 1.198, 1.175],
+        [6.02, 1.574, 1.574],
+        [7.867, 2.382, 2.356],
+        [10.628, 0.583, 0.525],
+        [1.271, 0.147, 0.12],
+        [0.641, 0.246, 0.243],
+        [1.482, 0.231, 0.21],
+        [5.197, 1.716, 1.728],
+        [5.756, 5.073, 4.592],
+        [0.784, 0.32, 0.302],
+        [1.584, 0.484, 0.484],
+        [3.677, 0.627, 0.626],
+        [2.828, 1.78, 1.795],
+        [5.501, 2.575, 2.571],
+        [5.453, 2.567, 2.597],
+        [1.088, 0.672, 0.669],
+        [0.479, 0.104, 0.101],
+        [0.454, 0.074, 0.065],
+        [0.472, 0.06, 0.061],
+        [0.626, 0.168, 0.166],
+        [0.493, 0.04, 0.041],
+        [0.486, 0.039, 0.036],
+        [0.485, 0.032, 0.034]
+]
+  } 
+

parseable/results/20260827/c6a.metal.json

@@ -0,0 +1,60 @@
+{
+      "system": "Parseable (Parquet, partitioned)",
+      "date": "2026-08-27",
+      "machine": "c6a.metal",
+      "cluster_size": 1,
+      "proprietary": "no",
+      "hardware": "cpu",
+      "tuned": "no",
+      "tags": ["Rust","column-oriented","lukewarm-cold-run"],
+      "load_time": 1959,
+      "data_size": 14004905018,
+      "concurrent_qps": 0.717,
+      "concurrent_error_ratio": 0,
+      "result": [
+        [0.749, 0.207, 0.23],
+        [0.663, 0.21, 0.235],
+        [0.659, 0.208, 0.208],
+        [0.818, 0.2, 0.241],
+        [2.858, 2.699, 2.761],
+        [2.452, 2.172, 2.147],
+        [0.516, 0.19, 0.164],
+        [1.133, 0.546, 0.514],
+        [5.998, 5.427, 5.883],
+        [3.337, 1.831, 1.773],
+        [2.84, 2.363, 2.368],
+        [2.847, 2.461, 2.459],
+        [2.532, 2.064, 2.114],
+        [6.669, 6.195, 6.072],
+        [2.547, 2.228, 2.287],
+        [2.825, 2.577, 2.596],
+        [3.52, 2.931, 2.931],
+        [3.28, 3.033, 3.013],
+        [6.596, 5.008, 5.111],
+        [0.672, 0.162, 0.214],
+        [8.763, 0.537, 0.536],
+        [10.623, 0.93, 1.005],
+        [15.748, 1.303, 1.34],
+        [39.236, 0.419, 0.503],
+        [2.05, 0.16, 0.167],
+        [0.992, 0.284, 0.261],
+        [1.252, 0.251, 0.22],
+        [9.103, 0.987, 0.99],
+        [8.555, 2.346, 2.416],
+        [0.581, 0.266, 0.256],
+        [3.489, 2.156, 2.171],
+        [6.573, 2.352, 2.418],
+        [8.263, 8.132, 8.067],
+        [9.383, 3.648, 3.426],
+        [9.397, 3.493, 3.316],
+        [2.915, 2.582, 2.618],
+        [1.011, 0.5, 0.518],
+        [1.13, 0.48, 0.493],
+        [1.086, 0.497, 0.441],
+        [1.323, 0.596, 0.581],
+        [1.103, 0.473, 0.476],
+        [1.064, 0.475, 0.441],
+        [1.077, 0.454, 0.463]
+]
+  } 
+