ClickHouse MergeTree: Optimizing Merge Behaviour for Performance


In ClickHouse, the concept of a “compaction factor” isn’t used in the same way as it might be in other database systems, like those using LSM trees (e.g., Cassandra). Instead, ClickHouse utilizes a merge process, especially in ClickHouse MergeTree family table engines, which is somewhat analogous to compaction in other databases. This process involves combining smaller data parts into larger ones, which can affect query performance.

Runbook for Optimizing Merge Behavior for Performance

While you cannot directly configure a “compaction factor” in ClickHouse, you can control the behavior of the merge process. Here’s how you can optimize this for better query performance.

1. Understanding ClickHouse MergeTree Settings

  • ClickHouse’s MergeTree engine automatically merges data parts in the background. The frequency and size of these merges can impact query performance and disk I/O.

2. Adjusting Merge Settings

  • parts_to_throw_insert: Determines the number of parts after which the server starts to aggressively merge parts to decrease their number.
  • parts_to_delay_insert: Once the number of parts reaches this threshold, ClickHouse starts to delay insert queries to allow time for background merges.
  • max_bytes_to_merge_at_max_space_in_pool: Sets the maximum total size of parts to be merged in one merge operation.
  • max_bytes_to_merge_at_min_space_in_pool: Sets the minimum total size of parts to be merged in one merge operation.

3. Configuring Merge Frequency

  • Adjust settings like max_parts_in_totalmax_parts_to_throw_insert, and max_parts_to_delay_insert in the MergeTree table settings to influence how often and how much data is merged.

4. Disk Space for Merging

  • Ensure there is enough disk space for merging operations. Merges can require significant additional temporary space.

5. Monitor Merge Impact

  • Use system tables like system.merges to monitor ongoing merge operations and understand their impact on system performance.

6. Optimize Data Insertions

  • Design your data ingestion patterns to minimize the creation of excessive small parts. Bulk insertions are generally more efficient than very frequent small insertions.

7. Consider Data Partitioning

  • Proper data partitioning can help manage the merge process more effectively. Each partition is merged independently, so consider how your data is partitioned.

8. Regular Maintenance

  • Regularly monitor and possibly optimize table indices, and consider routine operations like DETACH and ATTACH to manage old data.

9. Update and Fine-Tuning

  • Stay updated with the latest ClickHouse versions as there are frequent improvements. Regularly fine-tune settings based on your workload and observe the impact.


While there isn’t a direct “compaction factor” setting in ClickHouse, managing the merge behavior in MergeTree table engines is key to optimizing query performance. This involves a balance between maintaining smaller data parts for insert efficiency and larger parts for query efficiency. Monitoring and regularly adjusting settings based on your specific workload and data patterns is crucial for maintaining optimal performance in a ClickHouse environment.

To read more about ClickHouse MergeTree, do consider reading the following articles:

About Shiv Iyer 222 Articles
Open Source Database Systems Engineer with a deep understanding of Optimizer Internals, Performance Engineering, Scalability and Data SRE. Shiv currently is the Founder, Investor, Board Member and CEO of multiple Database Systems Infrastructure Operations companies in the Transaction Processing Computing and ColumnStores ecosystem. He is also a frequent speaker in open source software conferences globally.