diff --git a/duckdb-datalake-partitioned/load b/duckdb-datalake-partitioned/load index 17aeb8d6c1..42b0232a6f 100755 --- a/duckdb-datalake-partitioned/load +++ b/duckdb-datalake-partitioned/load @@ -7,5 +7,6 @@ set -e rm -f hits.db trap 'rm -f create.rewritten.sql' EXIT bench_dataset_sql < create.sql > create.rewritten.sql -duckdb hits.db -f create.rewritten.sql +# -no-agent: keep the plain CLI output; see ./query. +duckdb -no-agent hits.db -f create.rewritten.sql sync diff --git a/duckdb-datalake-partitioned/query b/duckdb-datalake-partitioned/query index 4819178cec..9c0e47c3d4 100755 --- a/duckdb-datalake-partitioned/query +++ b/duckdb-datalake-partitioned/query @@ -12,7 +12,11 @@ query=$(cat) # the playground's SNI-filter proxy can't follow gracefully. Bake the # region into every query. Empty creds keep the credential chain off # IMDS (which the proxy correctly blocks). -out=$(duckdb hits.db \ +# -no-agent: the 2.0 CLI turns on "agent mode" when it detects an AI coding +# agent in the environment (AI_AGENT, CLAUDECODE, CURSOR_AGENT, ...) and +# stdout is not a terminal: Markdown tables, truncated results, JSON errors +# and a progress bar. Keep the plain output regardless of who runs this. +out=$(duckdb -no-agent hits.db \ -c "SET s3_region='eu-central-1'" \ -c "CREATE OR REPLACE SECRET (TYPE S3, KEY_ID '', SECRET '', REGION 'eu-central-1')" \ -c "SET parquet_metadata_cache=true" \ diff --git a/duckdb-datalake-partitioned/results/20261110/c6a.2xlarge.json b/duckdb-datalake-partitioned/results/20261110/c6a.2xlarge.json new file mode 100644 index 0000000000..abee1c7944 --- /dev/null +++ b/duckdb-datalake-partitioned/results/20261110/c6a.2xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (data lake, partitioned)", + "date": "2026-11-10", + "machine": "c6a.2xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 0, + "data_size": 14737666736, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.539, 0.503, 0.515], + [0.773, 0.754, 0.724], + [1.333, 1.047, 1.011], + [0.892, 0.832, 0.842], + [1.172, 1.142, 1.178], + [1.517, 1.445, 1.494], + [0.915, 0.783, 1.009], + [0.89, 0.793, 0.791], + [1.368, 1.42, 1.314], + [1.696, 1.704, 1.653], + [1.227, 1.156, 1.232], + [1.124, 1.474, 1.164], + [1.517, 1.47, 1.45], + [2.142, 2.005, 2.052], + [1.683, 1.539, 1.543], + [1.332, 1.245, 1.289], + [2.553, 2.496, 2.441], + [2.147, 2.115, 2.116], + [4.674, 3.96, 4.295], + [1.126, 0.837, 0.788], + [4.181, 2.813, 3.024], + [2.917, 3.042, 2.857], + [5.811, 5.258, 5.425], + [1.991, 1.762, 1.679], + [0.814, 0.77, 0.763], + [1.165, 1.086, 1.027], + [0.788, 0.75, 0.737], + [2.744, 2.855, 2.768], + [18.22, 18.257, 18.319], + [0.866, 0.839, 0.817], + [1.841, 2.139, 1.822], + [2.928, 2.431, 2.477], + [4.08, 4.11, 5.995], + [5.345, 5.591, 5.51], + [5.486, 5.391, 5.011], + [1.252, 1.143, 1.174], + [0.663, 0.624, 0.607], + [0.599, 0.556, 0.547], + [0.591, 0.581, 0.554], + [0.793, 0.976, 0.748], + [0.57, 0.526, 0.507], + [0.599, 0.525, 0.515], + [0.559, 0.519, 0.512] +] + } + \ No newline at end of file diff --git a/duckdb-datalake-partitioned/results/20261110/c6a.4xlarge.json b/duckdb-datalake-partitioned/results/20261110/c6a.4xlarge.json new file mode 100644 index 0000000000..71701b4e02 --- /dev/null +++ b/duckdb-datalake-partitioned/results/20261110/c6a.4xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (data lake, partitioned)", + "date": "2026-11-10", + "machine": "c6a.4xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 0, + "data_size": 14737666736, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.641, 0.623, 0.609], + [0.757, 0.965, 0.657], + [0.826, 0.972, 0.745], + [0.755, 0.792, 1.061], + [0.925, 0.962, 1.892], + [1.101, 1.095, 1.053], + [0.784, 0.704, 0.632], + [0.653, 0.615, 0.604], + [1.008, 1.122, 0.974], + [1.214, 1.208, 1.375], + [0.842, 1.296, 0.773], + [0.848, 0.797, 0.777], + [1.134, 1.059, 1.084], + [1.534, 1.468, 1.454], + [1.189, 1.138, 1.092], + [1.039, 0.981, 0.978], + [1.737, 1.694, 1.704], + [1.451, 1.393, 1.456], + [2.612, 2.574, 2.679], + [0.692, 0.636, 0.73], + [2.41, 2.331, 2.307], + [2.533, 2.567, 2.529], + [4.41, 4.403, 4.243], + [1.721, 1.605, 1.684], + [0.864, 0.823, 0.643], + [0.835, 0.824, 0.78], + [1.026, 0.769, 0.683], + [2.372, 2.331, 2.274], + [9.896, 9.611, 9.733], + [0.734, 0.622, 0.64], + [1.227, 1.325, 1.209], + [1.729, 1.676, 1.677], + [2.809, 3.103, 2.773], + [3.465, 3.556, 3.448], + [3.512, 3.487, 3.45], + [0.909, 0.899, 0.896], + [0.659, 0.564, 0.565], + [0.563, 0.551, 0.553], + [0.55, 0.663, 0.517], + [0.719, 0.689, 0.786], + [0.71, 0.579, 0.566], + [0.623, 0.51, 0.516], + [0.547, 0.494, 0.475] +] + } + \ No newline at end of file diff --git a/duckdb-datalake-partitioned/results/20261110/c6a.large.json b/duckdb-datalake-partitioned/results/20261110/c6a.large.json new file mode 100644 index 0000000000..22cea78903 --- /dev/null +++ b/duckdb-datalake-partitioned/results/20261110/c6a.large.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (data lake, partitioned)", + "date": "2026-11-10", + "machine": "c6a.large", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 0, + "data_size": 14737666736, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.793, 0.757, 0.738], + [2.02, 1.773, 1.757], + [3.173, 2.621, 2.549], + [6.038, 2.442, 2.117], + [4.111, 4.244, 4.047], + [4.655, 4.358, 4.357], + [2.735, 1.903, 2.165], + [1.819, 1.827, 1.83], + [4.893, 4.715, 4.733], + [6.459, 6.376, 6.636], + [3.349, 3.038, 3.011], + [3.227, 3.025, 2.917], + [4.598, 4.506, 4.347], + [7.045, 6.805, 6.832], + [4.791, 4.606, 4.551], + [4.554, 4.837, 4.444], + [9.319, 9.389, 9.283], + [7.867, 7.826, 7.821], + [24.479, 32.942, 23.686], + [2.459, 2.105, 1.932], + [10.254, 11.888, 10.143], + [11.028, 10.227, 10.383], + [20.733, 19.596, 20.098], + [4.89, 4.752, 5.243], + [1.542, 1.507, 1.481], + [3.354, 3.143, 3.154], + [1.495, 1.479, 1.44], + [11.1, 10.515, 10.324], + [72.535, 71.747, 72.1], + [1.97, 2.812, 2.047], + [6.065, 6.117, 6.035], + [9.582, 9.46, 9.435], + [27.547, 27.655, 27.14], + [27.985, 27.63, 27.144], + [27.573, 27.539, 28.259], + [4.103, 4.134, 4.088], + [0.98, 0.948, 1.345], + [0.928, 0.867, 0.857], + [1.03, 0.931, 0.893], + [1.221, 1.092, 1.1], + [1.346, 0.835, 0.824], + [1.323, 0.873, 0.769], + [0.856, 0.815, 0.757] +] + } + \ No newline at end of file diff --git a/duckdb-datalake-partitioned/results/20261110/c6a.metal.json b/duckdb-datalake-partitioned/results/20261110/c6a.metal.json new file mode 100644 index 0000000000..eee7fe7aeb --- /dev/null +++ b/duckdb-datalake-partitioned/results/20261110/c6a.metal.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (data lake, partitioned)", + "date": "2026-11-10", + "machine": "c6a.metal", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 0, + "data_size": 14737666736, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.568, 0.516, 0.535], + [0.641, 0.577, 0.594], + [0.698, 0.634, 0.717], + [0.649, 0.613, 0.63], + [0.741, 0.661, 0.7], + [0.807, 1.073, 0.721], + [0.6, 0.639, 0.583], + [0.639, 0.642, 0.611], + [0.714, 0.7, 0.668], + [0.863, 0.852, 0.843], + [0.732, 0.71, 0.716], + [0.741, 0.691, 0.747], + [0.769, 0.742, 0.71], + [0.955, 0.892, 0.901], + [0.786, 0.699, 0.707], + [0.829, 1.219, 0.714], + [0.937, 0.912, 1.192], + [1, 0.927, 0.942], + [1.147, 1.092, 1.392], + [0.607, 0.735, 0.872], + [1.312, 1.23, 1.375], + [1.26, 1.32, 1.323], + [1.78, 1.695, 1.918], + [1.641, 1.525, 1.565], + [0.978, 0.71, 0.69], + [0.68, 0.841, 0.669], + [0.741, 0.693, 0.677], + [1.47, 1.221, 1.378], + [2.098, 2.075, 1.955], + [1.022, 0.666, 0.596], + [0.965, 1.065, 0.886], + [1.161, 1.725, 1.616], + [1.347, 1.325, 1.292], + [1.467, 1.433, 1.516], + [1.485, 1.4, 1.442], + [0.786, 0.677, 0.896], + [0.674, 0.605, 0.593], + [0.612, 0.571, 0.606], + [0.628, 0.783, 0.576], + [0.7, 0.687, 0.683], + [0.585, 0.544, 0.843], + [0.592, 0.868, 0.593], + [0.569, 0.55, 0.606] +] + } + \ No newline at end of file diff --git a/duckdb-datalake-partitioned/results/20261110/c6a.xlarge.json b/duckdb-datalake-partitioned/results/20261110/c6a.xlarge.json new file mode 100644 index 0000000000..8f30027155 --- /dev/null +++ b/duckdb-datalake-partitioned/results/20261110/c6a.xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (data lake, partitioned)", + "date": "2026-11-10", + "machine": "c6a.xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 0, + "data_size": 14737666736, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.617, 0.58, 0.576], + [1.217, 1.286, 1.158], + [1.975, 1.629, 1.636], + [1.324, 1.256, 1.335], + [1.851, 1.823, 1.862], + [2.391, 2.342, 2.336], + [1.159, 1.137, 1.183], + [1.114, 1.25, 1.141], + [2.284, 2.269, 2.432], + [3.385, 2.851, 2.839], + [1.821, 1.84, 1.887], + [1.862, 2.048, 1.773], + [2.453, 2.338, 2.446], + [3.411, 3.413, 3.372], + [2.612, 2.537, 2.477], + [1.983, 2.015, 2.061], + [4.738, 4.802, 4.499], + [3.69, 3.619, 3.549], + [8.193, 8.471, 8.329], + [1.227, 1.221, 1.183], + [5.075, 5.234, 5.059], + [6.572, 5.245, 5.501], + [9.868, 10.076, 9.225], + [2.667, 3.246, 2.514], + [1.07, 0.993, 1.028], + [1.767, 1.772, 1.735], + [1.095, 1.041, 1.07], + [5.094, 5.223, 4.896], + [36.026, 35.723, 35.709], + [1.204, 1.158, 1.174], + [3.388, 3.392, 3.32], + [4.746, 5.143, 5.061], + [8.119, 8.21, 8.278], + [8.693, 8.821, 9.152], + [9.525, 8.923, 9.038], + [1.94, 1.93, 1.903], + [0.836, 0.726, 0.724], + [0.726, 0.657, 0.902], + [0.737, 0.663, 0.815], + [0.922, 0.802, 0.785], + [0.752, 0.593, 0.623], + [0.711, 0.636, 0.643], + [0.661, 0.62, 0.7] +] + } + \ No newline at end of file diff --git a/duckdb-datalake-partitioned/results/20261110/c7a.metal-48xl.json b/duckdb-datalake-partitioned/results/20261110/c7a.metal-48xl.json new file mode 100644 index 0000000000..9022d38411 --- /dev/null +++ b/duckdb-datalake-partitioned/results/20261110/c7a.metal-48xl.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (data lake, partitioned)", + "date": "2026-11-10", + "machine": "c7a.metal-48xl", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 0, + "data_size": 14737666736, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.499, 0.524, 0.757], + [0.601, 0.616, 0.605], + [0.633, 0.657, 0.639], + [0.627, 0.588, 0.572], + [0.663, 0.68, 0.634], + [0.721, 0.66, 0.648], + [0.587, 0.727, 0.572], + [0.605, 0.815, 0.549], + [0.732, 0.665, 0.65], + [0.823, 0.878, 0.821], + [0.894, 0.682, 0.704], + [0.763, 0.725, 0.682], + [0.837, 0.702, 0.665], + [0.883, 0.894, 0.822], + [0.723, 0.717, 0.68], + [0.772, 0.667, 0.696], + [0.896, 0.845, 0.841], + [0.863, 0.952, 0.844], + [1.016, 0.986, 1.203], + [0.608, 0.564, 0.559], + [1.09, 1.197, 1.104], + [1.121, 1.138, 1.276], + [1.679, 1.637, 1.767], + [1.52, 1.411, 1.652], + [0.645, 0.665, 0.612], + [0.705, 1.018, 1.225], + [0.694, 0.651, 0.679], + [1.187, 1.12, 1.182], + [1.634, 1.554, 1.578], + [0.605, 0.581, 0.595], + [0.917, 0.878, 0.919], + [1.069, 1.064, 1.13], + [1.188, 1.149, 1.144], + [1.434, 1.353, 1.246], + [1.247, 1.323, 1.258], + [0.712, 0.847, 0.631], + [0.599, 0.571, 0.677], + [0.613, 0.544, 0.505], + [0.57, 0.6, 0.537], + [0.666, 0.683, 0.639], + [0.593, 0.582, 0.555], + [0.586, 0.56, 0.682], + [0.573, 0.555, 0.556] +] + } + \ No newline at end of file diff --git a/duckdb-datalake-partitioned/results/20261110/c8g.4xlarge.json b/duckdb-datalake-partitioned/results/20261110/c8g.4xlarge.json new file mode 100644 index 0000000000..ddc15bcef6 --- /dev/null +++ b/duckdb-datalake-partitioned/results/20261110/c8g.4xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (data lake, partitioned)", + "date": "2026-11-10", + "machine": "c8g.4xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 0, + "data_size": 14737666736, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.713, 0.67, 0.485], + [0.604, 0.55, 0.585], + [0.816, 0.721, 0.816], + [0.649, 0.929, 1.04], + [1.043, 0.733, 0.714], + [0.902, 0.82, 0.822], + [0.641, 0.902, 0.582], + [0.61, 0.571, 0.576], + [0.791, 0.816, 0.753], + [1.073, 1.026, 1.004], + [0.793, 0.83, 0.8], + [0.789, 0.758, 0.758], + [0.896, 0.849, 1.086], + [1.258, 1.055, 1.045], + [1, 1.094, 0.989], + [0.824, 0.775, 0.788], + [1.167, 1.118, 1.099], + [1.017, 1.025, 1.023], + [1.624, 1.568, 1.529], + [0.64, 0.603, 0.619], + [2.048, 1.962, 2.01], + [2.172, 2.133, 2.171], + [3.886, 3.728, 3.659], + [1.603, 1.44, 1.553], + [0.814, 0.712, 0.765], + [0.785, 0.736, 0.736], + [0.787, 0.743, 0.655], + [2.139, 1.942, 1.996], + [5.858, 6.097, 6.002], + [0.637, 0.631, 0.64], + [1.185, 1.146, 1.121], + [1.564, 1.526, 1.539], + [1.744, 1.653, 1.643], + [2.23, 2.199, 2.317], + [2.224, 2.298, 2.267], + [0.762, 0.717, 0.742], + [0.537, 0.552, 0.528], + [0.51, 0.544, 0.522], + [0.596, 0.499, 0.489], + [0.641, 0.61, 0.631], + [0.55, 0.485, 0.48], + [0.526, 0.505, 0.481], + [0.533, 0.495, 0.519] +] + } + \ No newline at end of file diff --git a/duckdb-datalake-partitioned/results/20261110/c8g.metal-48xl.json b/duckdb-datalake-partitioned/results/20261110/c8g.metal-48xl.json new file mode 100644 index 0000000000..8cbe47d03b --- /dev/null +++ b/duckdb-datalake-partitioned/results/20261110/c8g.metal-48xl.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (data lake, partitioned)", + "date": "2026-11-10", + "machine": "c8g.metal-48xl", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 0, + "data_size": 14737666736, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.479, 0.474, 0.662], + [0.566, 0.554, 0.549], + [0.796, 0.618, 0.617], + [0.635, 0.565, 0.566], + [0.64, 0.63, 0.642], + [0.672, 0.629, 0.724], + [0.543, 0.603, 0.584], + [0.52, 0.509, 0.547], + [0.611, 0.612, 0.581], + [0.83, 0.796, 0.749], + [0.671, 0.617, 0.787], + [0.754, 0.647, 0.697], + [0.677, 0.633, 0.65], + [1.271, 0.778, 1.198], + [0.727, 0.663, 0.653], + [0.834, 0.651, 0.639], + [0.822, 0.791, 1.013], + [0.835, 0.806, 0.851], + [0.997, 0.938, 0.979], + [0.575, 0.546, 0.54], + [1.058, 1.068, 1.052], + [1.121, 1.098, 1.611], + [1.581, 1.593, 1.521], + [2.18, 1.486, 1.469], + [0.661, 0.664, 0.57], + [0.641, 0.583, 0.589], + [0.75, 0.523, 0.618], + [1.179, 1.233, 1.116], + [1.562, 1.577, 1.57], + [0.639, 0.703, 0.6], + [0.883, 0.848, 1.008], + [1.122, 1.044, 1.886], + [1.174, 1.165, 1.164], + [1.225, 1.148, 1.183], + [1.613, 1.182, 1.204], + [1.101, 0.579, 0.894], + [0.514, 0.584, 0.551], + [0.543, 0.627, 0.599], + [0.511, 0.542, 0.517], + [0.684, 0.607, 0.628], + [0.538, 0.525, 0.52], + [0.528, 0.552, 0.551], + [0.548, 0.713, 0.682] +] + } + \ No newline at end of file diff --git a/duckdb-datalake-partitioned/results/20261110/t3a.small.json b/duckdb-datalake-partitioned/results/20261110/t3a.small.json new file mode 100644 index 0000000000..b62ebd5601 --- /dev/null +++ b/duckdb-datalake-partitioned/results/20261110/t3a.small.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (data lake, partitioned)", + "date": "2026-11-10", + "machine": "t3a.small", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 0, + "data_size": 14737666736, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [1.784, 0.972, 0.819], + [5.298, 4.031, 1.889], + [4.757, 2.87, 2.722], + [5.177, 2.538, 2.43], + [6.082, 5.914, 5.965], + [6.54, 6.644, 6.517], + [2.01, 1.944, 1.983], + [1.862, 1.828, 1.906], + [7.801, 7.208, 7.409], + [10.238, 10.071, 11.529], + [3.553, 3.653, 3.487], + [3.408, 3.47, 3.209], + [6.979, 6.837, 7.37], + [15.774, 14.188, 13.348], + [7.827, 7.686, 7.596], + [9.068, 7.056, 7.518], + [23.785, 22.607, 22.787], + [15.683, 17.355, 14.925], + [51.394, 52.385, 51.645], + [2.184, 2.218, 2.131], + [16.897, 16.784, 18.077], + [18.043, 18.165, 18.578], + [37.21, 37.153, 36.611], + [8.022, 8.624, 7.966], + [1.756, 1.826, 1.869], + [4.257, 4.415, 4.192], + [1.969, 1.934, 2.097], + [17.379, 17.313, 17.119], + [127.241, 129.294, 127.63], + [2.357, 2.312, 2.051], + [9.655, 9.393, 9.595], + [17.786, 17.991, 17.015], + [61.191, 47.879, 49.012], + [53.517, 53.639, 61.794], + [54.753, 54.748, 53.733], + [6.279, 5.91, 5.963], + [1.232, 1.641, 1.293], + [1.02, 0.983, 0.986], + [1.117, 1.069, 1.065], + [1.595, 1.401, 1.369], + [1.043, 0.909, 0.875], + [0.952, 0.923, 0.914], + [0.945, 0.905, 0.921] +] + } + \ No newline at end of file diff --git a/duckdb-datalake/load b/duckdb-datalake/load index 0d0a09b867..4394fd96eb 100755 --- a/duckdb-datalake/load +++ b/duckdb-datalake/load @@ -7,5 +7,6 @@ set -e rm -f hits.db trap 'rm -f create.rewritten.sql' EXIT bench_dataset_sql < create.sql > create.rewritten.sql -duckdb hits.db -f create.rewritten.sql +# -no-agent: keep the plain CLI output; see ./query. +duckdb -no-agent hits.db -f create.rewritten.sql sync diff --git a/duckdb-datalake/query b/duckdb-datalake/query index ec07ea0af2..c2da0169e6 100755 --- a/duckdb-datalake/query +++ b/duckdb-datalake/query @@ -11,7 +11,11 @@ query=$(cat) # doesn't default to us-east-1 and get into a redirect loop. The # session-scoped SECRET keeps creds at empty so the chain doesn't # probe IMDS (which the playground's SNI filter blocks). -out=$(duckdb hits.db \ +# -no-agent: the 2.0 CLI turns on "agent mode" when it detects an AI coding +# agent in the environment (AI_AGENT, CLAUDECODE, CURSOR_AGENT, ...) and +# stdout is not a terminal: Markdown tables, truncated results, JSON errors +# and a progress bar. Keep the plain output regardless of who runs this. +out=$(duckdb -no-agent hits.db \ -c "SET s3_region='eu-central-1'" \ -c "CREATE OR REPLACE SECRET (TYPE S3, KEY_ID '', SECRET '', REGION 'eu-central-1')" \ -c "SET parquet_metadata_cache=true" \ diff --git a/duckdb-datalake/results/20261110/c6a.2xlarge.json b/duckdb-datalake/results/20261110/c6a.2xlarge.json new file mode 100644 index 0000000000..ed795e70c3 --- /dev/null +++ b/duckdb-datalake/results/20261110/c6a.2xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (data lake, single)", + "date": "2026-11-10", + "machine": "c6a.2xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 0, + "data_size": 14779976446, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.241, 0.168, 0.194], + [0.477, 0.421, 0.458], + [0.643, 0.658, 0.716], + [0.562, 0.504, 0.588], + [0.899, 0.826, 0.826], + [1.276, 1.191, 1.188], + [0.531, 0.423, 0.395], + [0.465, 0.423, 0.393], + [1.033, 1.006, 0.993], + [1.431, 1.411, 1.353], + [0.765, 0.735, 0.747], + [0.747, 0.81, 0.713], + [1.275, 1.447, 1.21], + [1.829, 1.775, 1.833], + [1.379, 1.277, 1.276], + [1, 0.93, 0.958], + [2.124, 2.165, 2.135], + [2.02, 1.75, 1.768], + [3.763, 3.757, 3.757], + [0.49, 0.439, 0.457], + [3.923, 2.59, 2.801], + [2.706, 2.674, 2.789], + [5.78, 5.076, 4.981], + [1.559, 1.298, 1.444], + [0.544, 0.532, 0.452], + [0.875, 0.781, 0.824], + [0.761, 0.456, 0.539], + [2.681, 2.534, 2.544], + [18.607, 18.391, 18.371], + [0.654, 0.477, 0.46], + [1.566, 1.467, 1.927], + [2.256, 2.053, 2.13], + [4, 4.366, 3.929], + [4.606, 5.351, 5.326], + [4.69, 5.157, 5.428], + [0.905, 0.858, 0.838], + [0.482, 0.385, 0.325], + [0.35, 0.31, 0.332], + [0.355, 0.28, 0.288], + [0.554, 0.454, 0.479], + [0.358, 0.256, 0.247], + [0.31, 0.279, 0.294], + [0.278, 0.26, 0.279] +] + } + \ No newline at end of file diff --git a/duckdb-datalake/results/20261110/c6a.4xlarge.json b/duckdb-datalake/results/20261110/c6a.4xlarge.json new file mode 100644 index 0000000000..c2a09bdd8e --- /dev/null +++ b/duckdb-datalake/results/20261110/c6a.4xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (data lake, single)", + "date": "2026-11-10", + "machine": "c6a.4xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 0, + "data_size": 14779976446, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.208, 0.186, 0.209], + [0.388, 0.385, 0.339], + [0.59, 20.278, 0.555], + [0.459, 0.755, 0.43], + [0.669, 0.632, 0.599], + [0.876, 0.851, 0.801], + [0.365, 0.307, 0.32], + [0.358, 0.353, 0.364], + [0.927, 0.665, 0.693], + [0.998, 0.88, 0.882], + [0.564, 0.496, 0.472], + [0.572, 0.467, 0.478], + [0.874, 0.8, 0.821], + [1.342, 1.264, 1.288], + [1.005, 0.888, 0.86], + [0.756, 0.651, 0.611], + [1.503, 1.375, 1.465], + [1.258, 1.176, 1.13], + [2.456, 2.437, 2.409], + [0.461, 0.527, 0.489], + [2.121, 2.111, 2.09], + [2.449, 2.394, 2.297], + [4.191, 4.099, 4.166], + [1.47, 2.124, 1.404], + [0.524, 0.634, 0.652], + [0.593, 0.571, 0.581], + [0.543, 0.513, 0.478], + [2.189, 2.152, 2.132], + [10.15, 10.229, 10.674], + [0.411, 0.325, 0.371], + [1.138, 1.023, 1.014], + [1.592, 1.515, 1.501], + [2.561, 2.465, 2.658], + [3.407, 3.303, 3.216], + [3.395, 3.259, 3.419], + [0.657, 0.613, 0.574], + [0.417, 0.344, 0.317], + [0.351, 0.309, 0.514], + [0.367, 0.274, 0.287], + [0.578, 0.507, 0.496], + [0.331, 0.283, 0.233], + [0.303, 0.293, 0.212], + [0.288, 0.252, 0.218] +] + } + \ No newline at end of file diff --git a/duckdb-datalake/results/20261110/c6a.large.json b/duckdb-datalake/results/20261110/c6a.large.json new file mode 100644 index 0000000000..2fe7b779f4 --- /dev/null +++ b/duckdb-datalake/results/20261110/c6a.large.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (data lake, single)", + "date": "2026-11-10", + "machine": "c6a.large", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 0, + "data_size": 14779976446, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.205, 0.175, 0.163], + [1.079, 0.975, 0.982], + [1.912, 1.683, 1.627], + [3.647, 1.59, 1.395], + [3.311, 3.107, 3.244], + [4.049, 3.805, 3.795], + [1.619, 1.006, 0.971], + [1.107, 0.939, 0.991], + [3.854, 3.801, 3.858], + [5.6, 5.365, 5.365], + [2.131, 1.983, 1.849], + [2.071, 1.945, 1.98], + [3.865, 3.704, 3.88], + [5.958, 6.029, 5.942], + [4.158, 4.122, 3.997], + [3.608, 3.911, 3.496], + [7.911, 7.984, 8.661], + [6.985, 6.71, 7.248], + [21.079, 86.97, 20.517], + [1.167, 1.119, 1.328], + [9.981, 9.681, 9.516], + [9.503, 9.69, 9.295], + [21.292, 20.184, 19.57], + [4.01, 3.821, 3.877], + [1.172, 1.2, 1.097], + [2.494, 2.499, 2.436], + [1.203, 1.185, 1.223], + [9.659, 10.18, 9.854], + [72.512, 72.331, 72.371], + [1.175, 1.042, 1.078], + [5.221, 5.351, 5.089], + [8.65, 8.009, 7.769], + [26.13, 103.407, 25.967], + [24.549, 24.361, 24.44], + [26.378, 26.498, 26.711], + [3.16, 3.111, 3.072], + [0.587, 0.427, 0.446], + [0.44, 0.358, 0.334], + [0.526, 0.358, 0.397], + [0.75, 0.649, 0.701], + [0.393, 0.344, 0.297], + [0.412, 0.311, 0.341], + [0.386, 0.318, 0.298] +] + } + \ No newline at end of file diff --git a/duckdb-datalake/results/20261110/c6a.metal.json b/duckdb-datalake/results/20261110/c6a.metal.json new file mode 100644 index 0000000000..f8bbb898a5 --- /dev/null +++ b/duckdb-datalake/results/20261110/c6a.metal.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (data lake, single)", + "date": "2026-11-10", + "machine": "c6a.metal", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 0, + "data_size": 14779976446, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.204, 0.161, 0.16], + [0.412, 0.334, 0.319], + [0.448, 0.387, 0.443], + [0.368, 0.399, 0.402], + [0.438, 0.405, 0.449], + [0.524, 0.514, 0.545], + [0.376, 0.343, 0.359], + [0.514, 0.367, 0.352], + [0.611, 0.457, 0.444], + [0.615, 0.503, 0.542], + [0.715, 0.683, 0.48], + [0.487, 0.439, 0.421], + [0.582, 0.562, 0.56], + [0.811, 0.627, 0.629], + [0.533, 0.493, 0.502], + [0.472, 0.382, 0.421], + [0.645, 0.632, 0.626], + [0.658, 0.617, 0.621], + [0.856, 0.817, 0.915], + [0.446, 0.337, 0.347], + [0.966, 1.502, 0.964], + [1.028, 1.076, 1.038], + [1.546, 1.481, 1.651], + [1.53, 1.271, 1.354], + [0.541, 0.473, 0.458], + [0.499, 0.422, 0.857], + [0.541, 0.483, 0.474], + [1.045, 0.959, 0.879], + [1.892, 1.831, 1.904], + [0.407, 0.375, 0.352], + [0.705, 0.799, 0.606], + [1.104, 0.861, 1.136], + [1.04, 0.97, 0.943], + [1.426, 1.182, 1.391], + [1.325, 1.155, 1.119], + [0.444, 0.394, 0.393], + [0.496, 0.365, 0.361], + [0.385, 0.57, 0.27], + [0.34, 0.287, 0.276], + [0.551, 0.474, 0.439], + [0.442, 0.218, 0.242], + [0.29, 0.249, 0.286], + [0.281, 0.246, 0.23] +] + } + \ No newline at end of file diff --git a/duckdb-datalake/results/20261110/c6a.xlarge.json b/duckdb-datalake/results/20261110/c6a.xlarge.json new file mode 100644 index 0000000000..fdf09b4405 --- /dev/null +++ b/duckdb-datalake/results/20261110/c6a.xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (data lake, single)", + "date": "2026-11-10", + "machine": "c6a.xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 0, + "data_size": 14779976446, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.216, 0.189, 0.15], + [0.665, 1.047, 0.593], + [1.923, 1.078, 0.975], + [0.875, 0.779, 0.782], + [1.368, 1.324, 1.362], + [2.082, 1.981, 2.025], + [1.134, 0.597, 0.764], + [0.662, 0.604, 0.597], + [1.728, 1.724, 1.7], + [2.547, 2.453, 2.423], + [1.194, 1.122, 1.121], + [1.239, 1.108, 1.114], + [2.086, 2.063, 2.001], + [2.97, 3.007, 2.995], + [2.274, 2.211, 2.171], + [1.599, 1.642, 1.696], + [3.748, 3.854, 3.709], + [3.104, 3.092, 3.087], + [7.342, 7.429, 7.381], + [0.735, 0.694, 1.141], + [4.868, 4.961, 4.731], + [4.883, 5.065, 4.778], + [11.777, 8.964, 9.772], + [2.182, 2.014, 2.487], + [0.757, 0.893, 0.729], + [1.42, 1.385, 1.309], + [0.738, 0.703, 0.715], + [4.946, 4.625, 4.656], + [36.802, 36.658, 36.092], + [0.733, 0.68, 0.674], + [2.648, 2.806, 2.729], + [3.729, 3.652, 3.716], + [7.729, 7.421, 7.555], + [8.328, 8.23, 8.673], + [8.657, 8.631, 9.033], + [1.557, 1.441, 1.423], + [0.425, 0.371, 0.375], + [0.388, 0.291, 0.329], + [0.433, 0.342, 0.287], + [0.651, 0.604, 0.524], + [0.358, 0.275, 0.268], + [0.335, 0.25, 0.298], + [0.31, 0.254, 0.256] +] + } + \ No newline at end of file diff --git a/duckdb-datalake/results/20261110/c7a.metal-48xl.json b/duckdb-datalake/results/20261110/c7a.metal-48xl.json new file mode 100644 index 0000000000..194000511f --- /dev/null +++ b/duckdb-datalake/results/20261110/c7a.metal-48xl.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (data lake, single)", + "date": "2026-11-10", + "machine": "c7a.metal-48xl", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 0, + "data_size": 14779976446, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.186, 0.176, 0.139], + [0.367, 0.292, 0.308], + [0.417, 0.375, 0.379], + [0.401, 0.381, 0.337], + [0.439, 0.405, 0.363], + [0.481, 0.477, 0.489], + [0.376, 0.301, 0.287], + [0.398, 0.287, 0.328], + [0.65, 0.471, 0.409], + [0.579, 0.519, 0.607], + [0.516, 0.402, 0.626], + [0.465, 0.403, 0.366], + [0.517, 0.497, 0.541], + [0.759, 0.53, 0.535], + [0.784, 0.448, 0.482], + [0.441, 0.396, 0.395], + [0.648, 0.587, 0.633], + [0.629, 0.827, 0.577], + [0.804, 0.71, 0.701], + [0.384, 0.587, 0.323], + [0.865, 0.856, 0.833], + [0.959, 0.851, 0.869], + [1.82, 1.367, 1.404], + [1.233, 1.242, 1.253], + [0.512, 0.48, 0.453], + [0.46, 0.429, 0.383], + [0.473, 0.439, 0.438], + [0.871, 0.856, 0.851], + [1.476, 1.487, 1.43], + [0.375, 0.37, 0.345], + [0.683, 0.624, 0.59], + [0.854, 0.82, 0.813], + [0.99, 0.84, 0.894], + [1.13, 1.063, 1.038], + [1.17, 1.039, 1.097], + [0.478, 0.358, 0.36], + [0.369, 0.357, 0.33], + [0.309, 0.311, 0.308], + [0.315, 0.259, 0.251], + [0.541, 0.422, 0.43], + [0.288, 0.253, 0.24], + [0.283, 0.276, 0.231], + [0.315, 0.244, 0.257] +] + } + \ No newline at end of file diff --git a/duckdb-datalake/results/20261110/c8g.4xlarge.json b/duckdb-datalake/results/20261110/c8g.4xlarge.json new file mode 100644 index 0000000000..8e435976bb --- /dev/null +++ b/duckdb-datalake/results/20261110/c8g.4xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (data lake, single)", + "date": "2026-11-10", + "machine": "c8g.4xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 0, + "data_size": 14779976446, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.183, 0.15, 0.162], + [0.317, 0.294, 0.251], + [0.397, 0.394, 0.4], + [0.391, 0.382, 0.323], + [0.465, 0.41, 0.41], + [0.559, 0.589, 0.618], + [0.342, 0.309, 0.323], + [0.318, 0.289, 0.266], + [0.495, 0.656, 0.502], + [0.713, 0.69, 0.807], + [0.444, 0.402, 0.456], + [0.506, 0.432, 0.427], + [0.772, 0.606, 0.562], + [0.818, 0.743, 0.871], + [0.614, 0.602, 0.611], + [0.502, 0.517, 0.481], + [0.907, 0.814, 0.819], + [0.766, 0.772, 0.755], + [1.407, 1.378, 1.361], + [0.359, 0.304, 0.351], + [1.768, 1.775, 1.81], + [2.012, 1.944, 1.982], + [3.493, 3.543, 3.531], + [1.174, 1.12, 1.182], + [0.488, 0.419, 0.415], + [0.72, 0.787, 0.634], + [0.509, 0.483, 0.607], + [1.818, 1.769, 1.79], + [5.899, 6.135, 5.936], + [0.349, 0.319, 0.296], + [0.847, 0.808, 0.788], + [1.301, 1.288, 1.26], + [1.394, 1.406, 1.444], + [1.995, 1.978, 2.006], + [2.024, 2.555, 1.957], + [0.464, 0.447, 0.394], + [0.287, 0.294, 0.292], + [0.263, 0.24, 0.273], + [0.349, 0.278, 0.226], + [0.524, 0.415, 0.421], + [0.308, 0.21, 0.233], + [0.255, 0.229, 0.248], + [0.237, 0.233, 0.215] +] + } + \ No newline at end of file diff --git a/duckdb-datalake/results/20261110/c8g.metal-48xl.json b/duckdb-datalake/results/20261110/c8g.metal-48xl.json new file mode 100644 index 0000000000..7fe992529a --- /dev/null +++ b/duckdb-datalake/results/20261110/c8g.metal-48xl.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (data lake, single)", + "date": "2026-11-10", + "machine": "c8g.metal-48xl", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 0, + "data_size": 14779976446, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.168, 0.149, 0.132], + [0.335, 0.374, 0.622], + [0.394, 0.52, 0.368], + [0.54, 0.553, 0.304], + [0.416, 0.369, 0.346], + [0.456, 0.455, 0.455], + [0.552, 0.29, 0.295], + [0.32, 0.248, 0.29], + [0.661, 0.511, 0.669], + [0.721, 0.468, 0.458], + [0.425, 0.395, 0.355], + [0.424, 0.351, 0.39], + [0.436, 0.405, 0.396], + [0.536, 0.5, 0.513], + [0.839, 0.4, 0.411], + [0.346, 0.377, 0.363], + [0.641, 0.533, 0.52], + [0.564, 0.534, 0.526], + [0.726, 0.677, 0.707], + [0.347, 0.312, 0.489], + [0.822, 1.258, 0.837], + [0.837, 0.812, 1.023], + [1.5, 1.379, 1.332], + [1.16, 1.013, 0.971], + [0.567, 0.422, 0.525], + [0.38, 0.384, 0.398], + [0.472, 0.461, 0.452], + [0.857, 0.816, 0.842], + [1.373, 1.447, 1.374], + [0.355, 0.291, 0.305], + [0.653, 0.699, 0.574], + [0.778, 0.735, 0.731], + [0.882, 0.845, 0.852], + [0.981, 0.934, 0.991], + [1.096, 0.934, 0.902], + [0.411, 0.327, 0.335], + [0.338, 0.325, 0.312], + [0.393, 0.386, 0.292], + [0.286, 0.302, 0.283], + [0.483, 0.389, 0.394], + [0.332, 0.252, 0.312], + [0.316, 0.261, 0.217], + [0.354, 0.257, 0.222] +] + } + \ No newline at end of file diff --git a/duckdb-datalake/results/20261110/t3a.small.json b/duckdb-datalake/results/20261110/t3a.small.json new file mode 100644 index 0000000000..60238a21f1 --- /dev/null +++ b/duckdb-datalake/results/20261110/t3a.small.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (data lake, single)", + "date": "2026-11-10", + "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.32, 0.24, 0.279], + [3.669, 2.245, 1.219], + [3.725, 2.528, 1.915], + [4.897, 2.05, 1.81], + [5.297, 5.237, 5.545], + [6.251, 6.396, 7.952], + [1.453, 1.149, 1.248], + [1.22, 1.122, 1.14], + [6.526, 6.382, 6.628], + [9.157, 8.949, 8.995], + [2.427, 2.431, 2.385], + [2.63, 2.483, 2.442], + [6.379, 6.353, 6.316], + [15.423, 11.476, 12.088], + [7.17, 7.394, 7.518], + [6.208, 6.115, 6.235], + [21.058, 20.773, 21.166], + [14.292, 13.871, 14.147], + [47.1, 46.457, 47.909], + [1.405, 1.446, 1.317], + [19.18, 20.722, 19.283], + [19.709, 19.633, 20.066], + [34.249, 34.33, 34.911], + [5.712, 5.586, 5.692], + [1.837, 1.744, 1.57], + [3.813, 3.787, 3.897], + [1.751, 1.783, 1.792], + [19.586, 18.939, 18.4], + [130.281, 129.946, 131.646], + [1.462, 1.295, 1.316], + [8.772, 9.375, 8.916], + [16.847, 18.49, 15.293], + [60.302, 45.951, 70.487], + [54.589, 52.443, 53.005], + [53.709, 53.45, 61.288], + [5.224, 5.174, 5.15], + [0.78, 0.746, 0.676], + [0.635, 0.545, 0.549], + [0.651, 0.547, 0.56], + [1.213, 1.043, 1.134], + [0.611, 0.478, 0.421], + [0.604, 0.488, 0.469], + [0.496, 0.403, 0.465] +] + } + \ No newline at end of file diff --git a/duckdb-iceberg/load b/duckdb-iceberg/load index 7fb63923f7..633c2c1313 100755 --- a/duckdb-iceberg/load +++ b/duckdb-iceberg/load @@ -6,9 +6,10 @@ set -e ../lib/iceberg/prepare source ../lib/iceberg/env.sh +# -no-agent: keep the plain CLI output; see ../duckdb/query. { ../lib/iceberg/substitute < attach.sql cat create.sql insert.sql -} | duckdb -init /dev/null -bail +} | duckdb -no-agent -init /dev/null -bail rm -f hits_*.parquet diff --git a/duckdb-iceberg/query b/duckdb-iceberg/query index bede7a07b5..c372e786c3 100755 --- a/duckdb-iceberg/query +++ b/duckdb-iceberg/query @@ -10,7 +10,8 @@ attach=$(../lib/iceberg/substitute < attach.sql) err=$(mktemp) trap 'rm -f "$err"' EXIT -out=$(duckdb -init /dev/null \ +# -no-agent: keep the plain CLI output; see ../duckdb/query. +out=$(duckdb -no-agent -init /dev/null \ -c "$attach" \ -c "USE lake.clickbench" \ -c ".timer on" \ diff --git a/duckdb-iceberg/results/20261110/c6a.2xlarge.json b/duckdb-iceberg/results/20261110/c6a.2xlarge.json new file mode 100644 index 0000000000..15dae09d70 --- /dev/null +++ b/duckdb-iceberg/results/20261110/c6a.2xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Iceberg)", + "date": "2026-11-10", + "machine": "c6a.2xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded"], + "load_time": 100, + "data_size": 14228192197, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.02, 0.005, 0.006], + [0.285, 0.224, 0.224], + [2.26, 0.562, 0.576], + [0.642, 0.402, 0.401], + [0.862, 0.79, 0.795], + [1.155, 1.094, 1.099], + [0.379, 0.277, 0.274], + [0.292, 0.227, 0.222], + [1.121, 1.076, 1.102], + [15.789, 2.042, 2.118], + [13.021, 0.956, 0.927], + [11.388, 0.927, 0.99], + [1.217, 1.148, 1.14], + [16.562, 1.96, 2.013], + [1.292, 1.236, 1.219], + [0.995, 0.94, 0.938], + [17.196, 2.33, 2.403], + [16.345, 2.01, 2.047], + [16.957, 3.929, 3.939], + [0.327, 0.266, 0.272], + [9.17, 2.485, 2.487], + [10.98, 2.794, 2.82], + [20.563, 5.141, 5.144], + [6.916, 1.79, 1.761], + [0.308, 0.256, 0.266], + [1.042, 0.706, 0.708], + [0.335, 0.252, 0.255], + [11.034, 2.582, 2.62], + [17.028, 16.908, 16.939], + [0.377, 0.319, 0.324], + [17.299, 2.106, 2.118], + [25.552, 3.776, 2.935], + [27.165, 20.551, 19.927], + [10.243, 5.011, 5.049], + [10.233, 5.179, 5.27], + [0.939, 0.88, 0.882], + [0.217, 0.163, 0.154], + [0.146, 0.096, 0.1], + [0.188, 0.123, 0.127], + [0.276, 0.21, 0.214], + [0.156, 0.106, 0.103], + [0.151, 0.096, 0.095], + [0.139, 0.091, 0.096] +] + } + \ No newline at end of file diff --git a/duckdb-iceberg/results/20261110/c6a.4xlarge.json b/duckdb-iceberg/results/20261110/c6a.4xlarge.json new file mode 100644 index 0000000000..b9d2406d7d --- /dev/null +++ b/duckdb-iceberg/results/20261110/c6a.4xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Iceberg)", + "date": "2026-11-10", + "machine": "c6a.4xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded"], + "load_time": 85, + "data_size": 14216565231, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.026, 0.006, 0.006], + [0.204, 0.134, 0.131], + [0.581, 0.288, 0.287], + [0.647, 0.233, 0.238], + [0.69, 0.485, 0.488], + [0.889, 0.654, 0.656], + [0.337, 0.162, 0.164], + [0.214, 0.141, 0.132], + [0.934, 0.616, 0.609], + [13.724, 1.149, 0.907], + [4.621, 0.402, 0.392], + [2.078, 0.597, 0.405], + [1.122, 0.687, 0.683], + [15.244, 1.238, 1.341], + [1.199, 0.74, 0.739], + [0.78, 0.606, 0.605], + [17.583, 1.407, 1.428], + [14.513, 1.144, 1.151], + [17.998, 2.366, 2.32], + [0.361, 0.17, 0.159], + [9.511, 1.622, 1.594], + [11.328, 1.859, 1.836], + [21.256, 3.107, 3.09], + [7.56, 1.167, 1.155], + [0.224, 0.155, 0.148], + [0.955, 0.381, 0.388], + [0.22, 0.158, 0.171], + [10.222, 1.767, 1.728], + [8.829, 8.616, 8.612], + [0.262, 0.185, 0.182], + [2.369, 1.006, 1.895], + [16.637, 1.387, 3.439], + [25.397, 3.143, 3.029], + [9.737, 2.993, 3.035], + [9.754, 3.058, 3.062], + [0.542, 0.484, 0.492], + [0.163, 0.109, 0.115], + [0.132, 0.077, 0.074], + [0.156, 0.1, 0.096], + [0.211, 0.154, 0.157], + [0.143, 0.083, 0.079], + [0.136, 0.075, 0.076], + [0.127, 0.069, 0.07] +] + } + \ No newline at end of file diff --git a/duckdb-iceberg/results/20261110/c6a.large.json b/duckdb-iceberg/results/20261110/c6a.large.json new file mode 100644 index 0000000000..1fc9527db4 --- /dev/null +++ b/duckdb-iceberg/results/20261110/c6a.large.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Iceberg)", + "date": "2026-11-10", + "machine": "c6a.large", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded"], + "load_time": 303, + "data_size": 14191367336, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.028, 0.007, 0.007], + [0.982, 0.812, 0.762], + [2.738, 2.24, 2.186], + [2.07, 1.47, 1.488], + [4.152, 4.128, 3.858], + [4.507, 4.221, 4.283], + [1.204, 1.024, 1.016], + [1.024, 0.806, 0.817], + [5.266, 5.061, 5.018], + [11.38, 12.559, 11.295], + [5.126, 4.158, 3.9], + [5.883, 4.828, 4.443], + [4.705, 4.313, 4.391], + [11.43, 13.075, 12.028], + [5.037, 4.618, 4.653], + [4.797, 4.437, 4.464], + [26.856, 23.345, 24.061], + [12.797, 12.777, 13.744], + [50.358, 50.985, 65.14], + [1.377, 0.904, 0.926], + [11.654, 11.433, 11.236], + [13.927, 15.589, 17.833], + [29.173, 27.742, 28.726], + [6.225, 5.552, 5.791], + [0.733, 0.669, 0.742], + [3.074, 2.719, 2.722], + [0.863, 0.757, 0.843], + [14.336, 13.957, 17.19], + [74.178, 73.624, 72.967], + [1.454, 1.147, 1.128], + [13.975, 11.836, 15.597], + [29.318, 27.762, 26.873], + [92.361, 79.207, 153.404], + [59.796, 55.43, 52.468], + [57.728, 51.121, 61.89], + [4.139, 3.793, 3.759], + [0.419, 0.338, 0.33], + [0.293, 0.206, 0.202], + [0.369, 0.254, 0.265], + [0.576, 0.507, 0.47], + [0.317, 0.214, 0.212], + [0.266, 0.204, 0.208], + [0.269, 0.183, 0.183] +] + } + \ No newline at end of file diff --git a/duckdb-iceberg/results/20261110/c6a.metal.json b/duckdb-iceberg/results/20261110/c6a.metal.json new file mode 100644 index 0000000000..be648e518e --- /dev/null +++ b/duckdb-iceberg/results/20261110/c6a.metal.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Iceberg)", + "date": "2026-11-10", + "machine": "c6a.metal", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded"], + "load_time": 69, + "data_size": 14198810638, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.024, 0.008, 0.007], + [0.204, 0.12, 0.144], + [0.631, 0.24, 0.2], + [1.003, 0.162, 0.162], + [1.044, 0.218, 0.211], + [1.249, 0.234, 0.249], + [0.336, 0.138, 0.141], + [0.182, 0.129, 0.118], + [1.144, 0.237, 0.232], + [2.116, 0.344, 0.355], + [1.381, 0.231, 0.235], + [1.243, 0.242, 0.245], + [1.253, 0.233, 0.252], + [2.627, 0.389, 0.38], + [1.149, 0.274, 0.251], + [1.06, 0.26, 0.245], + [2.575, 0.397, 0.39], + [2.659, 0.39, 0.398], + [5.333, 0.635, 0.622], + [0.247, 0.145, 0.131], + [9.351, 0.58, 0.575], + [11.064, 0.683, 0.695], + [19.344, 1.125, 1.131], + [44.322, 1.893, 1.716], + [3.547, 0.108, 0.134], + [1.077, 0.195, 0.187], + [3.504, 0.259, 0.136], + [9.504, 0.643, 0.646], + [9.007, 1.192, 1.14], + [0.262, 0.147, 0.145], + [2.749, 0.44, 0.465], + [6.07, 0.616, 0.677], + [4.488, 0.836, 0.844], + [9.288, 0.817, 0.779], + [9.422, 0.842, 0.805], + [1.275, 0.208, 0.218], + [0.196, 0.15, 0.146], + [0.162, 0.123, 0.119], + [0.207, 0.132, 0.136], + [0.276, 0.188, 0.184], + [0.182, 0.131, 0.134], + [0.174, 0.123, 0.125], + [0.159, 0.129, 0.111] +] + } + \ No newline at end of file diff --git a/duckdb-iceberg/results/20261110/c6a.xlarge.json b/duckdb-iceberg/results/20261110/c6a.xlarge.json new file mode 100644 index 0000000000..4d7f9959b3 --- /dev/null +++ b/duckdb-iceberg/results/20261110/c6a.xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Iceberg)", + "date": "2026-11-10", + "machine": "c6a.xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded"], + "load_time": 161, + "data_size": 14221553592, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.026, 0.006, 0.006], + [0.539, 0.401, 0.413], + [2.229, 1.07, 1.084], + [0.914, 0.733, 0.731], + [1.733, 1.571, 1.587], + [2.217, 2.058, 2.066], + [0.618, 0.535, 0.527], + [0.544, 0.417, 0.403], + [2.089, 2.019, 2.052], + [12.602, 5.288, 3.577], + [7.456, 2.105, 1.828], + [11.057, 2.117, 2.031], + [2.312, 2.15, 2.158], + [11.587, 5.43, 4.059], + [2.425, 2.283, 2.298], + [1.844, 1.744, 1.73], + [10.565, 6.469, 4.618], + [11.287, 6.488, 4.003], + [10.865, 10.321, 8.646], + [0.617, 0.479, 0.489], + [9.161, 4.716, 4.704], + [10.844, 5.376, 5.251], + [20.277, 20.45, 19.938], + [6.705, 2.986, 2.941], + [0.576, 0.501, 0.452], + [1.581, 1.345, 1.339], + [0.557, 0.47, 0.505], + [10.794, 4.787, 4.828], + [34.081, 33.641, 33.717], + [0.764, 0.581, 0.59], + [14.477, 7.302, 4.006], + [19.488, 17.623, 17.043], + [34.637, 30.343, 29.639], + [10.704, 10.513, 10.279], + [10.839, 10.324, 10.345], + [1.685, 1.619, 1.631], + [0.305, 0.216, 0.214], + [0.201, 0.122, 0.135], + [0.241, 0.167, 0.179], + [0.361, 0.305, 0.298], + [0.21, 0.136, 0.139], + [0.2, 0.113, 0.116], + [0.184, 0.108, 0.109] +] + } + \ No newline at end of file diff --git a/duckdb-iceberg/results/20261110/c7a.metal-48xl.json b/duckdb-iceberg/results/20261110/c7a.metal-48xl.json new file mode 100644 index 0000000000..b24a6fd979 --- /dev/null +++ b/duckdb-iceberg/results/20261110/c7a.metal-48xl.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Iceberg)", + "date": "2026-11-10", + "machine": "c7a.metal-48xl", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded"], + "load_time": 68, + "data_size": 14193614518, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.023, 0.009, 0.009], + [0.168, 0.136, 0.117], + [0.558, 0.169, 0.165], + [0.914, 0.151, 0.156], + [0.972, 0.187, 0.191], + [1.244, 0.214, 0.207], + [0.318, 0.116, 0.13], + [0.175, 0.122, 0.131], + [1.149, 0.206, 0.195], + [2.069, 0.327, 0.289], + [1.403, 0.213, 0.207], + [1.456, 0.223, 0.229], + [1.197, 0.219, 0.218], + [2.486, 0.312, 0.319], + [1.271, 0.224, 0.231], + [1.01, 0.21, 0.208], + [2.576, 0.348, 0.317], + [2.587, 0.325, 0.329], + [5.234, 0.515, 0.506], + [0.243, 0.137, 0.135], + [9.294, 0.477, 0.476], + [11.16, 0.543, 0.543], + [19.334, 0.871, 0.849], + [43.332, 1.38, 1.491], + [3.521, 0.123, 0.161], + [1.217, 0.156, 0.168], + [3.333, 0.154, 0.102], + [9.474, 0.529, 0.478], + [8.203, 0.853, 0.842], + [0.215, 0.123, 0.135], + [2.77, 0.393, 0.38], + [6.031, 0.536, 0.5], + [4.542, 0.728, 0.714], + [9.508, 0.603, 0.605], + [9.482, 0.607, 0.614], + [0.745, 0.169, 0.169], + [0.168, 0.13, 0.132], + [0.148, 0.104, 0.108], + [0.159, 0.124, 0.131], + [0.221, 0.172, 0.161], + [0.16, 0.116, 0.129], + [0.164, 0.122, 0.124], + [0.153, 0.125, 0.114] +] + } + \ No newline at end of file diff --git a/duckdb-iceberg/results/20261110/c8g.4xlarge.json b/duckdb-iceberg/results/20261110/c8g.4xlarge.json new file mode 100644 index 0000000000..3f8721978c --- /dev/null +++ b/duckdb-iceberg/results/20261110/c8g.4xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Iceberg)", + "date": "2026-11-10", + "machine": "c8g.4xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded"], + "load_time": 81, + "data_size": 14230008502, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.018, 0.006, 0.006], + [0.239, 0.09, 0.092], + [0.775, 0.876, 0.214], + [1.007, 0.155, 0.16], + [0.722, 0.294, 0.292], + [1.052, 0.406, 0.408], + [0.359, 0.104, 0.11], + [0.39, 0.091, 0.098], + [1.045, 0.365, 0.362], + [1.739, 0.618, 0.627], + [3.69, 0.291, 0.292], + [3.489, 0.302, 0.339], + [1.273, 0.419, 0.413], + [13.853, 0.707, 0.757], + [1.176, 0.455, 0.453], + [0.716, 0.347, 0.343], + [15.527, 0.807, 0.815], + [16.971, 0.728, 0.722], + [18.737, 1.289, 1.305], + [0.175, 0.105, 0.104], + [9.174, 0.899, 0.889], + [11.386, 1.003, 0.978], + [20.604, 1.724, 1.72], + [7.908, 0.583, 0.653], + [0.628, 0.108, 0.106], + [1.115, 0.26, 0.264], + [0.174, 0.107, 0.105], + [10.469, 0.862, 0.875], + [7.992, 4.973, 4.979], + [0.253, 0.135, 0.13], + [2.261, 0.73, 0.744], + [8.427, 2.988, 1.965], + [11.637, 10.964, 1.703], + [9.39, 1.517, 1.534], + [9.399, 1.56, 1.577], + [0.482, 0.314, 0.318], + [0.128, 0.08, 0.08], + [0.102, 0.063, 0.062], + [0.118, 0.07, 0.076], + [0.149, 0.106, 0.106], + [0.109, 0.061, 0.063], + [0.102, 0.058, 0.059], + [0.098, 0.055, 0.055] +] + } + \ No newline at end of file diff --git a/duckdb-iceberg/results/20261110/c8g.metal-48xl.json b/duckdb-iceberg/results/20261110/c8g.metal-48xl.json new file mode 100644 index 0000000000..40d6650134 --- /dev/null +++ b/duckdb-iceberg/results/20261110/c8g.metal-48xl.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Iceberg)", + "date": "2026-11-10", + "machine": "c8g.metal-48xl", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded"], + "load_time": 69, + "data_size": 14205721237, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.014, 0.006, 0.006], + [0.174, 0.094, 0.09], + [0.562, 0.12, 0.126], + [1.139, 0.103, 0.108], + [0.974, 0.136, 0.129], + [1.219, 0.161, 0.188], + [0.314, 0.095, 0.093], + [0.183, 0.091, 0.088], + [1.274, 0.159, 0.168], + [1.658, 0.253, 0.253], + [1.473, 0.179, 0.169], + [1.446, 0.166, 0.173], + [1.117, 0.16, 0.172], + [2.54, 0.283, 0.263], + [1.223, 0.186, 0.197], + [1.009, 0.175, 0.175], + [2.565, 0.256, 0.259], + [2.522, 0.272, 0.282], + [5.332, 0.427, 0.412], + [0.237, 0.104, 0.103], + [9.304, 0.367, 0.378], + [11.024, 0.449, 0.438], + [19.246, 0.692, 0.711], + [44.167, 1.204, 1.035], + [3.394, 0.14, 0.154], + [1.141, 0.132, 0.121], + [3.425, 0.138, 0.123], + [9.362, 0.395, 0.416], + [8.121, 0.74, 0.729], + [0.271, 0.101, 0.103], + [2.78, 0.339, 0.365], + [5.864, 0.53, 0.478], + [4.448, 0.621, 0.635], + [9.561, 0.498, 0.549], + [9.469, 0.55, 0.502], + [0.714, 0.145, 0.146], + [0.164, 0.112, 0.114], + [0.138, 0.087, 0.101], + [0.134, 0.095, 0.094], + [0.206, 0.13, 0.143], + [0.141, 0.091, 0.102], + [0.118, 0.091, 0.099], + [0.123, 0.085, 0.09] +] + } + \ No newline at end of file diff --git a/duckdb-iceberg/results/20261111/t3a.small.json b/duckdb-iceberg/results/20261111/t3a.small.json new file mode 100644 index 0000000000..4c0f719afa --- /dev/null +++ b/duckdb-iceberg/results/20261111/t3a.small.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Iceberg)", + "date": "2026-11-11", + "machine": "t3a.small", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded"], + "load_time": 590, + "data_size": 14199872601, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.08, 0.032, 0.022], + [2.18, 1.398, 1.477], + [5.728, 5.93, 7.174], + [3.624, 2.631, 2.68], + [8.141, 7.538, 7.561], + [8.128, 8.767, 18.456], + [2.682, 2.057, 1.881], + [1.991, 1.47, 1.467], + [10.008, 9.326, 9.29], + [34.178, 24.286, 24.116], + [13.664, 13.011, 14.507], + [13.063, 15.124, 13.003], + [9.414, 10.157, 10.188], + [93.276, 101.771, 105.213], + [14.814, 11.801, 10.976], + [9.599, 8.7, 9.412], + [118.382, 146.534, 102.371], + [130.061, 96.16, 116.237], + [147.149, 186.887, 129.326], + [3.271, 1.769, 2.156], + [34.419, 27.312, 31.435], + [30.44, 28.71, 32.785], + [61.619, 63.195, 57.825], + [28.822, 20.71, 19.79], + [2.747, 1.18, 1.743], + [5.374, 4.82, 4.748], + [1.771, 1.587, 1.515], + [30.427, 35.804, 31.599], + [151, 143.674, 142.597], + [3.082, 2.112, 2.311], + [34.617, 42.469, 45.014], + [109.441, 132.16, 90.924], + [342.18, 398.68, 368.91], + [227.041, 193.385, 148.578], + [171.538, 212.563, 162.098], + [7.878, 6.995, 7.031], + [0.774, 0.567, 0.594], + [0.507, 0.392, 0.375], + [0.678, 0.472, 0.478], + [1.076, 0.915, 0.926], + [0.611, 0.379, 0.383], + [0.5, 0.425, 0.376], + [0.537, 0.356, 0.354] +] + } + \ No newline at end of file diff --git a/duckdb-parquet-partitioned/load b/duckdb-parquet-partitioned/load index 54176f57c7..27cd88690d 100755 --- a/duckdb-parquet-partitioned/load +++ b/duckdb-parquet-partitioned/load @@ -3,5 +3,6 @@ set -e # create.sql defines a VIEW over hits_*.parquet — no ingestion happens. rm -f hits.db -duckdb hits.db -f create.sql +# -no-agent: keep the plain CLI output; see ./query. +duckdb -no-agent hits.db -f create.sql sync diff --git a/duckdb-parquet-partitioned/query b/duckdb-parquet-partitioned/query index a21f567705..cc4e0c7be2 100755 --- a/duckdb-parquet-partitioned/query +++ b/duckdb-parquet-partitioned/query @@ -7,7 +7,11 @@ set -e query=$(cat) -out=$(duckdb hits.db -c "SET parquet_metadata_cache=true" -c ".timer on" -c "$query" 2>/tmp/duckdb.err.$$) && status=0 || status=$? +# -no-agent: the 2.0 CLI turns on "agent mode" when it detects an AI coding +# agent in the environment (AI_AGENT, CLAUDECODE, CURSOR_AGENT, ...) and +# stdout is not a terminal: Markdown tables, truncated results, JSON errors +# and a progress bar. Keep the plain output regardless of who runs this. +out=$(duckdb -no-agent hits.db -c "SET parquet_metadata_cache=true" -c ".timer on" -c "$query" 2>/tmp/duckdb.err.$$) && status=0 || status=$? if [ "$status" -ne 0 ]; then cat /tmp/duckdb.err.$$ >&2 diff --git a/duckdb-parquet-partitioned/results/20261110/c6a.2xlarge.json b/duckdb-parquet-partitioned/results/20261110/c6a.2xlarge.json new file mode 100644 index 0000000000..5cbfa376b7 --- /dev/null +++ b/duckdb-parquet-partitioned/results/20261110/c6a.2xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Parquet, partitioned)", + "date": "2026-11-10", + "machine": "c6a.2xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 0, + "data_size": 14737666736, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.075, 0.031, 0.03], + [0.096, 0.048, 0.052], + [0.174, 0.127, 0.119], + [0.453, 0.134, 0.136], + [0.781, 0.55, 0.556], + [0.925, 0.827, 0.832], + [0.136, 0.085, 0.09], + [0.11, 0.049, 0.059], + [0.835, 0.741, 0.731], + [1.301, 0.961, 0.963], + [0.468, 0.212, 0.212], + [0.507, 0.238, 0.239], + [0.95, 0.848, 0.847], + [2.481, 1.276, 1.283], + [1.023, 0.922, 0.923], + [0.752, 0.685, 0.683], + [2.488, 1.735, 1.74], + [2.227, 1.357, 1.361], + [5.139, 3.05, 3.028], + [0.217, 0.069, 0.065], + [9.914, 1.468, 1.466], + [11.156, 1.309, 1.34], + [21.738, 2.495, 2.48], + [4.501, 0.606, 0.598], + [0.255, 0.152, 0.159], + [0.798, 0.45, 0.443], + [0.227, 0.165, 0.159], + [9.594, 1.242, 1.256], + [17.006, 16.906, 16.853], + [0.181, 0.117, 0.109], + [2.258, 0.904, 0.901], + [6.008, 1.101, 1.102], + [6.19, 3.236, 3.244], + [10.698, 3.331, 3.299], + [10.687, 3.393, 3.463], + [0.693, 0.63, 0.624], + [0.202, 0.112, 0.113], + [0.153, 0.087, 0.089], + [0.151, 0.063, 0.063], + [0.316, 0.196, 0.203], + [0.116, 0.049, 0.054], + [0.116, 0.043, 0.045], + [0.121, 0.05, 0.042] +] + } + \ No newline at end of file diff --git a/duckdb-parquet-partitioned/results/20261110/c6a.4xlarge.json b/duckdb-parquet-partitioned/results/20261110/c6a.4xlarge.json new file mode 100644 index 0000000000..82d7f60cb7 --- /dev/null +++ b/duckdb-parquet-partitioned/results/20261110/c6a.4xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Parquet, partitioned)", + "date": "2026-11-10", + "machine": "c6a.4xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 0, + "data_size": 14737666736, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.065, 0.03, 0.029], + [0.082, 0.04, 0.036], + [0.121, 0.078, 0.08], + [0.416, 0.093, 0.092], + [0.83, 0.364, 0.364], + [0.915, 0.527, 0.524], + [0.101, 0.065, 0.057], + [0.09, 0.041, 0.04], + [0.835, 0.462, 0.46], + [1.053, 0.584, 0.582], + [0.467, 0.144, 0.148], + [0.596, 0.158, 0.161], + [1.002, 0.532, 0.529], + [2.417, 0.872, 0.889], + [1.024, 0.587, 0.573], + [0.587, 0.466, 0.451], + [2.378, 1.071, 1.069], + [2.109, 0.812, 0.805], + [4.594, 1.921, 1.933], + [0.232, 0.065, 0.067], + [9.878, 0.851, 0.858], + [11.138, 0.868, 0.886], + [21.524, 1.65, 1.61], + [5.376, 0.495, 0.445], + [0.248, 0.118, 0.104], + [1, 0.255, 0.258], + [0.592, 0.113, 0.114], + [9.595, 0.77, 0.763], + [9.996, 9.062, 9.486], + [0.13, 0.077, 0.08], + [2.08, 0.54, 0.532], + [5.648, 0.741, 0.718], + [5.119, 2.095, 2.129], + [10.176, 2.375, 2.586], + [10.277, 2.55, 2.595], + [0.442, 0.382, 0.37], + [0.184, 0.105, 0.107], + [0.138, 0.08, 0.078], + [0.137, 0.056, 0.054], + [0.33, 0.179, 0.198], + [0.098, 0.044, 0.041], + [0.092, 0.041, 0.04], + [0.105, 0.043, 0.038] +] + } + \ No newline at end of file diff --git a/duckdb-parquet-partitioned/results/20261110/c6a.large.json b/duckdb-parquet-partitioned/results/20261110/c6a.large.json new file mode 100644 index 0000000000..fd2fc8d9da --- /dev/null +++ b/duckdb-parquet-partitioned/results/20261110/c6a.large.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Parquet, partitioned)", + "date": "2026-11-10", + "machine": "c6a.large", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 0, + "data_size": 14737666736, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.153, 0.091, 0.092], + [0.226, 0.152, 0.152], + [0.516, 0.431, 0.431], + [0.574, 0.447, 0.446], + [2.947, 2.832, 2.831], + [3.232, 3.13, 3.155], + [0.378, 0.307, 0.307], + [0.247, 0.158, 0.157], + [3.681, 3.567, 3.526], + [4.616, 4.453, 4.483], + [0.848, 0.682, 0.684], + [0.921, 0.782, 0.785], + [3.207, 3.051, 3.052], + [4.937, 4.781, 4.791], + [3.434, 3.274, 3.324], + [3.431, 3.335, 3.41], + [7.335, 7.332, 7.257], + [5.989, 5.903, 5.937], + [27.684, 28.075, 22.7], + [0.345, 0.152, 0.153], + [9.589, 5.571, 5.548], + [11.114, 4.854, 5.064], + [21.549, 13.921, 13.405], + [4.659, 1.828, 1.754], + [0.523, 0.44, 0.414], + [1.758, 1.653, 1.658], + [0.569, 0.489, 0.448], + [9.6, 4.803, 4.783], + [67.799, 67.638, 67.781], + [0.441, 0.355, 0.356], + [3.597, 3.417, 3.405], + [6.994, 4.279, 4.296], + [85.84, 28.182, 26.57], + [27.261, 25.456, 25.262], + [26.153, 25.628, 25.92], + [2.982, 2.862, 2.847], + [0.338, 0.195, 0.195], + [0.239, 0.146, 0.162], + [0.256, 0.132, 0.128], + [0.533, 0.322, 0.323], + [0.193, 0.102, 0.102], + [0.194, 0.103, 0.103], + [0.199, 0.107, 0.107] +] + } + \ No newline at end of file diff --git a/duckdb-parquet-partitioned/results/20261110/c6a.metal.json b/duckdb-parquet-partitioned/results/20261110/c6a.metal.json new file mode 100644 index 0000000000..0454383f3f --- /dev/null +++ b/duckdb-parquet-partitioned/results/20261110/c6a.metal.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Parquet, partitioned)", + "date": "2026-11-10", + "machine": "c6a.metal", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 0, + "data_size": 14737666736, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.098, 0.049, 0.043], + [0.105, 0.058, 0.048], + [0.148, 0.07, 0.065], + [0.317, 0.067, 0.073], + [0.565, 0.147, 0.131], + [0.799, 0.215, 0.184], + [0.08, 0.056, 0.051], + [0.098, 0.067, 0.07], + [0.611, 0.165, 0.149], + [0.885, 0.208, 0.201], + [0.362, 0.092, 0.098], + [0.495, 0.096, 0.093], + [0.895, 0.207, 0.228], + [2.026, 0.406, 0.419], + [0.88, 0.213, 0.2], + [0.404, 0.181, 0.181], + [2.025, 0.298, 0.289], + [2.039, 0.289, 0.283], + [3.834, 0.477, 0.47], + [0.185, 0.071, 0.064], + [9.563, 0.25, 0.253], + [10.91, 0.251, 0.232], + [21.24, 0.409, 0.411], + [14.102, 0.349, 0.321], + [1.76, 0.101, 0.1], + [0.844, 0.122, 0.125], + [1.798, 0.105, 0.099], + [9.464, 0.244, 0.242], + [8.689, 1.326, 1.336], + [0.121, 0.075, 0.067], + [2.001, 0.206, 0.201], + [5.447, 0.297, 0.303], + [4.159, 0.56, 0.58], + [9.606, 0.565, 0.561], + [9.622, 0.607, 0.565], + [0.273, 0.142, 0.145], + [0.191, 0.114, 0.112], + [0.138, 0.086, 0.085], + [0.15, 0.077, 0.078], + [0.325, 0.198, 0.199], + [0.113, 0.066, 0.058], + [0.102, 0.063, 0.074], + [0.117, 0.068, 0.065] +] + } + \ No newline at end of file diff --git a/duckdb-parquet-partitioned/results/20261110/c6a.xlarge.json b/duckdb-parquet-partitioned/results/20261110/c6a.xlarge.json new file mode 100644 index 0000000000..8d1a37a855 --- /dev/null +++ b/duckdb-parquet-partitioned/results/20261110/c6a.xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Parquet, partitioned)", + "date": "2026-11-10", + "machine": "c6a.xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 0, + "data_size": 14737666736, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.109, 0.054, 0.052], + [0.146, 0.09, 0.08], + [0.294, 0.221, 0.224], + [0.427, 0.234, 0.232], + [1.095, 1.009, 1.013], + [1.608, 1.526, 1.523], + [0.223, 0.163, 0.16], + [0.17, 0.084, 0.085], + [1.526, 1.437, 1.457], + [1.97, 1.867, 1.864], + [0.502, 0.351, 0.354], + [0.598, 0.407, 0.406], + [1.619, 1.532, 1.53], + [2.815, 2.305, 2.318], + [1.753, 1.676, 1.681], + [1.339, 1.237, 1.218], + [3.278, 3.209, 3.218], + [2.646, 2.545, 2.544], + [6.841, 6.575, 6.395], + [0.213, 0.089, 0.087], + [9.74, 2.794, 2.783], + [11.111, 2.494, 2.54], + [21.711, 4.313, 4.443], + [4.324, 1.005, 0.985], + [0.308, 0.262, 0.262], + [0.915, 0.84, 0.839], + [0.358, 0.267, 0.268], + [9.554, 2.374, 2.388], + [33.805, 33.667, 33.604], + [0.269, 0.189, 0.191], + [2.355, 1.675, 1.673], + [6.191, 1.947, 1.941], + [8.155, 7.442, 7.441], + [10.796, 8.279, 8.229], + [10.926, 8.63, 8.35], + [1.286, 1.198, 1.193], + [0.23, 0.147, 0.13], + [0.184, 0.104, 0.102], + [0.191, 0.083, 0.082], + [0.35, 0.249, 0.218], + [0.144, 0.064, 0.067], + [0.143, 0.066, 0.061], + [0.146, 0.062, 0.06] +] + } + \ No newline at end of file diff --git a/duckdb-parquet-partitioned/results/20261110/c7a.metal-48xl.json b/duckdb-parquet-partitioned/results/20261110/c7a.metal-48xl.json new file mode 100644 index 0000000000..cf0d0e3d4a --- /dev/null +++ b/duckdb-parquet-partitioned/results/20261110/c7a.metal-48xl.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Parquet, partitioned)", + "date": "2026-11-10", + "machine": "c7a.metal-48xl", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 0, + "data_size": 14737666736, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.109, 0.062, 0.053], + [0.101, 0.058, 0.059], + [0.125, 0.056, 0.052], + [0.317, 0.067, 0.064], + [0.576, 0.106, 0.114], + [0.801, 0.202, 0.194], + [0.085, 0.055, 0.053], + [0.096, 0.062, 0.055], + [0.597, 0.123, 0.116], + [0.873, 0.151, 0.163], + [0.362, 0.096, 0.087], + [0.495, 0.093, 0.096], + [0.884, 0.171, 0.176], + [1.991, 0.327, 0.316], + [0.862, 0.182, 0.213], + [0.381, 0.143, 0.141], + [1.98, 0.23, 0.234], + [2.011, 0.235, 0.248], + [3.81, 0.352, 0.427], + [0.153, 0.075, 0.066], + [9.595, 0.223, 0.244], + [10.91, 0.227, 0.207], + [21.219, 0.334, 0.304], + [14.101, 0.292, 0.297], + [1.091, 0.472, 0.095], + [1.098, 0.113, 0.11], + [0.171, 0.661, 0.094], + [9.802, 0.226, 0.197], + [8.449, 0.927, 0.907], + [0.124, 0.063, 0.065], + [1.971, 0.185, 0.199], + [5.404, 0.247, 0.275], + [4.071, 0.49, 0.477], + [9.579, 0.484, 0.461], + [9.589, 0.477, 0.442], + [0.189, 0.122, 0.118], + [0.175, 0.107, 0.105], + [0.138, 0.075, 0.075], + [0.138, 0.07, 0.078], + [0.349, 0.189, 0.182], + [0.145, 0.064, 0.054], + [0.133, 0.066, 0.064], + [0.138, 0.066, 0.067] +] + } + \ No newline at end of file diff --git a/duckdb-parquet-partitioned/results/20261110/c8g.4xlarge.json b/duckdb-parquet-partitioned/results/20261110/c8g.4xlarge.json new file mode 100644 index 0000000000..ee2ad52474 --- /dev/null +++ b/duckdb-parquet-partitioned/results/20261110/c8g.4xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Parquet, partitioned)", + "date": "2026-11-10", + "machine": "c8g.4xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 0, + "data_size": 14737666736, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.042, 0.026, 0.024], + [0.049, 0.029, 0.028], + [0.085, 0.056, 0.067], + [0.399, 0.069, 0.063], + [0.898, 0.184, 0.183], + [0.926, 0.293, 0.299], + [0.055, 0.047, 0.039], + [0.071, 0.028, 0.031], + [0.723, 0.25, 0.241], + [0.987, 0.335, 0.335], + [0.424, 0.093, 0.092], + [0.807, 0.109, 0.098], + [1.156, 0.297, 0.306], + [2.155, 0.44, 0.462], + [0.935, 0.327, 0.334], + [0.472, 0.228, 0.237], + [2.165, 0.541, 0.551], + [2.042, 0.464, 0.459], + [4.071, 0.943, 0.938], + [0.193, 0.039, 0.036], + [10.049, 0.561, 0.559], + [11.101, 0.523, 0.497], + [21.583, 0.863, 0.882], + [5.041, 0.768, 0.276], + [0.329, 0.076, 0.074], + [1.211, 0.177, 0.175], + [0.314, 0.095, 0.08], + [10.151, 0.452, 0.455], + [8.834, 5.06, 5.119], + [0.105, 0.059, 0.06], + [1.996, 0.331, 0.324], + [5.531, 0.377, 0.38], + [4.369, 0.908, 0.894], + [9.777, 1.069, 1.079], + [9.788, 1.091, 1.093], + [0.267, 0.211, 0.208], + [0.148, 0.081, 0.09], + [0.111, 0.078, 0.07], + [0.111, 0.051, 0.053], + [0.252, 0.164, 0.15], + [0.067, 0.034, 0.036], + [0.062, 0.033, 0.03], + [0.068, 0.039, 0.03] +] + } + \ No newline at end of file diff --git a/duckdb-parquet-partitioned/results/20261110/c8g.metal-48xl.json b/duckdb-parquet-partitioned/results/20261110/c8g.metal-48xl.json new file mode 100644 index 0000000000..98c79187f2 --- /dev/null +++ b/duckdb-parquet-partitioned/results/20261110/c8g.metal-48xl.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Parquet, partitioned)", + "date": "2026-11-10", + "machine": "c8g.metal-48xl", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 0, + "data_size": 14737666736, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.073, 0.043, 0.035], + [0.067, 0.042, 0.042], + [0.107, 0.046, 0.057], + [0.306, 0.062, 0.063], + [0.7, 0.105, 0.107], + [0.872, 0.177, 0.171], + [0.065, 0.033, 0.044], + [0.095, 0.053, 0.052], + [0.676, 0.111, 0.122], + [0.857, 0.134, 0.15], + [0.683, 0.074, 0.078], + [0.631, 0.075, 0.083], + [0.763, 0.16, 0.181], + [1.973, 0.217, 0.211], + [0.847, 0.163, 0.159], + [0.36, 0.13, 0.129], + [1.975, 0.21, 0.22], + [1.963, 0.218, 0.217], + [3.786, 0.363, 0.356], + [0.208, 0.066, 0.062], + [9.616, 0.23, 0.236], + [10.91, 0.192, 0.216], + [21.213, 0.317, 0.318], + [14.118, 0.318, 0.255], + [1.751, 0.092, 0.103], + [0.938, 0.09, 0.1], + [1.945, 0.089, 0.105], + [9.633, 0.188, 0.214], + [8.572, 0.93, 0.94], + [0.138, 0.057, 0.064], + [1.961, 0.179, 0.165], + [5.393, 0.249, 0.222], + [4.026, 0.412, 0.391], + [9.579, 0.411, 0.413], + [9.538, 0.403, 0.408], + [0.266, 0.108, 0.116], + [0.172, 0.093, 0.087], + [0.123, 0.071, 0.071], + [0.147, 0.056, 0.048], + [0.303, 0.157, 0.161], + [0.103, 0.063, 0.051], + [0.101, 0.052, 0.062], + [0.079, 0.052, 0.051] +] + } + \ No newline at end of file diff --git a/duckdb-parquet-partitioned/results/20261110/t3a.small.json b/duckdb-parquet-partitioned/results/20261110/t3a.small.json new file mode 100644 index 0000000000..a9ec046fed --- /dev/null +++ b/duckdb-parquet-partitioned/results/20261110/t3a.small.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Parquet, partitioned)", + "date": "2026-11-10", + "machine": "t3a.small", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 0, + "data_size": 14737666736, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.244, 0.162, 0.163], + [0.361, 0.265, 0.261], + [0.866, 0.746, 0.741], + [0.937, 0.784, 0.783], + [5.196, 4.844, 4.846], + [5.393, 5.402, 5.371], + [0.616, 0.527, 0.528], + [0.378, 0.271, 0.275], + [6.691, 6.276, 6.145], + [7.832, 7.871, 7.786], + [1.397, 1.208, 1.238], + [1.607, 1.416, 1.423], + [5.571, 5.561, 5.417], + [9.713, 9.48, 9.219], + [6.222, 6.183, 5.929], + [6.329, 5.89, 5.759], + [25.026, 20.767, 21.6], + [13.667, 13.701, 13.791], + [51.745, 45.898, 46.747], + [0.723, 0.278, 0.271], + [11.992, 9.858, 10.214], + [11.494, 11.938, 11.952], + [21.885, 22.356, 22.876], + [4.568, 3.33, 3.878], + [0.901, 0.723, 0.748], + [2.825, 2.678, 2.67], + [0.902, 0.762, 0.783], + [9.826, 10.388, 10.47], + [120.299, 120.204, 120.423], + [0.721, 0.617, 0.616], + [6.09, 5.708, 5.744], + [7.956, 7.984, 8.065], + [63.659, 43.807, 57.518], + [45.361, 45.596, 46.435], + [75.511, 46.812, 45.925], + [4.958, 4.689, 4.713], + [0.448, 0.32, 0.316], + [0.362, 0.251, 0.239], + [0.36, 0.22, 0.223], + [0.733, 0.56, 0.556], + [0.276, 0.174, 0.177], + [0.277, 0.181, 0.175], + [0.287, 0.184, 0.187] +] + } + \ No newline at end of file diff --git a/duckdb-parquet/load b/duckdb-parquet/load index 99b8db36e2..5582a40a41 100755 --- a/duckdb-parquet/load +++ b/duckdb-parquet/load @@ -5,5 +5,6 @@ set -e # parquet file is read in place at query time. We persist the view in # hits.db so subsequent query invocations see it. rm -f hits.db -duckdb hits.db -f create.sql +# -no-agent: keep the plain CLI output; see ./query. +duckdb -no-agent hits.db -f create.sql sync diff --git a/duckdb-parquet/query b/duckdb-parquet/query index 46a748cb7e..47e0d2cf6c 100755 --- a/duckdb-parquet/query +++ b/duckdb-parquet/query @@ -7,7 +7,11 @@ set -e query=$(cat) -out=$(duckdb hits.db -c "SET parquet_metadata_cache=true" -c ".timer on" -c "$query" 2>/tmp/duckdb.err.$$) && status=0 || status=$? +# -no-agent: the 2.0 CLI turns on "agent mode" when it detects an AI coding +# agent in the environment (AI_AGENT, CLAUDECODE, CURSOR_AGENT, ...) and +# stdout is not a terminal: Markdown tables, truncated results, JSON errors +# and a progress bar. Keep the plain output regardless of who runs this. +out=$(duckdb -no-agent hits.db -c "SET parquet_metadata_cache=true" -c ".timer on" -c "$query" 2>/tmp/duckdb.err.$$) && status=0 || status=$? if [ "$status" -ne 0 ]; then cat /tmp/duckdb.err.$$ >&2 diff --git a/duckdb-parquet/results/20261110/c6a.2xlarge.json b/duckdb-parquet/results/20261110/c6a.2xlarge.json new file mode 100644 index 0000000000..3aa92e6bb0 --- /dev/null +++ b/duckdb-parquet/results/20261110/c6a.2xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Parquet, single)", + "date": "2026-11-10", + "machine": "c6a.2xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 0, + "data_size": 14779976446, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.11, 0.055, 0.055], + [0.138, 0.078, 0.077], + [0.186, 0.121, 0.121], + [0.276, 0.197, 0.196], + [0.662, 0.557, 0.552], + [1.052, 0.869, 0.871], + [0.148, 0.084, 0.084], + [0.164, 0.081, 0.08], + [0.786, 0.677, 0.685], + [1.023, 0.896, 0.895], + [0.403, 0.238, 0.234], + [0.457, 0.264, 0.265], + [0.972, 0.876, 0.875], + [2.318, 1.307, 1.288], + [1.067, 0.953, 0.951], + [0.748, 0.644, 0.648], + [2.36, 1.697, 1.672], + [1.998, 1.321, 1.321], + [4.956, 3.026, 3.045], + [0.287, 0.096, 0.097], + [9.522, 1.549, 1.515], + [11.038, 1.443, 1.413], + [21.695, 2.473, 2.527], + [3.234, 0.628, 0.614], + [0.381, 0.211, 0.211], + [0.739, 0.489, 0.487], + [0.438, 0.223, 0.22], + [9.568, 1.299, 1.299], + [17.985, 17.476, 17.489], + [0.196, 0.121, 0.122], + [2.122, 0.943, 0.944], + [5.619, 2.368, 1.148], + [5.719, 3.263, 3.317], + [10.552, 3.299, 3.394], + [10.716, 3.67, 3.729], + [0.713, 0.609, 0.612], + [0.27, 0.153, 0.159], + [0.212, 0.123, 0.123], + [0.226, 0.106, 0.099], + [0.44, 0.27, 0.267], + [0.185, 0.081, 0.079], + [0.161, 0.073, 0.077], + [0.161, 0.084, 0.078] +] + } + \ No newline at end of file diff --git a/duckdb-parquet/results/20261110/c6a.4xlarge.json b/duckdb-parquet/results/20261110/c6a.4xlarge.json new file mode 100644 index 0000000000..1163532ad5 --- /dev/null +++ b/duckdb-parquet/results/20261110/c6a.4xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Parquet, single)", + "date": "2026-11-10", + "machine": "c6a.4xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 0, + "data_size": 14779976446, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.105, 0.056, 0.056], + [0.124, 0.069, 0.07], + [0.162, 0.095, 0.097], + [0.404, 0.142, 0.142], + [0.52, 0.38, 0.381], + [0.941, 0.56, 0.547], + [0.132, 0.072, 0.074], + [0.139, 0.071, 0.071], + [0.688, 0.454, 0.45], + [0.939, 0.564, 0.574], + [0.34, 0.18, 0.18], + [0.378, 0.194, 0.198], + [0.807, 0.563, 0.572], + [2.263, 1.706, 0.938], + [0.91, 0.625, 0.621], + [0.557, 0.438, 0.434], + [2.235, 1.075, 1.061], + [2.01, 0.816, 0.817], + [4.378, 1.95, 1.944], + [0.245, 0.099, 0.099], + [9.556, 0.921, 0.927], + [11.038, 0.962, 0.965], + [21.63, 1.668, 1.742], + [4.617, 0.926, 0.528], + [0.416, 0.21, 0.184], + [0.951, 0.294, 0.294], + [0.512, 0.193, 0.194], + [9.615, 0.855, 0.861], + [11.257, 9.654, 9.107], + [0.162, 0.099, 0.098], + [2.294, 0.583, 0.583], + [5.649, 0.809, 0.798], + [5.088, 2.151, 2.136], + [10.075, 2.429, 2.451], + [10.156, 2.536, 2.55], + [0.498, 0.394, 0.39], + [0.258, 0.153, 0.161], + [0.207, 0.124, 0.124], + [0.205, 0.105, 0.104], + [0.421, 0.277, 0.266], + [0.202, 0.08, 0.079], + [0.178, 0.076, 0.074], + [0.173, 0.081, 0.078] +] + } + \ No newline at end of file diff --git a/duckdb-parquet/results/20261110/c6a.large.json b/duckdb-parquet/results/20261110/c6a.large.json new file mode 100644 index 0000000000..873935020e --- /dev/null +++ b/duckdb-parquet/results/20261110/c6a.large.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Parquet, single)", + "date": "2026-11-10", + "machine": "c6a.large", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 0, + "data_size": 14779976446, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.099, 0.056, 0.057], + [0.191, 0.135, 0.135], + [0.38, 0.295, 0.297], + [0.672, 0.561, 0.559], + [2.726, 2.613, 2.608], + [3.208, 3.078, 3.105], + [0.229, 0.154, 0.154], + [0.233, 0.142, 0.141], + [3.273, 3.09, 3.111], + [4.116, 3.902, 3.95], + [0.789, 0.631, 0.628], + [0.897, 0.754, 0.734], + [3.123, 3.002, 2.991], + [4.866, 4.67, 4.667], + [3.405, 3.245, 3.269], + [3.086, 2.943, 2.973], + [6.92, 6.815, 6.958], + [5.734, 5.566, 5.624], + [20.766, 32.506, 19.992], + [0.34, 0.139, 0.14], + [9.576, 5.744, 5.735], + [11.101, 5.029, 5.289], + [21.73, 13.95, 13.343], + [3.451, 1.779, 1.754], + [0.615, 0.541, 0.536], + [1.786, 1.674, 1.679], + [0.715, 0.568, 0.569], + [9.547, 4.799, 4.804], + [69.234, 68.426, 68.909], + [0.342, 0.258, 0.257], + [3.573, 3.365, 3.371], + [6.264, 4.222, 4.219], + [28.094, 27.382, 26.167], + [23.599, 22.34, 22.678], + [25.333, 25.673, 25.961], + [2.645, 2.525, 2.504], + [0.316, 0.192, 0.177], + [0.234, 0.153, 0.156], + [0.283, 0.112, 0.111], + [0.505, 0.314, 0.352], + [0.221, 0.086, 0.086], + [0.184, 0.08, 0.079], + [0.183, 0.085, 0.085] +] + } + \ No newline at end of file diff --git a/duckdb-parquet/results/20261110/c6a.metal.json b/duckdb-parquet/results/20261110/c6a.metal.json new file mode 100644 index 0000000000..1ca45c45c4 --- /dev/null +++ b/duckdb-parquet/results/20261110/c6a.metal.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Parquet, single)", + "date": "2026-11-10", + "machine": "c6a.metal", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 0, + "data_size": 14779976446, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.108, 0.053, 0.054], + [0.131, 0.078, 0.076], + [0.19, 0.085, 0.083], + [0.479, 0.1, 0.098], + [0.467, 0.155, 0.153], + [0.769, 0.236, 0.239], + [0.138, 0.077, 0.076], + [0.155, 0.081, 0.081], + [0.614, 0.182, 0.18], + [0.854, 0.224, 0.219], + [0.637, 0.125, 0.119], + [0.541, 0.123, 0.122], + [0.885, 0.248, 0.249], + [2.095, 0.391, 0.303], + [0.882, 0.29, 0.259], + [0.373, 0.174, 0.179], + [1.962, 0.327, 0.327], + [1.955, 0.313, 0.315], + [3.726, 0.445, 0.461], + [0.282, 0.092, 0.09], + [9.45, 0.275, 0.296], + [10.929, 0.262, 0.268], + [21.42, 0.429, 0.408], + [12.581, 0.332, 0.337], + [2.285, 0.138, 0.14], + [0.681, 0.146, 0.15], + [2.287, 0.136, 0.135], + [9.454, 0.262, 0.256], + [8.875, 1.39, 1.448], + [0.201, 0.097, 0.093], + [1.979, 0.232, 0.228], + [5.331, 0.324, 0.3], + [3.993, 0.579, 0.579], + [9.77, 0.57, 0.571], + [9.744, 0.569, 0.591], + [0.338, 0.169, 0.16], + [0.323, 0.171, 0.173], + [0.242, 0.137, 0.141], + [0.27, 0.127, 0.122], + [0.507, 0.274, 0.27], + [0.205, 0.097, 0.1], + [0.18, 0.094, 0.09], + [0.175, 0.095, 0.094] +] + } + \ No newline at end of file diff --git a/duckdb-parquet/results/20261110/c6a.xlarge.json b/duckdb-parquet/results/20261110/c6a.xlarge.json new file mode 100644 index 0000000000..f84cfeaf63 --- /dev/null +++ b/duckdb-parquet/results/20261110/c6a.xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Parquet, single)", + "date": "2026-11-10", + "machine": "c6a.xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 0, + "data_size": 14779976446, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.098, 0.056, 0.056], + [0.146, 0.096, 0.096], + [0.24, 0.181, 0.182], + [0.411, 0.318, 0.32], + [1.065, 0.946, 0.944], + [1.672, 1.578, 1.583], + [0.178, 0.107, 0.106], + [0.187, 0.102, 0.1], + [1.387, 1.266, 1.271], + [1.825, 1.693, 1.687], + [0.519, 0.365, 0.37], + [1.19, 0.42, 0.42], + [1.642, 1.551, 1.562], + [2.621, 2.303, 2.285], + [1.813, 1.721, 1.726], + [1.297, 1.171, 1.179], + [3.216, 3.052, 3.077], + [2.541, 2.413, 2.45], + [6.432, 6.34, 6.292], + [0.283, 0.111, 0.113], + [9.621, 2.885, 2.942], + [11.093, 2.571, 2.54], + [21.709, 4.401, 4.465], + [3.056, 1, 0.975], + [0.443, 0.354, 0.452], + [1.023, 0.882, 0.887], + [0.455, 0.342, 0.339], + [9.646, 2.415, 2.418], + [34.885, 34.762, 34.731], + [0.247, 0.167, 0.165], + [2.166, 1.713, 1.719], + [5.744, 1.965, 1.982], + [8.084, 6.955, 6.998], + [10.703, 8.518, 7.943], + [10.999, 8.553, 8.341], + [1.205, 1.119, 1.115], + [0.294, 0.165, 0.157], + [0.231, 0.133, 0.131], + [0.243, 0.109, 0.107], + [0.468, 0.285, 0.287], + [0.194, 0.079, 0.085], + [0.172, 0.076, 0.076], + [0.172, 0.083, 0.085] +] + } + \ No newline at end of file diff --git a/duckdb-parquet/results/20261110/c7a.metal-48xl.json b/duckdb-parquet/results/20261110/c7a.metal-48xl.json new file mode 100644 index 0000000000..8267ea9298 --- /dev/null +++ b/duckdb-parquet/results/20261110/c7a.metal-48xl.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Parquet, single)", + "date": "2026-11-10", + "machine": "c7a.metal-48xl", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 0, + "data_size": 14779976446, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.1, 0.047, 0.05], + [0.116, 0.07, 0.068], + [0.151, 0.072, 0.074], + [0.278, 0.085, 0.086], + [0.415, 0.123, 0.123], + [0.748, 0.209, 0.211], + [0.121, 0.069, 0.071], + [0.133, 0.073, 0.072], + [0.654, 0.141, 0.137], + [0.804, 0.17, 0.178], + [0.32, 0.105, 0.105], + [0.408, 0.107, 0.11], + [0.756, 0.219, 0.211], + [2.029, 0.244, 0.354], + [0.849, 0.237, 0.231], + [0.35, 0.133, 0.134], + [1.909, 0.257, 0.253], + [1.917, 0.253, 0.261], + [3.58, 0.336, 0.347], + [0.366, 0.08, 0.084], + [9.463, 0.254, 0.242], + [10.912, 0.238, 0.279], + [21.381, 0.324, 0.388], + [12.519, 0.341, 0.303], + [2.272, 0.108, 0.118], + [0.68, 0.124, 0.134], + [2.252, 0.121, 0.128], + [9.418, 0.252, 0.228], + [8.495, 0.897, 0.883], + [0.182, 0.083, 0.085], + [1.941, 0.202, 0.204], + [5.291, 0.284, 0.273], + [3.896, 0.483, 0.469], + [9.717, 0.458, 0.473], + [9.734, 0.477, 0.473], + [0.393, 0.129, 0.123], + [0.292, 0.15, 0.149], + [0.216, 0.128, 0.126], + [0.241, 0.099, 0.103], + [0.454, 0.257, 0.257], + [0.184, 0.089, 0.086], + [0.164, 0.084, 0.082], + [0.17, 0.083, 0.085] +] + } + \ No newline at end of file diff --git a/duckdb-parquet/results/20261110/c8g.4xlarge.json b/duckdb-parquet/results/20261110/c8g.4xlarge.json new file mode 100644 index 0000000000..2a9e709f48 --- /dev/null +++ b/duckdb-parquet/results/20261110/c8g.4xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Parquet, single)", + "date": "2026-11-10", + "machine": "c8g.4xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 0, + "data_size": 14779976446, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.07, 0.05, 0.051], + [0.083, 0.062, 0.06], + [0.112, 0.085, 0.082], + [0.249, 0.107, 0.106], + [0.724, 0.217, 0.222], + [0.775, 0.333, 0.341], + [0.087, 0.064, 0.062], + [0.088, 0.061, 0.06], + [0.563, 0.272, 0.273], + [0.807, 0.357, 0.356], + [0.282, 0.128, 0.124], + [0.645, 0.138, 0.14], + [1.005, 0.344, 0.344], + [2.036, 0.491, 0.487], + [0.793, 0.376, 0.373], + [0.332, 0.255, 0.253], + [2.143, 0.584, 0.587], + [1.922, 0.489, 0.503], + [3.871, 1.02, 1.023], + [0.152, 0.068, 0.067], + [9.884, 0.624, 0.624], + [10.991, 0.556, 0.557], + [21.581, 0.903, 0.925], + [4.602, 0.834, 0.312], + [0.543, 0.119, 0.114], + [1.133, 0.207, 0.206], + [0.536, 0.128, 0.132], + [10.073, 0.498, 0.503], + [8.71, 5.687, 5.523], + [0.114, 0.083, 0.084], + [2.144, 0.371, 0.367], + [5.351, 0.426, 0.419], + [4.348, 0.959, 0.951], + [9.73, 1.144, 1.161], + [9.734, 1.188, 1.185], + [0.292, 0.242, 0.239], + [0.195, 0.126, 0.13], + [0.156, 0.115, 0.115], + [0.158, 0.089, 0.088], + [0.323, 0.211, 0.21], + [0.147, 0.07, 0.068], + [0.119, 0.067, 0.066], + [0.117, 0.071, 0.068] +] + } + \ No newline at end of file diff --git a/duckdb-parquet/results/20261110/c8g.metal-48xl.json b/duckdb-parquet/results/20261110/c8g.metal-48xl.json new file mode 100644 index 0000000000..727a774208 --- /dev/null +++ b/duckdb-parquet/results/20261110/c8g.metal-48xl.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Parquet, single)", + "date": "2026-11-10", + "machine": "c8g.metal-48xl", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 0, + "data_size": 14779976446, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.074, 0.051, 0.05], + [0.093, 0.059, 0.064], + [0.128, 0.068, 0.068], + [0.376, 0.08, 0.076], + [0.692, 0.122, 0.119], + [0.72, 0.193, 0.196], + [0.094, 0.063, 0.062], + [0.103, 0.061, 0.064], + [0.56, 0.141, 0.139], + [0.829, 0.162, 0.171], + [0.307, 0.096, 0.094], + [0.433, 0.095, 0.104], + [0.911, 0.201, 0.203], + [1.96, 0.317, 0.231], + [0.813, 0.209, 0.228], + [0.345, 0.126, 0.129], + [1.892, 0.236, 0.226], + [1.885, 0.236, 0.235], + [3.577, 0.318, 0.318], + [0.489, 0.071, 0.075], + [9.418, 0.258, 0.255], + [10.901, 0.227, 0.235], + [21.497, 0.377, 0.374], + [12.504, 0.287, 0.319], + [2.23, 0.106, 0.117], + [0.814, 0.123, 0.12], + [2.374, 0.118, 0.116], + [9.602, 0.235, 0.211], + [8.558, 0.895, 0.893], + [0.137, 0.076, 0.076], + [1.892, 0.185, 0.186], + [5.255, 0.255, 0.243], + [3.894, 0.432, 0.423], + [9.631, 0.431, 0.435], + [9.676, 0.436, 0.448], + [0.243, 0.122, 0.118], + [0.248, 0.139, 0.144], + [0.178, 0.122, 0.128], + [0.214, 0.098, 0.092], + [0.445, 0.23, 0.227], + [0.155, 0.076, 0.078], + [0.127, 0.074, 0.072], + [0.121, 0.08, 0.079] +] + } + \ No newline at end of file diff --git a/duckdb-parquet/results/20261110/t3a.small.json b/duckdb-parquet/results/20261110/t3a.small.json new file mode 100644 index 0000000000..2ce36b9ece --- /dev/null +++ b/duckdb-parquet/results/20261110/t3a.small.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Parquet, single)", + "date": "2026-11-10", + "machine": "t3a.small", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 0, + "data_size": 14779976446, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.188, 0.127, 0.124], + [0.307, 0.258, 0.258], + [0.662, 0.565, 0.57], + [1.121, 0.98, 0.992], + [4.513, 4.31, 4.186], + [5.19, 5.001, 5.074], + [0.386, 0.309, 0.308], + [0.362, 0.269, 0.279], + [5.575, 5.459, 5.343], + [6.88, 6.791, 6.612], + [1.366, 1.177, 1.149], + [1.566, 1.394, 1.37], + [5.332, 5.066, 5.113], + [9.008, 9.076, 9.063], + [5.901, 5.816, 5.726], + [5.022, 5.04, 4.84], + [20.519, 19.25, 18.494], + [12.413, 12.14, 12.536], + [42.396, 41.128, 41.184], + [0.472, 0.276, 0.277], + [9.912, 10.129, 10.248], + [11.359, 11.772, 11.835], + [22.201, 22.491, 22.516], + [3.593, 2.9, 3.038], + [1.072, 0.911, 0.911], + [2.856, 2.713, 2.714], + [1.113, 0.964, 0.974], + [9.839, 10.244, 10.229], + [122.216, 123.998, 123.718], + [0.582, 0.485, 0.489], + [5.891, 5.668, 5.634], + [7.57, 7.757, 7.6], + [74.908, 44.886, 54.739], + [44.616, 44.398, 53.207], + [46.387, 47.255, 45.636], + [4.92, 4.256, 4.233], + [0.482, 0.346, 0.351], + [0.4, 0.282, 0.28], + [0.376, 0.213, 0.214], + [0.713, 0.546, 0.562], + [0.313, 0.172, 0.173], + [0.27, 0.168, 0.167], + [0.292, 0.178, 0.177] +] + } + \ No newline at end of file diff --git a/duckdb-vortex-tuned/load b/duckdb-vortex-tuned/load index d9ef669ba3..28f765321f 100755 --- a/duckdb-vortex-tuned/load +++ b/duckdb-vortex-tuned/load @@ -7,11 +7,12 @@ set -e # https://github.com/vortex-data/vortex/issues/10046 for the full # investigation and raw evidence). `threads=2` is the largest thread # count that completed in our testing; default (`threads=4`) OOMs. -duckdb -c "LOAD vortex; SET threads = 2; COPY 'hits.parquet' TO 'hits.vortex' (FORMAT vortex);" +# -no-agent: keep the plain CLI output; see ./query. +duckdb -no-agent -c "LOAD vortex; SET threads = 2; COPY 'hits.parquet' TO 'hits.vortex' (FORMAT vortex);" # Create the persistent VIEW (over hits.vortex) in hits.db. rm -f hits.db -duckdb hits.db -f create.sql +duckdb -no-agent hits.db -f create.sql # Source parquet no longer needed. rm -f hits.parquet diff --git a/duckdb-vortex-tuned/query b/duckdb-vortex-tuned/query index 5eef5331ae..8b779c03bb 100755 --- a/duckdb-vortex-tuned/query +++ b/duckdb-vortex-tuned/query @@ -7,7 +7,11 @@ set -e query=$(cat) -out=$(duckdb hits.db -c "LOAD vortex;" -c ".timer on" -c "$query" 2>/tmp/duckdb.err.$$) && status=0 || status=$? +# -no-agent: the 2.0 CLI turns on "agent mode" when it detects an AI coding +# agent in the environment (AI_AGENT, CLAUDECODE, CURSOR_AGENT, ...) and +# stdout is not a terminal: Markdown tables, truncated results, JSON errors +# and a progress bar. Keep the plain output regardless of who runs this. +out=$(duckdb -no-agent hits.db -c "LOAD vortex;" -c ".timer on" -c "$query" 2>/tmp/duckdb.err.$$) && status=0 || status=$? if [ "$status" -ne 0 ]; then cat /tmp/duckdb.err.$$ >&2 diff --git a/duckdb-vortex-tuned/results/20261110/c6a.2xlarge.json b/duckdb-vortex-tuned/results/20261110/c6a.2xlarge.json new file mode 100644 index 0000000000..db55d4441c --- /dev/null +++ b/duckdb-vortex-tuned/results/20261110/c6a.2xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Vortex, single, load threads=2)", + "date": "2026-11-10", + "machine": "c6a.2xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "yes", + "tags": ["Rust","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 1182, + "data_size": 12263181092, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.045, 0.018, 0.018], + [0.081, 0.045, 0.045], + [0.284, 0.056, 0.054], + [0.656, 0.199, 0.204], + [1.023, 0.561, 0.563], + [0.994, 0.656, 0.666], + [0.07, 0.036, 0.035], + [0.102, 0.05, 0.049], + [1.293, 0.688, 0.683], + [1.531, 0.882, 0.879], + [0.754, 0.228, 0.225], + [0.804, 0.268, 0.272], + [1.018, 0.681, 0.693], + [2.667, 1.222, 1.217], + [1.251, 0.81, 0.816], + [1.087, 0.65, 0.655], + [2.62, 1.587, 1.563], + [2.292, 1.229, 1.22], + [4.335, 2.809, 2.878], + [0.403, 0.09, 0.091], + [10.273, 1.081, 1.055], + [13.331, 2.051, 2.045], + [16.797, 3.2, 3.188], + [1.79, 0.254, 0.254], + [0.264, 0.068, 0.065], + [0.807, 0.313, 0.316], + [0.279, 0.1, 0.095], + [11.6, 1.168, 1.191], + [11.154, 9.927, 9.915], + [0.277, 0.062, 0.062], + [2.248, 0.569, 0.571], + [5.371, 0.75, 0.744], + [5.399, 2.962, 3.115], + [12.355, 8.603, 8.293], + [12.407, 10.142, 10.005], + [1.172, 0.543, 0.56], + [0.231, 0.136, 0.144], + [0.125, 0.076, 0.067], + [0.212, 0.124, 0.124], + [0.44, 0.319, 0.326], + [0.128, 0.047, 0.047], + [0.112, 0.04, 0.04], + [0.106, 0.042, 0.043] +] + } + \ No newline at end of file diff --git a/duckdb-vortex-tuned/results/20261110/c6a.4xlarge.json b/duckdb-vortex-tuned/results/20261110/c6a.4xlarge.json new file mode 100644 index 0000000000..910619ad2c --- /dev/null +++ b/duckdb-vortex-tuned/results/20261110/c6a.4xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Vortex, single, load threads=2)", + "date": "2026-11-10", + "machine": "c6a.4xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "yes", + "tags": ["Rust","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 728, + "data_size": 12263181092, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.056, 0.018, 0.018], + [0.076, 0.034, 0.034], + [0.265, 0.046, 0.048], + [0.56, 0.124, 0.126], + [0.7, 0.356, 0.365], + [0.834, 0.448, 0.447], + [0.072, 0.031, 0.031], + [0.098, 0.038, 0.039], + [1.049, 0.44, 0.435], + [1.312, 0.564, 0.56], + [0.598, 0.155, 0.16], + [0.662, 0.187, 0.179], + [0.862, 0.517, 0.513], + [2.507, 0.858, 0.858], + [1.016, 0.547, 0.544], + [0.711, 0.417, 0.421], + [2.492, 1.012, 1.026], + [2.217, 0.786, 0.78], + [3.966, 1.887, 1.852], + [0.288, 0.065, 0.066], + [10.256, 0.737, 0.745], + [13.209, 1.315, 1.328], + [16.651, 2.113, 2.108], + [1.739, 0.19, 0.188], + [0.219, 0.068, 0.058], + [0.703, 0.205, 0.203], + [0.229, 0.079, 0.081], + [11.562, 0.845, 0.838], + [9.741, 5.399, 5.343], + [0.272, 0.057, 0.057], + [2.199, 0.378, 0.377], + [5.266, 0.532, 0.537], + [4.72, 1.959, 2.038], + [11.996, 2.413, 2.446], + [12.054, 2.648, 2.646], + [0.757, 0.349, 0.345], + [0.206, 0.124, 0.118], + [0.128, 0.075, 0.075], + [0.199, 0.122, 0.102], + [0.394, 0.285, 0.292], + [0.128, 0.044, 0.044], + [0.101, 0.037, 0.034], + [0.104, 0.038, 0.038] +] + } + \ No newline at end of file diff --git a/duckdb-vortex-tuned/results/20261110/c6a.metal.json b/duckdb-vortex-tuned/results/20261110/c6a.metal.json new file mode 100644 index 0000000000..6c90af7457 --- /dev/null +++ b/duckdb-vortex-tuned/results/20261110/c6a.metal.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Vortex, single, load threads=2)", + "date": "2026-11-10", + "machine": "c6a.metal", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "yes", + "tags": ["Rust","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 742, + "data_size": 12263181092, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.032, 0.018, 0.018], + [0.057, 0.041, 0.043], + [0.1, 0.055, 0.058], + [0.437, 0.158, 0.163], + [0.523, 0.304, 0.306], + [0.605, 0.367, 0.347], + [0.059, 0.038, 0.038], + [0.072, 0.041, 0.045], + [0.811, 0.281, 0.293], + [1.07, 0.324, 0.325], + [0.486, 0.217, 0.222], + [0.543, 0.301, 0.294], + [0.567, 0.445, 0.425], + [1.935, 0.785, 0.695], + [0.708, 0.351, 0.382], + [0.482, 0.335, 0.303], + [1.919, 0.493, 0.685], + [1.924, 0.597, 0.632], + [2.986, 0.729, 0.842], + [0.2, 0.152, 0.123], + [8.739, 0.873, 1.076], + [12.66, 2.809, 2.349], + [16.348, 1.888, 2.61], + [2.272, 0.382, 0.439], + [0.137, 0.11, 0.094], + [0.558, 0.304, 0.33], + [0.145, 0.104, 0.112], + [10.821, 0.739, 1.764], + [8.828, 2.578, 2.086], + [0.149, 0.094, 0.098], + [1.852, 0.264, 0.351], + [4.855, 0.858, 0.526], + [3.764, 0.786, 0.57], + [11.008, 1.397, 1.112], + [11.043, 1.915, 1.238], + [0.22, 0.192, 0.189], + [0.208, 0.175, 0.166], + [0.142, 0.106, 0.101], + [0.211, 0.158, 0.19], + [0.52, 0.493, 0.494], + [0.105, 0.06, 0.064], + [0.084, 0.063, 0.052], + [0.08, 0.047, 0.053] +] + } + \ No newline at end of file diff --git a/duckdb-vortex-tuned/results/20261110/c7a.metal-48xl.json b/duckdb-vortex-tuned/results/20261110/c7a.metal-48xl.json new file mode 100644 index 0000000000..6f7bf155ae --- /dev/null +++ b/duckdb-vortex-tuned/results/20261110/c7a.metal-48xl.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Vortex, single, load threads=2)", + "date": "2026-11-10", + "machine": "c7a.metal-48xl", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "yes", + "tags": ["Rust","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 701, + "data_size": 12263181092, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.043, 0.018, 0.018], + [0.072, 0.04, 0.038], + [0.145, 0.058, 0.057], + [0.395, 0.139, 0.154], + [0.451, 0.279, 0.254], + [0.585, 0.28, 0.292], + [0.076, 0.037, 0.037], + [0.101, 0.04, 0.041], + [0.779, 0.217, 0.226], + [1.035, 0.292, 0.288], + [0.466, 0.229, 0.208], + [0.499, 0.223, 0.228], + [0.525, 0.405, 0.342], + [1.876, 0.408, 0.452], + [0.67, 0.327, 0.296], + [0.448, 0.289, 0.228], + [1.862, 0.307, 0.553], + [1.874, 0.519, 0.528], + [2.923, 0.708, 0.75], + [0.196, 0.119, 0.128], + [8.722, 0.792, 0.839], + [12.504, 2.154, 2.383], + [16.297, 1.528, 2.435], + [2.189, 0.39, 0.344], + [0.348, 0.102, 0.091], + [0.504, 0.262, 0.265], + [0.171, 0.106, 0.105], + [10.795, 1.374, 1.881], + [8.705, 1.907, 1.894], + [0.182, 0.091, 0.091], + [1.803, 0.279, 0.356], + [4.81, 0.36, 0.51], + [3.657, 0.688, 0.644], + [10.795, 2.005, 2.156], + [10.911, 1.099, 1.002], + [0.265, 0.186, 0.158], + [0.227, 0.145, 0.154], + [0.152, 0.105, 0.099], + [0.231, 0.156, 0.155], + [0.502, 0.404, 0.426], + [0.147, 0.064, 0.063], + [0.113, 0.056, 0.051], + [0.11, 0.045, 0.049] +] + } + \ No newline at end of file diff --git a/duckdb-vortex-tuned/results/20261110/c8g.4xlarge.json b/duckdb-vortex-tuned/results/20261110/c8g.4xlarge.json new file mode 100644 index 0000000000..f63bca7dd8 --- /dev/null +++ b/duckdb-vortex-tuned/results/20261110/c8g.4xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Vortex, single, load threads=2)", + "date": "2026-11-10", + "machine": "c8g.4xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "yes", + "tags": ["Rust","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 687, + "data_size": 12263179748, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.027, 0.014, 0.014], + [0.044, 0.024, 0.024], + [0.181, 0.037, 0.037], + [0.521, 0.081, 0.08], + [1.02, 0.206, 0.21], + [0.875, 0.241, 0.249], + [0.046, 0.026, 0.025], + [0.056, 0.028, 0.027], + [0.952, 0.272, 0.264], + [1.222, 0.364, 0.369], + [0.574, 0.112, 0.112], + [0.933, 0.132, 0.13], + [1.074, 0.248, 0.25], + [2.326, 0.443, 0.443], + [0.943, 0.297, 0.296], + [0.602, 0.248, 0.253], + [2.291, 0.573, 0.581], + [2.197, 0.557, 0.559], + [3.536, 0.982, 0.972], + [0.24, 0.049, 0.05], + [10.663, 0.494, 0.49], + [13.216, 0.789, 0.794], + [16.637, 1.36, 1.353], + [1.724, 0.139, 0.133], + [0.144, 0.045, 0.046], + [1.238, 0.138, 0.132], + [0.153, 0.066, 0.059], + [11.824, 0.603, 0.613], + [9.529, 3.029, 3.015], + [0.194, 0.044, 0.045], + [2.129, 0.227, 0.227], + [5.133, 0.286, 0.283], + [3.966, 0.884, 0.885], + [11.649, 1.165, 1.183], + [11.664, 1.3, 1.309], + [0.486, 0.193, 0.2], + [0.137, 0.089, 0.089], + [0.078, 0.058, 0.058], + [0.134, 0.085, 0.085], + [0.29, 0.215, 0.222], + [0.082, 0.035, 0.036], + [0.057, 0.029, 0.028], + [0.062, 0.03, 0.029] +] + } + \ No newline at end of file diff --git a/duckdb-vortex-tuned/results/20261110/c8g.metal-48xl.json b/duckdb-vortex-tuned/results/20261110/c8g.metal-48xl.json new file mode 100644 index 0000000000..466ca84435 --- /dev/null +++ b/duckdb-vortex-tuned/results/20261110/c8g.metal-48xl.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Vortex, single, load threads=2)", + "date": "2026-11-10", + "machine": "c8g.metal-48xl", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "yes", + "tags": ["Rust","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 658, + "data_size": 12263179748, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.028, 0.014, 0.014], + [0.053, 0.027, 0.027], + [0.107, 0.043, 0.041], + [0.233, 0.115, 0.099], + [0.259, 0.221, 0.229], + [0.343, 0.276, 0.281], + [0.05, 0.025, 0.026], + [0.064, 0.029, 0.03], + [0.578, 0.246, 0.209], + [1, 0.243, 0.238], + [0.433, 0.173, 0.179], + [0.325, 0.206, 0.178], + [0.34, 0.248, 0.244], + [1.672, 0.425, 0.446], + [0.472, 0.264, 0.254], + [0.427, 0.25, 0.233], + [1.675, 0.444, 0.432], + [1.681, 0.498, 0.473], + [2.722, 0.558, 0.511], + [0.179, 0.119, 0.063], + [8.656, 0.78, 0.853], + [12.581, 1.427, 1.791], + [16.231, 1.583, 1.498], + [1.984, 0.271, 0.271], + [0.125, 0.088, 0.065], + [0.324, 0.223, 0.214], + [0.135, 0.11, 0.105], + [10.622, 1.341, 1.315], + [8.75, 1.586, 0.89], + [0.135, 0.07, 0.073], + [1.796, 0.259, 0.23], + [4.633, 0.426, 0.543], + [3.433, 0.529, 0.504], + [10.789, 1.45, 1.533], + [10.795, 0.926, 1.725], + [0.207, 0.148, 0.136], + [0.163, 0.13, 0.122], + [0.115, 0.077, 0.079], + [0.176, 0.134, 0.133], + [0.399, 0.342, 0.319], + [0.102, 0.049, 0.049], + [0.071, 0.039, 0.039], + [0.073, 0.035, 0.044] +] + } + \ No newline at end of file diff --git a/duckdb-vortex/load b/duckdb-vortex/load index 5fa24aacfd..87ed365e9c 100755 --- a/duckdb-vortex/load +++ b/duckdb-vortex/load @@ -2,11 +2,12 @@ set -e # Convert source parquet to Vortex format. -duckdb -c "LOAD vortex; COPY 'hits.parquet' TO 'hits.vortex' (FORMAT vortex);" +# -no-agent: keep the plain CLI output; see ./query. +duckdb -no-agent -c "LOAD vortex; COPY 'hits.parquet' TO 'hits.vortex' (FORMAT vortex);" # Create the persistent VIEW (over hits.vortex) in hits.db. rm -f hits.db -duckdb hits.db -f create.sql +duckdb -no-agent hits.db -f create.sql # Source parquet no longer needed. rm -f hits.parquet diff --git a/duckdb-vortex/query b/duckdb-vortex/query index 5eef5331ae..8b779c03bb 100755 --- a/duckdb-vortex/query +++ b/duckdb-vortex/query @@ -7,7 +7,11 @@ set -e query=$(cat) -out=$(duckdb hits.db -c "LOAD vortex;" -c ".timer on" -c "$query" 2>/tmp/duckdb.err.$$) && status=0 || status=$? +# -no-agent: the 2.0 CLI turns on "agent mode" when it detects an AI coding +# agent in the environment (AI_AGENT, CLAUDECODE, CURSOR_AGENT, ...) and +# stdout is not a terminal: Markdown tables, truncated results, JSON errors +# and a progress bar. Keep the plain output regardless of who runs this. +out=$(duckdb -no-agent hits.db -c "LOAD vortex;" -c ".timer on" -c "$query" 2>/tmp/duckdb.err.$$) && status=0 || status=$? if [ "$status" -ne 0 ]; then cat /tmp/duckdb.err.$$ >&2 diff --git a/duckdb-vortex/results/20261110/c6a.2xlarge.json b/duckdb-vortex/results/20261110/c6a.2xlarge.json new file mode 100644 index 0000000000..19fa597900 --- /dev/null +++ b/duckdb-vortex/results/20261110/c6a.2xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Vortex, single)", + "date": "2026-11-10", + "machine": "c6a.2xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["Rust","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 1225, + "data_size": 12263181092, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.051, 0.018, 0.018], + [0.085, 0.045, 0.045], + [0.277, 0.056, 0.056], + [0.708, 0.207, 0.2], + [1.033, 0.571, 0.566], + [1.084, 0.674, 0.683], + [0.069, 0.035, 0.037], + [0.101, 0.052, 0.051], + [1.271, 0.688, 0.687], + [1.48, 0.9, 0.897], + [0.733, 0.232, 0.241], + [0.801, 0.266, 0.266], + [1.028, 0.689, 0.693], + [2.652, 1.214, 1.194], + [1.28, 0.825, 0.829], + [1.11, 0.661, 0.661], + [2.643, 1.566, 1.589], + [2.314, 1.229, 1.233], + [4.326, 2.925, 2.952], + [0.399, 0.094, 0.102], + [10.191, 1.092, 1.063], + [13.317, 2.076, 2.081], + [16.82, 3.295, 3.217], + [1.785, 0.266, 0.262], + [0.258, 0.071, 0.07], + [0.795, 0.329, 0.326], + [0.274, 0.101, 0.105], + [11.613, 1.171, 1.192], + [11.264, 9.947, 9.902], + [0.284, 0.064, 0.063], + [2.255, 0.569, 0.565], + [5.347, 0.751, 0.753], + [5.454, 3.076, 3.115], + [12.334, 8.585, 8.368], + [12.443, 10.525, 10.017], + [1.106, 0.556, 0.555], + [0.235, 0.147, 0.149], + [0.127, 0.08, 0.08], + [0.213, 0.129, 0.124], + [0.456, 0.328, 0.336], + [0.129, 0.05, 0.048], + [0.121, 0.04, 0.042], + [0.113, 0.043, 0.042] +] + } + \ No newline at end of file diff --git a/duckdb-vortex/results/20261110/c6a.4xlarge.json b/duckdb-vortex/results/20261110/c6a.4xlarge.json new file mode 100644 index 0000000000..bcbfed1d14 --- /dev/null +++ b/duckdb-vortex/results/20261110/c6a.4xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Vortex, single)", + "date": "2026-11-10", + "machine": "c6a.4xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["Rust","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 1024, + "data_size": 12263181092, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.043, 0.018, 0.018], + [0.063, 0.034, 0.034], + [0.217, 0.048, 0.047], + [0.566, 0.124, 0.127], + [0.88, 0.355, 0.358], + [0.86, 0.446, 0.444], + [0.059, 0.031, 0.03], + [0.08, 0.039, 0.039], + [1.056, 0.435, 0.432], + [1.336, 0.552, 0.553], + [0.63, 0.165, 0.158], + [0.742, 0.177, 0.184], + [0.922, 0.515, 0.518], + [2.545, 0.861, 0.861], + [1.02, 0.546, 0.552], + [0.735, 0.421, 0.422], + [2.49, 1.016, 1.019], + [2.264, 0.776, 0.776], + [3.982, 1.849, 1.855], + [0.284, 0.064, 0.067], + [10.415, 0.728, 0.741], + [13.254, 1.301, 1.291], + [16.677, 2.106, 2.096], + [1.741, 0.184, 0.19], + [0.164, 0.059, 0.059], + [0.75, 0.196, 0.201], + [0.178, 0.079, 0.079], + [11.579, 0.823, 0.847], + [9.778, 5.341, 5.358], + [0.233, 0.058, 0.057], + [2.214, 0.375, 0.373], + [5.269, 0.533, 0.517], + [4.744, 1.972, 1.98], + [12.016, 2.432, 2.446], + [12.096, 2.665, 2.668], + [0.632, 0.348, 0.345], + [0.178, 0.11, 0.122], + [0.11, 0.075, 0.075], + [0.176, 0.12, 0.114], + [0.369, 0.291, 0.283], + [0.105, 0.043, 0.043], + [0.082, 0.038, 0.036], + [0.086, 0.037, 0.038] +] + } + \ No newline at end of file diff --git a/duckdb-vortex/results/20261110/c6a.metal.json b/duckdb-vortex/results/20261110/c6a.metal.json new file mode 100644 index 0000000000..cf96545c6f --- /dev/null +++ b/duckdb-vortex/results/20261110/c6a.metal.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Vortex, single)", + "date": "2026-11-10", + "machine": "c6a.metal", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["Rust","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 750, + "data_size": 12263181092, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.038, 0.018, 0.019], + [0.063, 0.041, 0.043], + [0.129, 0.055, 0.054], + [0.412, 0.134, 0.163], + [0.461, 0.274, 0.283], + [0.603, 0.412, 0.351], + [0.07, 0.039, 0.039], + [0.088, 0.042, 0.046], + [0.773, 0.277, 0.278], + [1.031, 0.316, 0.313], + [0.462, 0.227, 0.254], + [0.523, 0.265, 0.23], + [0.531, 0.386, 0.421], + [1.909, 0.708, 0.702], + [0.7, 0.456, 0.313], + [0.44, 0.34, 0.301], + [1.894, 0.707, 0.622], + [1.9, 0.718, 0.698], + [2.991, 0.65, 0.746], + [0.185, 0.114, 0.07], + [8.832, 0.867, 0.811], + [12.67, 2.615, 2.418], + [16.324, 1.733, 1.512], + [2.284, 0.363, 0.36], + [0.159, 0.115, 0.121], + [0.536, 0.293, 0.29], + [0.159, 0.107, 0.119], + [10.789, 2.093, 0.781], + [8.814, 1.097, 2.257], + [0.174, 0.095, 0.098], + [1.814, 0.35, 0.271], + [4.863, 0.815, 0.501], + [3.716, 0.846, 0.851], + [10.978, 1.07, 1.095], + [11.037, 2.356, 1.192], + [0.245, 0.172, 0.193], + [0.23, 0.163, 0.188], + [0.159, 0.101, 0.108], + [0.232, 0.154, 0.158], + [0.499, 0.474, 0.451], + [0.118, 0.06, 0.066], + [0.101, 0.05, 0.055], + [0.097, 0.049, 0.047] +] + } + \ No newline at end of file diff --git a/duckdb-vortex/results/20261110/c7a.metal-48xl.json b/duckdb-vortex/results/20261110/c7a.metal-48xl.json new file mode 100644 index 0000000000..973ab46168 --- /dev/null +++ b/duckdb-vortex/results/20261110/c7a.metal-48xl.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Vortex, single)", + "date": "2026-11-10", + "machine": "c7a.metal-48xl", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["Rust","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 713, + "data_size": 12263181092, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.039, 0.017, 0.018], + [0.062, 0.038, 0.038], + [0.117, 0.055, 0.055], + [0.436, 0.125, 0.148], + [0.536, 0.246, 0.254], + [0.595, 0.383, 0.383], + [0.069, 0.039, 0.037], + [0.088, 0.041, 0.041], + [0.586, 0.239, 0.224], + [1.054, 0.295, 0.257], + [0.475, 0.201, 0.202], + [0.531, 0.252, 0.194], + [0.556, 0.322, 0.374], + [1.911, 0.515, 0.479], + [0.707, 0.342, 0.301], + [0.456, 0.285, 0.271], + [1.894, 0.513, 0.572], + [1.896, 0.638, 0.637], + [2.935, 0.668, 0.75], + [0.204, 0.107, 0.124], + [8.879, 1.225, 0.749], + [12.628, 2.029, 1.619], + [16.232, 2.001, 1.747], + [2.266, 0.314, 0.472], + [0.151, 0.105, 0.111], + [0.53, 0.258, 0.309], + [0.149, 0.109, 0.106], + [10.789, 1.523, 1.845], + [8.828, 2.29, 1.85], + [0.158, 0.094, 0.092], + [1.849, 0.348, 0.378], + [4.842, 0.621, 0.623], + [3.687, 0.648, 0.681], + [10.907, 2.115, 2.179], + [11.01, 2.209, 2.293], + [0.228, 0.173, 0.158], + [0.214, 0.161, 0.153], + [0.141, 0.098, 0.106], + [0.209, 0.158, 0.164], + [0.514, 0.408, 0.399], + [0.116, 0.058, 0.06], + [0.095, 0.053, 0.05], + [0.093, 0.05, 0.049] +] + } + \ No newline at end of file diff --git a/duckdb-vortex/results/20261110/c8g.4xlarge.json b/duckdb-vortex/results/20261110/c8g.4xlarge.json new file mode 100644 index 0000000000..50e95b7821 --- /dev/null +++ b/duckdb-vortex/results/20261110/c8g.4xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Vortex, single)", + "date": "2026-11-10", + "machine": "c8g.4xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["Rust","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 920, + "data_size": 12263179748, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.039, 0.014, 0.014], + [0.05, 0.024, 0.024], + [0.232, 0.035, 0.037], + [0.503, 0.085, 0.083], + [0.907, 0.2, 0.21], + [0.795, 0.243, 0.246], + [0.053, 0.025, 0.027], + [0.068, 0.027, 0.027], + [0.92, 0.276, 0.274], + [1.18, 0.361, 0.364], + [0.557, 0.104, 0.113], + [0.864, 0.131, 0.129], + [1.127, 0.246, 0.251], + [2.291, 0.441, 0.453], + [1.637, 0.284, 0.295], + [1.153, 0.249, 0.245], + [2.223, 0.555, 0.573], + [2.204, 0.466, 0.465], + [3.532, 0.975, 0.956], + [0.31, 0.049, 0.047], + [10.522, 0.484, 0.466], + [13.223, 0.794, 0.804], + [16.615, 1.362, 1.342], + [1.728, 0.133, 0.14], + [0.249, 0.047, 0.042], + [0.957, 0.131, 0.133], + [0.249, 0.063, 0.061], + [11.55, 0.601, 0.627], + [9.513, 3.07, 2.97], + [0.24, 0.045, 0.045], + [2.115, 0.221, 0.229], + [5.113, 0.287, 0.286], + [3.954, 0.926, 0.892], + [11.623, 1.173, 1.165], + [11.662, 1.285, 1.285], + [0.588, 0.192, 0.194], + [0.154, 0.088, 0.086], + [0.088, 0.058, 0.057], + [0.152, 0.097, 0.086], + [0.303, 0.212, 0.214], + [0.099, 0.035, 0.035], + [0.07, 0.028, 0.028], + [0.075, 0.029, 0.028] +] + } + \ No newline at end of file diff --git a/duckdb-vortex/results/20261110/c8g.metal-48xl.json b/duckdb-vortex/results/20261110/c8g.metal-48xl.json new file mode 100644 index 0000000000..da2ff45afc --- /dev/null +++ b/duckdb-vortex/results/20261110/c8g.metal-48xl.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB (Vortex, single)", + "date": "2026-11-10", + "machine": "c8g.metal-48xl", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["Rust","column-oriented","DuckDB derivative","embedded","stateless"], + "load_time": 690, + "data_size": 12263179748, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.033, 0.014, 0.014], + [0.05, 0.027, 0.027], + [0.123, 0.04, 0.04], + [0.403, 0.107, 0.119], + [0.633, 0.226, 0.224], + [0.499, 0.283, 0.276], + [0.053, 0.027, 0.027], + [0.07, 0.031, 0.03], + [0.758, 0.235, 0.208], + [1.002, 0.241, 0.241], + [0.421, 0.176, 0.163], + [0.474, 0.189, 0.202], + [0.489, 0.303, 0.304], + [1.856, 0.409, 0.51], + [0.637, 0.301, 0.311], + [0.407, 0.251, 0.231], + [1.828, 0.317, 0.505], + [1.857, 0.473, 0.397], + [2.887, 0.587, 0.542], + [0.273, 0.147, 0.117], + [8.785, 0.841, 0.657], + [12.547, 1.81, 1.899], + [16.225, 1.557, 1.555], + [2.194, 0.34, 0.317], + [0.185, 0.073, 0.074], + [0.525, 0.181, 0.204], + [0.153, 0.099, 0.098], + [10.669, 1.304, 1.398], + [8.739, 1.702, 1.75], + [0.156, 0.073, 0.074], + [1.772, 0.212, 0.286], + [4.76, 0.451, 0.519], + [3.562, 0.609, 0.547], + [10.795, 0.811, 0.848], + [10.837, 1.594, 1.109], + [0.271, 0.133, 0.143], + [0.183, 0.126, 0.136], + [0.126, 0.087, 0.078], + [0.184, 0.139, 0.132], + [0.396, 0.385, 0.362], + [0.111, 0.052, 0.053], + [0.083, 0.039, 0.04], + [0.077, 0.04, 0.04] +] + } + \ No newline at end of file diff --git a/duckdb/load b/duckdb/load index ae8ee21ff0..d425f01521 100755 --- a/duckdb/load +++ b/duckdb/load @@ -5,7 +5,8 @@ set -e rm -f hits.db # Build the database from the source parquet via inline create + load DDL. -duckdb hits.db -storage_version latest <<'SQL' +# -no-agent: keep the plain CLI output; see ./query. +duckdb -no-agent hits.db -storage_version latest <<'SQL' .read create.sql INSERT INTO hits SELECT * REPLACE ( diff --git a/duckdb/query b/duckdb/query index 51d155afd8..ba1a4939f7 100755 --- a/duckdb/query +++ b/duckdb/query @@ -9,7 +9,11 @@ query=$(cat) # duckdb writes both the result and the `Run Time (s): real X.XXX` line to # stdout; capture, split, redirect timing to stderr. -out=$(duckdb hits.db -c ".timer on" -c "$query" 2>/tmp/duckdb.err.$$) && status=0 || status=$? +# -no-agent: the 2.0 CLI turns on "agent mode" when it detects an AI coding +# agent in the environment (AI_AGENT, CLAUDECODE, CURSOR_AGENT, ...) and +# stdout is not a terminal: Markdown tables, truncated results, JSON errors +# and a progress bar. Keep the plain output regardless of who runs this. +out=$(duckdb -no-agent hits.db -c ".timer on" -c "$query" 2>/tmp/duckdb.err.$$) && status=0 || status=$? if [ "$status" -ne 0 ]; then cat /tmp/duckdb.err.$$ >&2 diff --git a/duckdb/results/20261110/c6a.2xlarge.json b/duckdb/results/20261110/c6a.2xlarge.json new file mode 100644 index 0000000000..5facdc08b8 --- /dev/null +++ b/duckdb/results/20261110/c6a.2xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB", + "date": "2026-11-10", + "machine": "c6a.2xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded"], + "load_time": 145, + "data_size": 20435709952, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.051, 0.017, 0.017], + [0.228, 0.05, 0.05], + [0.398, 0.092, 0.092], + [0.408, 0.115, 0.114], + [0.79, 0.517, 0.514], + [1.002, 0.535, 0.538], + [0.114, 0.03, 0.029], + [0.263, 0.052, 0.051], + [1.084, 0.636, 0.64], + [1.657, 0.876, 0.876], + [0.625, 0.197, 0.196], + [0.843, 0.227, 0.225], + [1.032, 0.602, 0.598], + [2.381, 1.003, 1.01], + [1.427, 0.674, 0.677], + [0.855, 0.605, 0.604], + [2.339, 1.366, 1.355], + [2, 1.028, 1.033], + [4.848, 2.586, 2.571], + [0.236, 0.055, 0.055], + [10.792, 1.258, 1.259], + [12.126, 1.339, 1.325], + [12.624, 1.318, 1.277], + [0.453, 0.154, 0.155], + [0.193, 0.078, 0.061], + [0.919, 0.23, 0.229], + [0.195, 0.08, 0.069], + [10.994, 1.08, 1.081], + [14.06, 12.949, 12.942], + [0.371, 0.09, 0.089], + [2.847, 0.64, 0.638], + [5.937, 0.83, 0.831], + [5.688, 3.123, 3.129], + [11.755, 3.201, 3.267], + [11.691, 3.475, 3.484], + [0.771, 0.568, 0.568], + [0.159, 0.061, 0.061], + [0.111, 0.035, 0.035], + [0.144, 0.041, 0.043], + [0.214, 0.096, 0.101], + [0.156, 0.035, 0.035], + [0.142, 0.033, 0.035], + [0.151, 0.034, 0.034] +] + } + \ No newline at end of file diff --git a/duckdb/results/20261110/c6a.4xlarge.json b/duckdb/results/20261110/c6a.4xlarge.json new file mode 100644 index 0000000000..7ba5ca95a7 --- /dev/null +++ b/duckdb/results/20261110/c6a.4xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB", + "date": "2026-11-10", + "machine": "c6a.4xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded"], + "load_time": 113, + "data_size": 20458778624, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.061, 0.019, 0.019], + [0.153, 0.044, 0.044], + [0.243, 0.063, 0.062], + [0.318, 0.073, 0.073], + [0.576, 0.328, 0.33], + [1.013, 0.359, 0.361], + [0.145, 0.031, 0.031], + [0.197, 0.042, 0.041], + [0.947, 0.396, 0.401], + [1.651, 0.521, 0.519], + [0.569, 0.131, 0.131], + [0.869, 0.152, 0.149], + [1.047, 0.398, 0.399], + [2.346, 0.742, 0.753], + [1.412, 0.459, 0.465], + [0.568, 0.388, 0.385], + [2.279, 0.878, 0.882], + [2.008, 0.645, 0.646], + [4.592, 1.632, 1.636], + [0.158, 0.045, 0.045], + [10.72, 0.692, 0.682], + [11.944, 0.721, 0.719], + [12.145, 0.741, 0.81], + [0.44, 0.12, 0.122], + [0.224, 0.059, 0.056], + [0.939, 0.142, 0.142], + [0.214, 0.059, 0.058], + [10.839, 0.601, 0.595], + [8.387, 7.564, 6.837], + [0.17, 0.066, 0.066], + [2.816, 0.394, 0.393], + [5.87, 0.55, 0.546], + [5.006, 1.928, 1.905], + [11.14, 2.011, 2.029], + [11.16, 2.192, 2.211], + [0.472, 0.346, 0.347], + [0.148, 0.057, 0.06], + [0.146, 0.037, 0.036], + [0.171, 0.044, 0.046], + [0.26, 0.089, 0.089], + [0.184, 0.036, 0.036], + [0.155, 0.036, 0.035], + [0.169, 0.035, 0.035] +] + } + \ No newline at end of file diff --git a/duckdb/results/20261110/c6a.large.json b/duckdb/results/20261110/c6a.large.json new file mode 100644 index 0000000000..3ed2a06c20 --- /dev/null +++ b/duckdb/results/20261110/c6a.large.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB", + "date": "2026-11-10", + "machine": "c6a.large", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded"], + "load_time": 458, + "data_size": 20422078464, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.056, 0.018, 0.018], + [0.488, 0.086, 0.088], + [1.163, 0.273, 0.272], + [1.372, 0.394, 0.394], + [3.641, 2.843, 2.903], + [3.256, 1.927, 1.945], + [0.114, 0.03, 0.03], + [0.556, 0.106, 0.106], + [4.409, 3.254, 3.228], + [6.263, 4.271, 4.258], + [2.007, 0.639, 0.636], + [2.384, 0.749, 0.741], + [3.427, 2.11, 2.123], + [5.902, 3.813, 3.841], + [4.117, 2.442, 2.425], + [3.908, 3.08, 3.127], + [7.867, 6.788, 6.638], + [6.642, 5.399, 5.428], + [20.464, 20.332, 20.596], + [0.803, 0.135, 0.135], + [11.666, 11.85, 12.031], + [12.861, 13.288, 13.161], + [13.053, 13.47, 13.182], + [1.346, 0.406, 0.403], + [0.397, 0.113, 0.1], + [2.125, 0.801, 0.799], + [0.399, 0.118, 0.159], + [11.639, 12.187, 12.175], + [55.235, 55.178, 55.958], + [0.851, 0.237, 0.236], + [5.435, 2.43, 2.425], + [8.377, 7.66, 8.059], + [29.569, 29.394, 28.824], + [26.743, 26.854, 83.589], + [29.8, 30.228, 30.476], + [3.41, 2.685, 2.672], + [0.289, 0.134, 0.133], + [0.185, 0.05, 0.062], + [0.252, 0.085, 0.084], + [0.473, 0.247, 0.248], + [0.227, 0.045, 0.057], + [0.198, 0.056, 0.054], + [0.18, 0.057, 0.056] +] + } + \ No newline at end of file diff --git a/duckdb/results/20261110/c6a.metal.json b/duckdb/results/20261110/c6a.metal.json new file mode 100644 index 0000000000..420ee72179 --- /dev/null +++ b/duckdb/results/20261110/c6a.metal.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB", + "date": "2026-11-10", + "machine": "c6a.metal", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded"], + "load_time": 100, + "data_size": 20631269376, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.045, 0.017, 0.017], + [0.145, 0.05, 0.05], + [0.196, 0.037, 0.038], + [0.842, 0.039, 0.039], + [0.901, 0.112, 0.114], + [1.752, 0.112, 0.111], + [0.112, 0.03, 0.031], + [0.119, 0.037, 0.039], + [1.502, 0.132, 0.13], + [2.528, 0.16, 0.158], + [1.196, 0.079, 0.078], + [1.614, 0.08, 0.078], + [1.791, 0.126, 0.117], + [3.294, 0.196, 0.204], + [2.28, 0.127, 0.122], + [0.688, 0.122, 0.129], + [3.289, 0.226, 0.223], + [3.29, 0.222, 0.21], + [6.148, 0.35, 0.375], + [0.178, 0.037, 0.037], + [15.403, 0.173, 0.18], + [17.403, 0.168, 0.159], + [17.808, 0.79, 0.961], + [2.715, 0.148, 0.15], + [0.502, 0.051, 0.05], + [1.903, 0.059, 0.067], + [0.632, 0.052, 0.054], + [15.618, 0.146, 0.146], + [11.812, 0.824, 0.899], + [0.195, 0.047, 0.05], + [4.32, 0.14, 0.147], + [8.358, 0.219, 0.218], + [6.049, 0.543, 0.554], + [15.358, 0.46, 0.475], + [15.362, 0.478, 0.489], + [1.213, 0.113, 0.11], + [0.155, 0.058, 0.052], + [0.089, 0.039, 0.04], + [0.13, 0.04, 0.042], + [0.2, 0.077, 0.078], + [0.113, 0.041, 0.042], + [0.095, 0.04, 0.041], + [0.088, 0.038, 0.037] +] + } + \ No newline at end of file diff --git a/duckdb/results/20261110/c6a.xlarge.json b/duckdb/results/20261110/c6a.xlarge.json new file mode 100644 index 0000000000..dd9fcf38e3 --- /dev/null +++ b/duckdb/results/20261110/c6a.xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB", + "date": "2026-11-10", + "machine": "c6a.xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded"], + "load_time": 224, + "data_size": 20427321344, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.05, 0.018, 0.017], + [0.377, 0.064, 0.065], + [0.752, 0.154, 0.152], + [0.791, 0.206, 0.205], + [1.404, 0.924, 0.925], + [1.681, 0.963, 0.964], + [0.123, 0.03, 0.031], + [0.404, 0.071, 0.07], + [1.962, 1.234, 1.235], + [2.765, 1.705, 1.716], + [1.118, 0.331, 0.33], + [1.437, 0.381, 0.383], + [1.716, 1.057, 1.054], + [2.871, 1.78, 1.791], + [2.108, 1.226, 1.21], + [1.628, 1.154, 1.15], + [3.544, 2.527, 2.546], + [2.928, 1.898, 1.904], + [6.93, 5.305, 5.413], + [0.462, 0.08, 0.078], + [11.203, 2.399, 2.417], + [12.386, 2.58, 2.565], + [12.136, 2.535, 2.422], + [0.644, 0.235, 0.24], + [0.296, 0.088, 0.082], + [1.201, 0.413, 0.411], + [0.307, 0.095, 0.084], + [11.407, 2.089, 2.089], + [27.735, 25.946, 25.953], + [0.573, 0.139, 0.137], + [2.926, 1.158, 1.155], + [6.19, 1.491, 1.499], + [7.787, 7.467, 7.277], + [12.172, 9.274, 10.297], + [12.234, 9.274, 10.829], + [1.342, 1.083, 1.088], + [0.19, 0.088, 0.089], + [0.135, 0.043, 0.041], + [0.214, 0.054, 0.054], + [0.352, 0.162, 0.168], + [0.197, 0.038, 0.039], + [0.195, 0.038, 0.038], + [0.15, 0.038, 0.037] +] + } + \ No newline at end of file diff --git a/duckdb/results/20261110/c7a.metal-48xl.json b/duckdb/results/20261110/c7a.metal-48xl.json new file mode 100644 index 0000000000..5aa33c8a0e --- /dev/null +++ b/duckdb/results/20261110/c7a.metal-48xl.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB", + "date": "2026-11-10", + "machine": "c7a.metal-48xl", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded"], + "load_time": 95, + "data_size": 20630482944, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.054, 0.016, 0.016], + [0.163, 0.047, 0.045], + [0.145, 0.036, 0.035], + [0.959, 0.034, 0.042], + [0.993, 0.086, 0.081], + [1.85, 0.091, 0.092], + [0.093, 0.028, 0.028], + [0.096, 0.039, 0.042], + [1.478, 0.101, 0.107], + [2.526, 0.125, 0.126], + [1.181, 0.067, 0.069], + [1.724, 0.069, 0.07], + [1.869, 0.091, 0.089], + [3.254, 0.163, 0.16], + [2.267, 0.103, 0.103], + [0.65, 0.094, 0.092], + [3.31, 0.164, 0.166], + [3.242, 0.162, 0.164], + [6.093, 0.27, 0.255], + [0.122, 0.034, 0.034], + [15.529, 0.15, 0.143], + [17.387, 0.134, 0.13], + [17.928, 1.063, 0.982], + [2.678, 0.141, 0.138], + [0.487, 0.047, 0.048], + [1.995, 0.055, 0.055], + [0.739, 0.052, 0.05], + [15.742, 0.114, 0.113], + [11.807, 0.681, 0.546], + [0.122, 0.045, 0.044], + [4.345, 0.113, 0.111], + [8.39, 0.204, 0.199], + [6.049, 0.452, 0.437], + [15.357, 0.391, 0.373], + [15.37, 0.412, 0.408], + [0.23, 0.091, 0.09], + [0.11, 0.044, 0.043], + [0.076, 0.036, 0.036], + [0.106, 0.038, 0.036], + [0.213, 0.07, 0.073], + [0.134, 0.036, 0.036], + [0.112, 0.038, 0.038], + [0.104, 0.036, 0.041] +] + } + \ No newline at end of file diff --git a/duckdb/results/20261110/c8g.4xlarge.json b/duckdb/results/20261110/c8g.4xlarge.json new file mode 100644 index 0000000000..5f3f9f4180 --- /dev/null +++ b/duckdb/results/20261110/c8g.4xlarge.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB", + "date": "2026-11-10", + "machine": "c8g.4xlarge", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded"], + "load_time": 107, + "data_size": 20451700736, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.036, 0.014, 0.014], + [0.254, 0.031, 0.032], + [0.518, 0.042, 0.042], + [0.507, 0.049, 0.049], + [0.566, 0.176, 0.178], + [0.915, 0.181, 0.179], + [0.087, 0.024, 0.023], + [0.147, 0.027, 0.026], + [0.81, 0.227, 0.228], + [1.503, 0.312, 0.311], + [0.867, 0.092, 0.096], + [0.917, 0.099, 0.099], + [1.134, 0.208, 0.204], + [2.09, 0.373, 0.372], + [1.32, 0.251, 0.24], + [0.525, 0.212, 0.212], + [2.547, 0.453, 0.454], + [1.997, 0.365, 0.366], + [4.194, 0.821, 0.84], + [0.382, 0.028, 0.027], + [10.61, 0.449, 0.45], + [11.934, 0.458, 0.449], + [12.232, 0.566, 0.485], + [0.537, 0.086, 0.088], + [0.343, 0.041, 0.038], + [1.088, 0.094, 0.092], + [0.16, 0.042, 0.044], + [10.787, 0.329, 0.328], + [8.174, 3.781, 4.437], + [0.188, 0.048, 0.048], + [2.751, 0.234, 0.233], + [5.757, 0.297, 0.299], + [4.291, 0.873, 0.87], + [10.799, 0.946, 0.951], + [10.8, 1, 1.009], + [0.371, 0.193, 0.195], + [0.131, 0.038, 0.037], + [0.098, 0.024, 0.024], + [0.124, 0.029, 0.03], + [0.183, 0.059, 0.059], + [0.149, 0.023, 0.023], + [0.109, 0.023, 0.023], + [0.095, 0.022, 0.023] +] + } + \ No newline at end of file diff --git a/duckdb/results/20261110/c8g.metal-48xl.json b/duckdb/results/20261110/c8g.metal-48xl.json new file mode 100644 index 0000000000..eeb60090f6 --- /dev/null +++ b/duckdb/results/20261110/c8g.metal-48xl.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB", + "date": "2026-11-10", + "machine": "c8g.metal-48xl", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded"], + "load_time": 97, + "data_size": 20631007232, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.032, 0.014, 0.014], + [0.15, 0.031, 0.031], + [0.195, 0.025, 0.025], + [0.926, 0.029, 0.024], + [1.009, 0.077, 0.081], + [1.888, 0.074, 0.077], + [0.109, 0.024, 0.024], + [0.104, 0.024, 0.024], + [1.498, 0.095, 0.099], + [2.56, 0.109, 0.112], + [1.195, 0.053, 0.051], + [1.744, 0.054, 0.057], + [1.918, 0.08, 0.086], + [3.258, 0.146, 0.138], + [2.257, 0.09, 0.097], + [0.668, 0.089, 0.088], + [3.319, 0.132, 0.148], + [3.248, 0.134, 0.147], + [6.077, 0.222, 0.222], + [0.268, 0.022, 0.021], + [15.405, 0.147, 0.146], + [17.333, 0.136, 0.113], + [17.562, 0.895, 0.713], + [2.837, 0.105, 0.106], + [0.544, 0.034, 0.034], + [2.021, 0.049, 0.046], + [0.754, 0.039, 0.036], + [15.749, 0.095, 0.096], + [11.798, 0.549, 0.539], + [0.136, 0.034, 0.038], + [4.317, 0.093, 0.105], + [8.36, 0.161, 0.168], + [5.983, 0.376, 0.379], + [15.36, 0.344, 0.332], + [15.369, 0.357, 0.348], + [0.285, 0.094, 0.085], + [0.108, 0.039, 0.037], + [0.076, 0.025, 0.023], + [0.115, 0.029, 0.029], + [0.185, 0.064, 0.061], + [0.111, 0.027, 0.023], + [0.081, 0.026, 0.027], + [0.071, 0.024, 0.026] +] + } + \ No newline at end of file diff --git a/duckdb/results/20261110/t3a.small.json b/duckdb/results/20261110/t3a.small.json new file mode 100644 index 0000000000..60bb73bc8b --- /dev/null +++ b/duckdb/results/20261110/t3a.small.json @@ -0,0 +1,60 @@ +{ + "system": "DuckDB", + "date": "2026-11-10", + "machine": "t3a.small", + "cluster_size": 1, + "proprietary": "no", + "hardware": "cpu", + "tuned": "no", + "tags": ["C++","column-oriented","DuckDB derivative","embedded"], + "load_time": 1230, + "data_size": 20422078464, + "concurrent_qps": null, + "concurrent_error_ratio": null, + "result": [ + [0.08, 0.034, 0.04], + [0.564, 0.153, 0.155], + [1.414, 0.472, 0.466], + [1.63, 0.631, 0.632], + [5.261, 4.359, 4.809], + [4.747, 3.921, 4.012], + [0.137, 0.056, 0.056], + [0.655, 0.179, 0.183], + [6.633, 6.32, 5.817], + [9.287, 9.022, 8.463], + [2.431, 1.013, 1.025], + [2.908, 1.198, 1.191], + [5.068, 5.007, 4.912], + [9.468, 9.271, 9.928], + [6.178, 6.251, 6.123], + [5.776, 4.991, 4.956], + [18.476, 18.903, 17.893], + [11.528, 11.829, 12.023], + [59.416, 48.34, 45.208], + [0.918, 0.215, 0.217], + [13.709, 13.641, 13.324], + [14.882, 15.045, 15.129], + [17.892, 15.703, 16.094], + [1.642, 0.641, 0.645], + [0.508, 0.182, 0.197], + [2.842, 1.281, 1.255], + [0.5, 0.197, 0.25], + [12.797, 12.864, 14.773], + [97.115, 97.95, 96.639], + [1.04, 0.412, 0.415], + [7.334, 7.45, 7.132], + [12.282, 10.554, 10.776], + [47.045, 44.311, 45.002], + [43.989, 42.126, 44.12], + [51.094, 46.898, 49.036], + [4.895, 4.149, 4.225], + [0.373, 0.203, 0.205], + [0.222, 0.085, 0.085], + [0.315, 0.117, 0.115], + [0.644, 0.396, 0.392], + [0.263, 0.079, 0.078], + [0.234, 0.088, 0.09], + [0.213, 0.079, 0.079] +] + } + \ No newline at end of file diff --git a/json/duckdb-variant/count b/json/duckdb-variant/count index 50300771b2..75af7e0836 100755 --- a/json/duckdb-variant/count +++ b/json/duckdb-variant/count @@ -1,4 +1,5 @@ #!/bin/bash set -e -duckdb bluesky.duckdb -noheader -list -c "SELECT count() FROM bluesky" +# -no-agent: keep the plain CLI output; see ../../duckdb/query. +duckdb -no-agent bluesky.duckdb -noheader -list -c "SELECT count() FROM bluesky" diff --git a/json/duckdb-variant/load b/json/duckdb-variant/load index d1b5c8be80..56476a765f 100755 --- a/json/duckdb-variant/load +++ b/json/duckdb-variant/load @@ -15,13 +15,14 @@ rm -f bluesky.duckdb bluesky.duckdb.wal # A few documents in the dataset are broken: a document longer than 64 KiB # is split into two lines by a raw newline. ignore_errors=true turns these # lines into NULLs, which are filtered out. +# -no-agent: keep the plain CLI output; see ../../duckdb/query. { cat ddl.sql for file in $(ls "${BENCH_DATA_DIR}"/file_*.json.gz | head -n "${BENCH_FILES}"); do echo "INSERT INTO bluesky SELECT json::VARIANT FROM read_ndjson_objects('${file}', ignore_errors = true, maximum_object_size = 1048576000) WHERE json IS NOT NULL;" done echo "CHECKPOINT;" -} | duckdb bluesky.duckdb +} | duckdb -no-agent bluesky.duckdb # Show the storage version of the database file in the log. -duckdb bluesky.duckdb -noheader -list -c "SELECT tags FROM duckdb_databases() WHERE database_name = 'bluesky'" +duckdb -no-agent bluesky.duckdb -noheader -list -c "SELECT tags FROM duckdb_databases() WHERE database_name = 'bluesky'" diff --git a/json/duckdb-variant/query b/json/duckdb-variant/query index 796d1bd0e6..2ad00ae192 100755 --- a/json/duckdb-variant/query +++ b/json/duckdb-variant/query @@ -9,7 +9,8 @@ query=$(cat) err=$(mktemp /var/tmp/duckdb-query.XXXXXX) trap 'rm -f "${err}"' EXIT -out=$(duckdb bluesky.duckdb -c ".timer on" -c "${query}" 2>"${err}") && status=0 || status=$? +# -no-agent: keep the plain CLI output; see ../../duckdb/query. +out=$(duckdb -no-agent bluesky.duckdb -c ".timer on" -c "${query}" 2>"${err}") && status=0 || status=$? if [ "${status}" -ne 0 ]; then cat "${err}" >&2 diff --git a/json/duckdb/count b/json/duckdb/count index 50300771b2..75af7e0836 100755 --- a/json/duckdb/count +++ b/json/duckdb/count @@ -1,4 +1,5 @@ #!/bin/bash set -e -duckdb bluesky.duckdb -noheader -list -c "SELECT count() FROM bluesky" +# -no-agent: keep the plain CLI output; see ../../duckdb/query. +duckdb -no-agent bluesky.duckdb -noheader -list -c "SELECT count() FROM bluesky" diff --git a/json/duckdb/load b/json/duckdb/load index 3170f0cd9c..c357c2542a 100755 --- a/json/duckdb/load +++ b/json/duckdb/load @@ -14,10 +14,11 @@ rm -f bluesky.duckdb bluesky.duckdb.wal # whole INSERT (in the original: the whole 100k-line chunk) failed. Now the # broken lines are skipped: ignore_errors=true turns them into NULLs, which # are filtered out. +# -no-agent: keep the plain CLI output; see ../../duckdb/query. { cat ddl.sql for file in $(ls "${BENCH_DATA_DIR}"/file_*.json.gz | head -n "${BENCH_FILES}"); do echo "INSERT INTO bluesky SELECT json FROM read_ndjson_objects('${file}', ignore_errors = true, maximum_object_size = 1048576000) WHERE json IS NOT NULL;" done echo "CHECKPOINT;" -} | duckdb bluesky.duckdb +} | duckdb -no-agent bluesky.duckdb diff --git a/json/duckdb/query b/json/duckdb/query index 796d1bd0e6..2ad00ae192 100755 --- a/json/duckdb/query +++ b/json/duckdb/query @@ -9,7 +9,8 @@ query=$(cat) err=$(mktemp /var/tmp/duckdb-query.XXXXXX) trap 'rm -f "${err}"' EXIT -out=$(duckdb bluesky.duckdb -c ".timer on" -c "${query}" 2>"${err}") && status=0 || status=$? +# -no-agent: keep the plain CLI output; see ../../duckdb/query. +out=$(duckdb -no-agent bluesky.duckdb -c ".timer on" -c "${query}" 2>"${err}") && status=0 || status=$? if [ "${status}" -ne 0 ]; then cat "${err}" >&2