ClickHouse 26.10 shipped on 22 October 2026 with 104 new features and 225 performance optimizations, and most of the ones that matter for real-time analytics do the same thing: they stop the engine from reading, decoding or holding data the query never needed. We ran six of them against a 40-million-row clickstream table. The short version: a “first 15 time buckets” query went from 40.0 million rows read to about 0.13 million, a join on a shared sort key got faster and stopped needing a hash table, and an IN subquery ran in 51 MiB where it previously needed 183 MiB.
Not everything in ClickHouse 26.10 landed that cleanly. The same Top-K query in descending order only halved its read, the now() support in the query condition cache is behind an experimental switch in the build we tested, and one default-on optimization made a query slightly slower on our two-core box. Those results are in here too, with the settings that produced them.
As of 20 November 2026. ClickHouse 26.10 is the current monthly stable release (26.10.2.103); 26.8 is the current LTS. Our earlier write-up of that line is here: ClickHouse 26.8 LTS for real-time analytics. Upstream sources for this post are the ClickHouse 26.10 changelog and the 26.10 release call slides.
ClickHouse 26.10 for real-time analytics: the scorecard
Each row is one ClickHouse 26.10 change, how it is switched, and what we saw. “Default” is what system.settings reported on our build; check yours with the inventory query near the end, because defaults can move between a monthly release and its patch versions.
| Change in ClickHouse 26.10 | Setting and default | What we measured | Verdict |
|---|---|---|---|
Top-K dynamic filtering for GROUP BY | enable_group_by_top_k_dynamic_filtering = 1 | Ascending: 241 ms to 7 ms, 40.0M to 0.13M rows. Descending: 427 ms to 289 ms | Adopt. Mind the sort direction |
| Query condition cache for time conditions | use_query_condition_cache_for_time_conditions = 0 (Experimental tier) | today() - 1: 40.0M to 9.53M rows on repeat. Sliding now(): no hits inside the first grid cell | Test only |
| Merge join sharded by primary key ranges | query_plan_join_shard_by_pk_ranges = 1 | 709 ms to 485 ms; fits in 9 MiB against 359 MiB for a hash join | Adopt where both sides share a sort key |
IN subqueries spill to disk | max_bytes_before_external_set = 0, ratio 0.5 | Fits in 51 MiB instead of 183 MiB, at 5.3 times the elapsed time | Safety net, not a speedup |
| Columns cache | use_columns_cache = 0 (Experimental tier) | 39 ms to 31 ms on a small hot set; zero hits when the column outgrew the cache | Test only |
| String filtering during the scan | apply_string_filters_during_scan = 1 | Bytes materialised: 1,970 MB to 397 MB. Elapsed time: no better | Leave on, expect memory relief |
Figure 1. ClickHouse 26.10 features compared by how much data the engine still reads once each one is enabled. Bars are our lab medians, not vendor figures.
How we measured ClickHouse 26.10
The numbers come from one small machine on purpose: 2 vCPU, 7 GiB RAM, local disk, Linux x86_64. A box this size cannot flatter anything that depends on wide parallelism, which makes the row-count and memory results easier to trust. The engine was the embedded build shipped as chDB 4.5.1, which reports version 26.11.1.1: a build cut after 26.10, so it carries the 26.10 changes. Treat default values here as “our build” and confirm them on your own 26.10 server.
Every timing is the median of five runs with the spread in brackets, query cache off, data fully merged and in the page cache. Rows and bytes read come from the query statistics, skip counts from system.events deltas. For memory we report the smallest max_memory_usage at which the query completes, found by bisection, because the embedded build has no system.query_log.
CREATE TABLE rt.events
(
event_time DateTime,
tenant_id UInt32,
user_id UInt64,
session_id UInt64,
event_type LowCardinality(String),
country LowCardinality(String),
device LowCardinality(String),
browser LowCardinality(String),
url String,
latency_ms UInt32,
revenue Decimal(12, 2)
)
ENGINE = MergeTree
PARTITION BY toYYYYMMDD(event_time)
ORDER BY (tenant_id, event_time)
SETTINGS index_granularity = 8192,
min_bytes_for_wide_part = 0,
min_rows_for_wide_part = 0;
-- 40M synthetic events spread evenly over seven days, 500 tenants
INSERT INTO rt.events
SELECT
toDateTime('2026-11-20 16:00:00') - toIntervalSecond(intDiv(number * 7 * 86400, 40000000)),
cityHash64(number, 1) % 500,
cityHash64(number, 2) % 4000000,
cityHash64(number, 3) % 12000000,
['page_view','page_view','page_view','click','click','add_to_cart','search','purchase'][cityHash64(number, 4) % 8 + 1],
['US','IN','DE','GB','BR','JP','FR','SG','AU','CA','NL','ES'][cityHash64(number, 5) % 12 + 1],
['mobile','mobile','desktop','tablet'][cityHash64(number, 6) % 4 + 1],
['chrome','safari','firefox','edge','samsung'][cityHash64(number, 7) % 5 + 1],
concat('https://shop.example.com/',
['home','search','product','cart','checkout','account','help'][cityHash64(number, 8) % 7 + 1],
'/', toString(cityHash64(number, 9) % 250000), '?ref=', hex(cityHash64(number, 10) % 65536)),
toUInt32(20 + cityHash64(number, 11) % 180 + if(cityHash64(number, 12) % 100 = 0, 2000, 0)),
if(cityHash64(number, 4) % 8 = 7, toDecimal64(5 + cityHash64(number, 13) % 29500 / 100, 2), toDecimal64(0, 2))
FROM numbers(40000000);
OPTIMIZE TABLE rt.events FINAL;
-- A cross-tenant timeline copy, the shape most "what is happening now" panels read
CREATE TABLE rt.events_timeline
(
event_minute DateTime,
event_time DateTime,
tenant_id UInt32,
event_type LowCardinality(String),
latency_ms UInt32,
revenue Decimal(12, 2)
)
ENGINE = MergeTree
ORDER BY (event_minute, tenant_id)
SETTINGS index_granularity = 8192,
min_bytes_for_wide_part = 0,
min_rows_for_wide_part = 0;
INSERT INTO rt.events_timeline
SELECT toStartOfMinute(event_time), event_time, tenant_id, event_type, latency_ms, revenue
FROM rt.events;
OPTIMIZE TABLE rt.events_timeline FINAL;rt.events landed as 8 parts, 1.39 GiB on disk and 3.51 GiB uncompressed. rt.events_timeline is a single part of 4,883 granules. The OPTIMIZE ... FINAL statements are lab hygiene to get a stable part layout; do not copy them into a production runbook.
Top-K dynamic filtering in ClickHouse 26.10: GROUP BY that stops at the limit
The panel every operations dashboard has is “the last N time buckets”: group by a time bucket, order by it, keep a handful. Until now ClickHouse aggregated every bucket in the table and threw away all but N at the end, unless you remembered to add a time predicate. In ClickHouse 26.10 the aggregation step keeps a small heap of the best keys seen so far and publishes the worst of them back to the reader as a filter. Granules whose key range cannot beat that boundary are never read.
Figure 2. Top-K dynamic filtering in ClickHouse 26.10. The aggregation heap feeds a boundary back into the MergeTree reader, which skips granules by primary key.
SELECT
event_minute,
count() AS events,
sum(revenue) AS revenue,
quantile(0.99)(latency_ms) AS p99_ms
FROM rt.events_timeline
GROUP BY event_minute
ORDER BY event_minute ASC
LIMIT 15
SETTINGS enable_group_by_top_k_dynamic_filtering = 1; -- 0 for the baselineThe plan shows the mechanism directly. Note the Top-K line on the aggregation step and the synthetic prewhere column on the read:
Limit (preliminary LIMIT)
└──Sorting (Sorting for ORDER BY)
│ Sort description: event_minute ASC
│ Limit 15
└──Aggregating
│ Keys: event_minute
│ Aggregates: count(), sum(revenue), quantile(0.99)(latency_ms)
│ Top-K: limit=15, columns=1, directions=[1]
└──ReadFromMergeTree (rt.events_timeline)
Parts: 1 | Granules: 4883
Prewhere filter column: __topKFilter(event_minute)
... (five lines trimmed: limit/offset, skip merging, read type, output columns)| Variant | Median ms (range) | Rows read | TopKGranulesSkippedByPrimaryKey |
|---|---|---|---|
| ASC, filter off | 241 (210 to 276) | 40,000,000 | 0 |
| ASC, filter on | 7 (7 to 8) | 122,880 to 131,072 | 4,867 to 4,868 |
| DESC, filter off | 427 (410 to 597) | 40,000,000 | 0 |
| DESC, filter on, 2 threads | 289 (276 to 362) | 19.4M to 19.9M | 2,450 to 2,513 |
DESC, filter on, max_threads = 1 | 1,139 (1,068 to 1,356) | 40,000,000 | 0 |
Top-K GROUP BY on the ClickHouse 26.10 lab build: rt.events_timeline, 40M rows, 15 buckets, five runs per variant.
The descending case is the one dashboards actually run
Ascending order is the easy direction: the reader starts at the front of the key, the heap fills with the smallest minutes at once, and almost everything after that is skipped. “Latest 15 minutes” is the opposite. The reader still walks the part front to back, so the boundary only becomes useful when a second thread happens to start in the newer half. With two threads that skipped about half the granules. With one thread it skipped none.
Two fixes worked in our lab. The first is the old one and still the right default: bound the scan with a time predicate so the primary key prunes before aggregation starts. The second is a descending sort key, which lets ClickHouse 26.10 read the newest data first:
CREATE TABLE rt.events_timeline_desc
(
event_minute DateTime,
event_time DateTime,
tenant_id UInt32,
event_type LowCardinality(String),
latency_ms UInt32,
revenue Decimal(12, 2)
)
ENGINE = MergeTree
ORDER BY (event_minute DESC, tenant_id)
SETTINGS index_granularity = 8192,
min_bytes_for_wide_part = 0,
min_rows_for_wide_part = 0,
allow_experimental_reverse_key = 1;On that table the descending query fell from 208 ms (186 to 245) to 20 ms (19 to 27), and bytes read fell from 640 MB to 161 MB. The granule-skip counter stayed at zero, so the saving came from the prewhere filter discarding rows before the other columns were read, not from index pruning. Descending keys are still gated by an experimental MergeTree setting, so we would prototype with them and ship the time predicate.
Rolling windows in ClickHouse 26.10: the query condition cache meets now()
The query condition cache remembers, per part and per filter, which granules contained no matching rows. It has always had a blind spot for real-time analytics: a filter such as event_time >= now() - INTERVAL 12 HOUR is a different condition every second, so nothing could be reused. ClickHouse 26.10 addresses this by rounding the time constant onto a grid whose step follows the look-back distance. Writes round the bound up, reads round it down, and that asymmetry keeps a cached “nothing here” answer correct.
Figure 3. How ClickHouse 26.10 rounds a now() bound onto a time grid so the query condition cache can serve rolling-window filters.
We filtered the timeline table on event_time, which is deliberately not in its sort key, so the primary index cannot help and every skipped granule is the cache at work.
SELECT
tenant_id,
count() AS events,
quantile(0.99)(latency_ms) AS p99_ms
FROM rt.events_timeline
WHERE event_time >= today() - 1
GROUP BY tenant_id
ORDER BY p99_ms DESC
LIMIT 20
SETTINGS use_query_condition_cache = 1,
use_query_condition_cache_for_time_conditions = 1;| Filter bound | Time-condition switch | First run | Repeat runs |
|---|---|---|---|
toDateTime('2026-11-20 10:00:00') | not needed | 40.0M rows, 95 ms | 1.45M rows, 28 to 31 ms |
today() - 1 | 0 | 40.0M rows, 216 ms median | 40.0M rows, no cache hits |
today() - 1 | 1 | 40.0M rows, 225 ms | 9.53M rows, 146 to 170 ms |
now() - INTERVAL 12 HOUR | 1 | 40.0M rows, 114 ms median | 40.0M rows, no hits, including after a 75 s wait |
Query condition cache behaviour on the ClickHouse 26.10 lab build, cache dropped before each series.
Three things to take from this. First, on our build the switch reports default = 0 and tier = Experimental, so a stock configuration behaves exactly as before; the feature is something you opt into per query or per profile. Second, grid-aligned bounds such as today() - N or toStartOfDay(now()) hit on the next run and stay valid for the rest of the cell. Third, an unaligned sliding bound writes entries that only become readable in the following grid cell. For a 12-hour look-back that is up to 12 hours away, which we did not wait for.
For dashboard authors the practical move does not need the new switch at all: where the panel tolerates it, align the lower bound to the bucket (toStartOfHour(now()) - INTERVAL 24 HOUR, or a literal the application computes once a minute). A deterministic bound has been cacheable since the condition cache arrived, and in our run it cut the repeat read by 96 percent.
Enrichment joins on a shared sort key in ClickHouse 26.10
Real-time pipelines join fact streams to slowly changing sets all the time: sessions to attribution, orders to accounts, devices to firmware. When both tables are sorted by the join key, a merge join needs no hash table at all. The catch was that it ran on one stream. ClickHouse 26.10 splits both sides into matching primary-key ranges and runs an independent merge join per range, on by default.
Figure 4. A ClickHouse 26.10 merge join sharded by primary key ranges: each thread joins one pre-sorted slice of both tables.
-- 11,573,369 sessions joined to 8,999,013 attribution rows; both tables ORDER BY session_id
SELECT
a.channel,
count() AS sessions,
sum(s.revenue) AS revenue
FROM rt.sessions AS s
INNER JOIN rt.session_attribution AS a
ON s.session_id = a.session_id
GROUP BY a.channel
ORDER BY revenue DESC
SETTINGS join_algorithm = 'full_sorting_merge',
query_plan_join_shard_by_pk_ranges = 1; -- 0 for the unsharded baseline| Join strategy | Median ms (range) | Smallest max_memory_usage that completes |
|---|---|---|
| Merge join, sharding off | 709 (679 to 746) | 79 MiB |
| Merge join, sharding on | 485 (448 to 537) | 9 MiB |
| Hash join | 858 (775 to 875) | 359 MiB |
Join strategies on the ClickHouse 26.10 lab build, 2 threads, five runs each.
On two threads the gain is 32 percent, which is roughly what two lanes can give. The ClickHouse 26.10 release call reports a far larger gain on a wide server for a 200M by 50M row join, and the mechanism supports that: lanes scale with cores. What interested us more is the memory column. A join that fits in single-digit MiB cannot be the query that takes the node down at peak, and you get it without touching the default join_algorithm for everything else. Set the algorithm per query on the joins whose tables you have deliberately co-sorted.
Funnel filters: ClickHouse 26.10 IN subqueries that spill instead of failing
“Purchases from sessions that added to cart” is a set-membership query, and the set is built in memory. With enough sessions it is the query that trips MEMORY_LIMIT_EXCEEDED on a shared cluster. ClickHouse 26.10 lets the set spill to disk once it crosses a threshold.
SELECT
country,
count() AS purchases,
sum(revenue) AS revenue
FROM rt.events
WHERE event_type = 'purchase'
AND session_id IN
(
SELECT session_id
FROM rt.events
WHERE event_type = 'add_to_cart' -- 4,090,534 distinct sessions
)
GROUP BY country
ORDER BY revenue DESC
SETTINGS max_memory_usage = '128Mi',
max_bytes_before_external_set = '32Mi';Without the spill threshold and under the same 128 MiB cap, this is what came back:
Code: 241. DB::Exception: Query memory limit exceeded: would use 178.04 MiB (attempt to allocate chunk of 126.01 MiB), maximum: 128.00 MiB: While executing CreatingSetsTransform. (MEMORY_LIMIT_EXCEEDED)
| Configuration | Median ms (range) | Smallest limit that completes | Spill events |
|---|---|---|---|
| Set in memory | 689 (661 to 719) | 183 MiB | none |
max_bytes_before_external_set = '32Mi' | 3,678 (3,569 to 3,835) | 51 MiB | SetsSpilledToDisk 1, ExternalSetWritePart 2, about 16.1 MB compressed |
IN subquery set handling on the ClickHouse 26.10 lab build, five runs each.
That is a 72 percent cut in required memory for 5.3 times the latency. Read it as a guard rail: the query finishes instead of failing, and it is slow enough that you will notice and fix the data model. The changelog also describes a ratio-based trigger, max_bytes_ratio_before_external_set, at 0.5 by default. In a separate run with a tuple-keyed set and a 256 MiB cap, the default ratio alone did not save the query, so set the absolute threshold explicitly on the profiles where it matters.
Repeat reads in ClickHouse 26.10: the columns cache and string filtering during the scan
The ClickHouse 26.10 columns cache (experimental)
A dashboard that refreshes every few seconds decompresses and deserialises the same granules again and again. The page cache saves the disk read, not the decoding. The columns cache in ClickHouse 26.10 keeps decoded column ranges of wide parts in memory. It is experimental and off by default.
SELECT country, device, count() AS c, avg(latency_ms) AS l FROM rt.events WHERE event_time >= '2026-11-20 00:00:00' GROUP BY country, device SETTINGS use_columns_cache = 1;
Over 3.81 million rows the query took 39 ms (36 to 67) with the cache off. With it on, the first run took 59 ms while it recorded 1,864 misses, and the next five took 26 to 37 ms with 1,864 hits each. A LIKE scan of the whole url column, roughly 2 GB decoded, behaved very differently: 4,887 misses on every run and no hits. The server setting columns_cache_size had defaulted to 841 MB (columns_cache_size_to_ram_ratio = 0.1), and the column did not fit. Size the cache to the hot set you expect to serve, or it will churn.
String filtering during the scan
LIKE, startsWith, endsWith and position filters are evaluated in ClickHouse 26.10 while a string column is being deserialised, so non-matching values are never copied into a block. The switch is apply_string_filters_during_scan, on by default.
SELECT count() FROM rt.events WHERE url LIKE '%/checkout/%' -- 5,715,813 of 40,000,000 rows match SETTINGS apply_string_filters_during_scan = 1; -- 0 for the previous behaviour
Bytes read into query blocks dropped from 1,970 MB to 397 MB. Elapsed time did not improve: 657 ms (617 to 769) off against 925 ms (761 to 936) on in one session, and 610 to 727 ms against 685 to 833 ms in fresh processes. With 14 percent of rows matching on two cores, the per-value check costs about what the copy saved. We also could not isolate the peak-memory change, because the embedded process idles near 475 MiB and the difference sat inside that noise. Expect this one to pay on selective filters over long strings, such as log bodies, on memory-tight nodes.
What a two-core lab cannot show about ClickHouse 26.10
Three ClickHouse 26.10 changes target concurrency and large hash tables, and we are not going to pretend a small box measured them. The figures in this section are the upstream ones from the ClickHouse 26.10 release call, attributed as such.
Hash tables at a 0.9 load factor. Large hash tables move to Robin Hood hashing in place, lifting the maximum load factor from 0.5 to 0.9. Upstream reports a GROUP BY over 10 million keys dropping from 24.7 GB to 16.3 GB and a 100-million-value uniqExact from 13.5 GB to 4.6 GB. For user-level and session-level rollups, that is headroom you get without touching a schema.
Narrower pipelines under load. A busy server no longer gives every query one processing lane per core. Upstream measured ten concurrent clients on 96 cores and reported lower p99 memory and about 15 percent less CPU time per query. For a serving tier this matters more than any single-query number.
Query-aware workload schedulers. Workloads in ClickHouse 26.10 gain fair, las (short queries first) and priority schedulers alongside fifo, plus memory limits with a spill threshold. The statements below were accepted by our build and the workload was usable from a query; we have not load-tested the scheduling behaviour.
CREATE RESOURCE cpu (MASTER THREAD, WORKER THREAD);
CREATE OR REPLACE WORKLOAD all
SETTINGS scheduler = 'las'; -- short queries first
CREATE OR REPLACE WORKLOAD dashboards IN all
SETTINGS weight = 9;
CREATE OR REPLACE WORKLOAD adhoc IN all
SETTINGS weight = 1,
max_memory = '16Gi',
max_memory_before_spill = '8Gi';
-- Verify, then route a query
SELECT name, parent, create_query FROM system.workloads ORDER BY name;
SELECT count() FROM rt.events SETTINGS workload = 'dashboards';
-- Rollback: DROP WORKLOAD adhoc; DROP WORKLOAD dashboards; DROP WORKLOAD all; DROP RESOURCE cpu;Before you upgrade to ClickHouse 26.10
The ClickHouse 26.10 changelog lists 37 backward-incompatible changes. These are the ones we would check first on a real-time analytics cluster. Blast radius for all of them is the whole cluster once the first replica restarts on the new binary, and the rollback path is a binary downgrade, so rehearse on a restored copy.
| Change | Who is hit | Action before the first node is upgraded |
|---|---|---|
| The pre-analyzer query path is removed | Mixed-version clusters during a rolling upgrade; anyone still running enable_analyzer = 0 | Set enable_analyzer = 1 on every server and soak it on the current version first |
system.metric_log moves to a bucketed Map schema | Exporters and dashboards that read metric columns from it | Test collectors; add <schema_type>wide</schema_type> under <metric_log> to keep the old layout |
| External join thresholds act as hard caps for all hash joins | Profiles with max_bytes_before_external_join set low | Review the thresholds; legacy_join_size_limits_trigger_spilling = 1 restores the old behaviour |
skip_unavailable_shards = 1 now errors when every shard is skipped | Distributed reads that relied on an empty result | Handle ALL_CONNECTION_TRIES_FAILED in the application |
| Named collection overrides need an extra grant | Tables and dictionaries that override collection keys | Recreate tables that override NOT OVERRIDABLE keys, or the server will not start |
| Non-compact Distributed queue format is removed | Clusters with use_compact_format_in_distributed_parts_names = 0 | Set it to 1 and let the queues drain |
| Seccomp filter is applied at startup | Sandboxed containers; executable UDFs | Set seccomp to log or disabled where the syscall is refused |
arrayCount returns UInt64 | Materialized views and inserts with strict target types | Set array_count_legacy_uint32_result = 1 during the rolling upgrade |
Run this on the current version and again on a ClickHouse 26.10 test node, and diff the output. It is read-only. Our build returned the block below; note that enable_analyzer is already reported as Obsolete.
SELECT name, value, default, tier
FROM system.settings
WHERE name IN
(
'enable_group_by_top_k_dynamic_filtering',
'query_plan_join_shard_by_pk_ranges',
'apply_string_filters_during_scan',
'max_bytes_before_external_set',
'max_bytes_ratio_before_external_set',
'use_query_condition_cache',
'use_query_condition_cache_for_time_conditions',
'use_columns_cache',
'enable_analyzer'
)
ORDER BY name;┌─name──────────────────────────────────────────┬─value─┬─default─┬─tier─────────┐ │ apply_string_filters_during_scan │ 1 │ 1 │ Production │ │ enable_analyzer │ 1 │ 1 │ Obsolete │ │ enable_group_by_top_k_dynamic_filtering │ 1 │ 1 │ Production │ │ max_bytes_before_external_set │ 0 │ 0 │ Production │ │ max_bytes_ratio_before_external_set │ 0.5 │ 0.5 │ Production │ │ query_plan_join_shard_by_pk_ranges │ 1 │ 1 │ Production │ │ use_columns_cache │ 0 │ 0 │ Experimental │ │ use_query_condition_cache │ 1 │ 1 │ Production │ │ use_query_condition_cache_for_time_conditions │ 0 │ 0 │ Experimental │ └───────────────────────────────────────────────┴───────┴─────────┴──────────────┘
Our stance on ClickHouse 26.10, November 2026
ClickHouse 26.10 is a monthly release, not an LTS. For fleets that upgrade twice a year, stay on 26.8 LTS and put 26.10 in a test environment now, because 26.9 and 26.10 between them remove the old analyzer path and you want that rehearsal done long before the next LTS forces it.
For teams already on the monthly train, we would move to ClickHouse 26.10 for three workloads: Top-K panels over a time-sorted key, joins between tables that share a sort key, and multi-tenant clusters where one oversized IN set can starve everyone else. We would keep the time-condition cache, the columns cache and descending sort keys out of production profiles until they leave the Experimental tier, and we would not change a default-on setting without a before-and-after from system.query_log on your own queries.
Everything above was measured on one small machine with synthetic data. Test on your own workload before applying any of it to production, and keep a restore you have actually exercised. If you want a second pair of eyes on a ClickHouse 26.10 upgrade plan or on the query patterns behind a slow dashboard, our ClickHouse consulting and 24×7 ClickHouse support teams do this work every week.
Running ClickHouse in production? ChistaDATA provides ClickHouse consulting for architecture, performance and migrations, and 24×7 ClickHouse support with a 15-minute S1 response. For day-to-day operations see ClickHouse DBA services and ClickHouse managed services.