Quantrail Data

Published on: March 26, 2026
Version: 26.3 (Long-Term Support)

ClickHouse® 26.3 LTS is a significant release that improves performance, correctness, and usability across the system. While the official changelog is extensive, it is not always easy to understand what actually matters – especially for beginners or engineers new to ClickHouse®.

This article explains the key changes in a structured way, focusing on how they affect real-world usage rather than listing every update.

What is an LTS Release?

An LTS (Long-Term Support) release is designed for stability and production use. It consolidates improvements made over previous versions and ensures they are reliable enough for long-term deployment.

If you are running ClickHouse® in production, this is the type of release you should consider upgrading to.

Key Theme of This Release

ClickHouse® 26.3 focuses on four main areas:

1. Query performance at scale
2. SQL correctness and standards compliance
3. Better support for modern data formats (especially JSON and data lakes)
4. Improved developer experience and safety

Breaking Changes You Should Understand First

SQL Operator Behavior is Now Standard-Compliant

The behavior of the NOT operator has been corrected to follow standard SQL rules.

Previously, ClickHouse® interpreted expressions differently from most SQL systems. This could lead to subtle bugs.

Now, expressions like:

SELECT NOT value IS NULL FROM table;

are interpreted as:

SELECT NOT (value IS NULL) FROM table;

Why this matters

Consider this example:

SELECT NOT x IS NULL;

• Old behavior: (NOT x) IS NULL → could lead to unexpected results
• New behavior: NOT (x IS NULL) → NOT true → false

If you relied on the old interpretation, your query results may change after upgrading.

Upgrade vs Downgrade Compatibility

A critical change affects how data is stored:

• New data written in this version cannot be read by older versions
• Older data remains fully readable in this version

This means:

• Upgrading is safe
• Downgrading is not safe

This is important for teams using rolling upgrades or maintaining rollback strategies.

Removal of Experimental Features

Some rarely used experimental features have been removed:

• Hypothesis skip index
• detectProgrammingLanguage function

Most users will not be affected, but if you used these features, queries will fail after upgrade.

New Features Explained

Materialized CTEs

Common Table Expressions (CTEs) can now be materialized.

In earlier versions, a CTE could be executed multiple times within a query. Now, it can be computed once and reused.

This improves performance in queries where the same intermediate result is referenced multiple times.

This is especially useful for:

• Complex analytical queries
• Queries with repeated subqueries
• Large datasets where recomputation is expensive

Async Inserts Enabled by Default

ClickHouse® now batches small insert operations automatically.

Previously, each insert could trigger immediate processing, which is inefficient for high-frequency small writes.

Now:

• Inserts are grouped internally
• Write throughput improves
• System overhead is reduced

This change benefits:

• Streaming pipelines
• Event ingestion systems
• Logging use cases

You can still control this behavior at different levels (query, session, or configuration).

Example

Instead of many small inserts like:

INSERT INTO logs VALUES (...);
INSERT INTO logs VALUES (...);
INSERT INTO logs VALUES (...);

ClickHouse® internally batches them into fewer operations.

Improved JSON Support

ClickHouse® continues to expand its JSON capabilities.

New improvements include:

• Direct JSON input support in extraction functions
• Ability to check if a JSON path exists
• Experimental lazy type hints for JSON columns

this means:

You can now work with semi-structured data more naturally, without extensive preprocessing.

Better Query Plan Visualization

The EXPLAIN command now supports a more readable format.

This helps you understand how queries are executed, which is essential for debugging and optimization.

For new users, this reduces the learning curve when trying to understand query performance.

Read-Only Tables

You can now mark tables as read-only.

This prevents accidental modifications such as inserts or updates.

Useful scenarios include:

• Protecting critical datasets
• Working with snapshots
• Ensuring reproducibility in analytics

Performance Improvements That Make a Real Difference

Performance is where this release stands out.

Major Improvement in Data Lake Queries

ClickHouse® significantly improves how it reads from object storage systems.

Previously:

• Query execution did not fully utilize available CPU cores

Now:

• Execution pipelines scale with available threads

This results in very large performance gains, especially when working with:

• S3
• Iceberg
• External storage systems

Smarter Partition Pruning

ClickHouse® can now optimize queries even when partition keys are wrapped in functions.

Example

SELECT *
FROM events
WHERE toYYYYMM(event_date) = 202603;

Previously, this could prevent partition pruning.

Now:

• ClickHouse® understands the transformation
• Skips irrelevant partitions
• Reduces data scanned

Better Use of Indexes

ClickHouse® now applies indexes more effectively in complex scenarios, including:

• Comparisons between different data types
• Nullable type conversions
• Expressions involving functions

This means more queries automatically become efficient without requiring manual tuning.

Improved Join Optimization

Joins are optimized more intelligently:

• The query planner can reorder joins
• Some outer joins can be converted into inner joins when safe
• Performance improves without changing query logic

Memory and Cache Efficiency

Internal improvements reduce memory usage and improve caching behavior.

For example:

• Metadata from Parquet files is cached
• Large queries use memory more efficiently

This improves stability under heavy workloads.

Experimental Features to Watch

WebAssembly-Based UDFs

ClickHouse® introduces experimental support for user-defined functions written in WebAssembly.

This allows developers to write custom logic outside SQL while maintaining performance and safety.

Although still experimental, this feature could expand how ClickHouse® is extended in the future.

Improvements in Reliability and Security

This release includes a large number of fixes, including:

• Query correctness issues
• Memory handling bugs
• Access control improvements
• Stability improvements in distributed environments

These fixes reduce the risk of:

• Incorrect query results
• Crashes under load
• Security vulnerabilities

Improvements for Developers and Operators

Better Error Messages

Error handling is clearer and more informative.

This reduces debugging time and helps new users understand issues more quickly.

Unicode and Text Processing

New string functions improve handling of multilingual data.

This is particularly useful for:

• Search systems
• Text analytics
• International datasets

Text Index Improvements

Text indexing is more efficient and flexible.

This is useful for:

• Log analysis
• Search use cases
• Natural language data

When Should You Upgrade?

You should consider upgrading to 26.3 LTS if:

• You are running production workloads
• You rely on data lake integrations
• You want better performance without rewriting queries
• You need improved SQL correctness

Be cautious if:

• You depend on legacy NOT operator behavior
• You need downgrade capability

Conclusion

ClickHouse® 26.3 LTS is a stability-focused release that also delivers meaningful improvements in performance and usability.

Instead of introducing many isolated features, it strengthens the core system:

• Queries are faster
• Behavior is more predictable
• Integration with modern data systems is improved

For most users, the biggest benefit is not new features, but better performance and reliability for existing workloads.

References

https://clickhouse.com/docs/whats-new/changelog