# Server settings (/docs/reference/sql/settings/server)



Server settings [#server-settings]

This page describes the RawTree engine binary used to generate this reference. It does not define Query API support. Descriptions retain upstream ClickHouse terminology. See [SQL interface scope](/docs/reference/clickhouse-compatibility#service-interfaces).

Operators configure RawTree server settings. In RawTree Cloud and RawTree BYOC, the deployment operators control this configuration.

abort_on_logical_error [#abort_on_logical_error]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
Crash the server on LOGICAL\_ERROR exceptions. Only for experts.

aggregate_function_group_array_action_when_limit_is_reached [#aggregate_function_group_array_action_when_limit_is_reached]

**Type:** `GroupArrayActionWhenLimitReached`\
**Default:** `throw`\
**Changeable without restart:** `No`\
Action to execute when max array element size is exceeded in groupArray: `throw` exception, or `discard` extra values

aggregate_function_group_array_max_element_size [#aggregate_function_group_array_max_element_size]

**Type:** `UInt64`\
**Default:** `16777215`\
**Changeable without restart:** `No`\
Max array element size in bytes for groupArray function. This limit is checked at serialization and help to avoid large state size.

ai_function_allow_sql_named_collections [#ai_function_allow_sql_named_collections]

**Type:** `Bool`\
**Default:** `1`\
**Changeable without restart:** `No`\
Allows AI functions (such as `aiGenerate`, `aiEmbed`, `aiSimilarity`) to use named collections created with `CREATE NAMED COLLECTION`. When disabled, AI functions accept only named collections defined in the server configuration file, and using any other collection throws an exception. This applies both to the `credentials` parameter and to the `ai_function_text_default_credentials` and `ai_function_embedding_default_credentials` settings.

allow_experimental_executable_udf_drivers [#allow_experimental_executable_udf_drivers]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Enable experimental support for drivers for executable user-defined functions, declared via `user_defined_executable_function_drivers_config`. A driver turns a user code snippet supplied in `CREATE FUNCTION ... ENGINE = DriverName(...) AS '...'` into a runnable executable UDF.

allow_experimental_webassembly_udf [#allow_experimental_webassembly_udf]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Enable experimental support for WebAssembly UDFs

allow_feature_tier [#allow_feature_tier]

**Type:** `UInt32`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
Controls if the user can change settings related to the different feature tiers. - `0` - Changes to any setting are allowed (experimental, private preview, beta, production). - `1` - Only changes to private preview, beta and production feature settings are allowed. Changes to experimental settings are rejected. - `2` - Only changes to beta and production feature settings are allowed. Changes to experimental or private preview settings are rejected. - `3` - Only changes to production settings are allowed. Changes to experimental, private preview or beta settings are rejected. This is equivalent to setting a readonly constraint on all `EXPERIMENTAL` / `PRIVATE PREVIEW` / `BETA` features. :::note A value of `0` means that all settings can be changed. ::: :::note `2` previously meant "production settings only". It now also allows beta settings, so a configuration that pinned `2` to allow production settings only must use `3`. :::

allow_use_jemalloc_memory [#allow_use_jemalloc_memory]

**Type:** `Bool`\
**Default:** `1`\
**Changeable without restart:** `No`\
Allows to use jemalloc memory.

allowed_disks_for_table_engines [#allowed_disks_for_table_engines]

**Type:** `String`\
**Default:** \`\`\
**Changeable without restart:** `No`\
List of disks allowed for use with Iceberg

async_insert_queue_flush_on_shutdown [#async_insert_queue_flush_on_shutdown]

**Type:** `Bool`\
**Default:** `1`\
**Changeable without restart:** `No`\
If true queue of asynchronous inserts is flushed on graceful shutdown

async_insert_threads [#async_insert_threads]

**Type:** `UInt64`\
**Default:** `16`\
**Changeable without restart:** `No`\
Maximum number of threads to actually parse and insert data in background. Zero means asynchronous mode is disabled

async_load_databases [#async_load_databases]

**Type:** `Bool`\
**Default:** `1`\
**Changeable without restart:** `No`\
Asynchronous loading of databases and tables. - If `true` all non-system databases with `Ordinary`, `Atomic` and `Replicated` engine will be loaded asynchronously after the RawTree server start up. See `system.asynchronous_loader` table, `tables_loader_background_pool_size` and `tables_loader_foreground_pool_size` server settings. Any query that tries to access a table, that is not yet loaded, will wait for exactly this table to be started up. If load job fails, query will rethrow an error (instead of shutting down the whole server in case of `async_load_databases = false`). The table that is waited for by at least one query will be loaded with higher priority. DDL queries on a database will wait for exactly that database to be started up. Also consider setting a limit `max_waiting_queries` for the total number of waiting queries. - If `false`, all databases are loaded when the server starts. **Example** `xml <async_load_databases>true</async_load_databases> `

async_load_system_database [#async_load_system_database]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Asynchronous loading of system tables. Helpful if there is a high amount of log tables and parts in the `system` database. Independent of the `async_load_databases` setting. - If set to `true`, all system databases with `Ordinary`, `Atomic`, and `Replicated` engines will be loaded asynchronously after the RawTree server starts. See `system.asynchronous_loader` table, `tables_loader_background_pool_size` and `tables_loader_foreground_pool_size` server settings. Any query that tries to access a system table, that is not yet loaded, will wait for exactly this table to be started up. The table that is waited for by at least one query will be loaded with higher priority. Also consider setting the `max_waiting_queries` setting to limit the total number of waiting queries. - If set to `false`, system database loads before server start. **Example** `xml <async_load_system_database>true</async_load_system_database> `

asynchronous_heavy_metrics_update_period_s [#asynchronous_heavy_metrics_update_period_s]

**Type:** `UInt32`\
**Default:** `120`\
**Changeable without restart:** `No`\
Period in seconds for updating heavy asynchronous metrics.

asynchronous_metrics_enable_heavy_metrics [#asynchronous_metrics_enable_heavy_metrics]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Enable the calculation of heavy asynchronous metrics.

asynchronous_metrics_keeper_metrics_only [#asynchronous_metrics_keeper_metrics_only]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Make asynchronous metrics calculate the keeper-related metrics only.

asynchronous_metrics_key_values_mode [#asynchronous_metrics_key_values_mode]

**Type:** `AsynchronousMetricsKeyValuesMode`\
**Default:** `key_values`\
**Changeable without restart:** `Yes`\
In which form the key-value asynchronous metrics - those broken down per CPU core, block device, network interface, disk, temperature sensor, memory controller or logging channel - are published to [`system.asynchronous_metrics`](/reference/system-tables/asynchronous_metrics), [`system.asynchronous_metric_log`](/reference/system-tables/asynchronous_metric_log), the Prometheus endpoint and Graphite. Possible values: - `key_values` - every family is a single key-value metric: a `Map` in the `key_values` column of `system.asynchronous_metrics`, one row per key in `system.asynchronous_metric_log`, one Prometheus sample per key carrying a label such as `device="sda"`, and a `<prefix>.<Metric>.<key>` Graphite path. - `legacy_names` - every key is a separate scalar metric with the key mangled into its name, as it was before version 26.8: `OSUserTimeCPU3`, `CPUFrequencyMHz_0`, `BlockReadBytes_sda`, `NetworkReceiveBytes_eth0`, `DiskTotal_default`, `Temperature0`, `EDAC0_Correctable`, and so on. - `both` - both forms are published at once, which is useful while the monitoring is being migrated. Beware of double counting in this mode: an aggregate over metric names matching a prefix, such as `sum(value) ... WHERE metric LIKE 'NetworkReceiveBytes%'`, counts every value twice. A key-value metric family introduced after version 26.8 has no legacy name and is always published in the key-value form. The setting is applied on the fly: it is re-read on every update of the asynchronous metrics, so `SYSTEM RELOAD CONFIG` is enough to switch the form without a restart.

asynchronous_metrics_update_period_s [#asynchronous_metrics_update_period_s]

**Type:** `UInt32`\
**Default:** `1`\
**Changeable without restart:** `No`\
Period in seconds for updating asynchronous metrics.

background_buffer_flush_schedule_pool_size [#background_buffer_flush_schedule_pool_size]

**Type:** `UInt64`\
**Default:** `16`\
**Changeable without restart:** `IncreaseOnly`\
The maximum number of threads that will be used for performing flush operations for [Buffer-engine tables](/reference/engines/table-engines/special/buffer) in the background.

background_common_pool_size [#background_common_pool_size]

**Type:** `UInt64`\
**Default:** `8`\
**Changeable without restart:** `No`\
The maximum number of threads that will be used for performing a variety of operations (mostly garbage collection) for [\*MergeTree-engine](/reference/engines/table-engines/mergetree-family) tables in the background.

background_distributed_schedule_pool_size [#background_distributed_schedule_pool_size]

**Type:** `UInt64`\
**Default:** `16`\
**Changeable without restart:** `IncreaseOnly`\
The maximum number of threads that will be used for executing distributed sends.

background_fetches_pool_size [#background_fetches_pool_size]

**Type:** `UInt64`\
**Default:** `16`\
**Changeable without restart:** `No`\
The maximum number of threads that will be used for fetching data parts from another replica for [\*MergeTree-engine](/reference/engines/table-engines/mergetree-family) tables in the background.

background_merges_mutations_concurrency_ratio [#background_merges_mutations_concurrency_ratio]

**Type:** `Float`\
**Default:** `2`\
**Changeable without restart:** `No`\
Sets a ratio between the number of threads and the number of background merges and mutations that can be executed concurrently. For example, if the ratio equals to 2 and [`background_pool_size`](/reference/settings/server-settings/settings/background#background_pool_size) is set to 16 then RawTree can execute 32 background merges concurrently. This is possible, because background operations could be suspended and postponed. This is needed to give small merges more execution priority. :::note You can only increase this ratio at runtime. To lower it you have to restart the server. As with the [`background_pool_size`](/reference/settings/server-settings/settings/background#background_pool_size) setting [`background_merges_mutations_concurrency_ratio`](/reference/settings/server-settings/settings/background-merges#background_merges_mutations_concurrency_ratio) could be applied from the `default` profile for backward compatibility. :::

background_merges_mutations_scheduling_policy [#background_merges_mutations_scheduling_policy]

**Type:** `String`\
**Default:** `round_robin`\
**Changeable without restart:** `No`\
The policy on how to perform a scheduling for background merges and mutations. Possible values are: `round_robin` and `shortest_task_first`. Algorithm used to select next merge or mutation to be executed by background thread pool. Policy may be changed at runtime without server restart. Could be applied from the `default` profile for backward compatibility. Possible values: - `round_robin` — Every concurrent merge and mutation is executed in round-robin order to ensure starvation-free operation. Smaller merges are completed faster than bigger ones just because they have fewer blocks to merge. - `shortest_task_first` — Always execute smaller merge or mutation. Merges and mutations are assigned priorities based on their resulting size. Merges with smaller sizes are strictly preferred over bigger ones. This policy ensures the fastest possible merge of small parts but can lead to indefinite starvation of big merges in partitions heavily overloaded by `INSERT`s.

background_message_broker_schedule_pool_size [#background_message_broker_schedule_pool_size]

**Type:** `UInt64`\
**Default:** `16`\
**Changeable without restart:** `IncreaseOnly`\
The maximum number of threads that will be used for executing background operations for message streaming.

background_move_pool_size [#background_move_pool_size]

**Type:** `UInt64`\
**Default:** `8`\
**Changeable without restart:** `No`\
The maximum number of threads that will be used for moving data parts to another disk or volume for \*MergeTree-engine tables in a background.

background_pool_size [#background_pool_size]

**Type:** `UInt64`\
**Default:** `16`\
**Changeable without restart:** `No`\
Sets the number of threads performing background merges and mutations for tables with MergeTree engines. :::note - This setting could also be applied at server startup from the `default` profile configuration for backward compatibility at the RawTree server start. - You can only increase the number of threads at runtime. - To lower the number of threads you have to restart the server. - By adjusting this setting, you manage CPU and disk load. ::: :::danger Smaller pool size utilizes less CPU and disk resources, but background processes advance slower which might eventually impact query performance. ::: Before changing it, please also take a look at related MergeTree settings, such as: - [`number_of_free_entries_in_pool_to_lower_max_size_of_merge`](/reference/settings/merge-tree-settings/number-of#number_of_free_entries_in_pool_to_lower_max_size_of_merge). - [`number_of_free_entries_in_pool_to_execute_mutation`](/reference/settings/merge-tree-settings/number-of#number_of_free_entries_in_pool_to_execute_mutation). - [`number_of_free_entries_in_pool_to_execute_optimize_entire_partition`](/reference/settings/merge-tree-settings/number-of#number_of_free_entries_in_pool_to_execute_optimize_entire_partition) **Example** `xml <background_pool_size>16</background_pool_size> `

background_schedule_pool_initial_size [#background_schedule_pool_initial_size]

**Type:** `UInt64`\
**Default:** `16`\
**Changeable without restart:** `No`\
Initial number of worker threads allocated for each background schedule pool. Each pool grows lazily up to its configured cap (`background_schedule_pool_size` and friends) when demand exceeds the current set of workers. Lower values reduce startup overhead and idle thread counts; higher values eliminate first-task scheduling latency on busy servers.

background_schedule_pool_max_parallel_tasks_per_type_ratio [#background_schedule_pool_max_parallel_tasks_per_type_ratio]

**Type:** `Float`\
**Default:** `0.8`\
**Changeable without restart:** `No`\
The maximum ratio of threads in the pool that can execute tasks of the same type simultaneously.

background_schedule_pool_size [#background_schedule_pool_size]

**Type:** `UInt64`\
**Default:** `512`\
**Changeable without restart:** `IncreaseOnly`\
The cap on the number of threads used to execute lightweight periodic operations for replicated tables, Kafka streaming, DNS cache updates, and similar tasks. Threads are spawned lazily on demand up to this cap, so a server with light background load uses far fewer threads than this number.

background_streaming_schedule_pool_size [#background_streaming_schedule_pool_size]

**Type:** `UInt64`\
**Default:** `16`\
**Changeable without restart:** `IncreaseOnly`\
The maximum number of threads that will be used for executing streaming background operations.

backup_threads [#backup_threads]

**Type:** `NonZeroUInt64`\
**Default:** `16`\
**Changeable without restart:** `No`\
The maximum number of threads to execute `BACKUP` requests.

backups_io_thread_pool_queue_size [#backups_io_thread_pool_queue_size]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
The maximum number of jobs that can be scheduled on the Backups IO Thread pool. It is recommended to keep this queue unlimited due to the current S3 backup logic. :::note A value of `0` (default) means unlimited. :::

cache_size_to_ram_max_ratio [#cache_size_to_ram_max_ratio]

**Type:** `Double`\
**Default:** `0.5`\
**Changeable without restart:** `No`\
Set cache size to RAM max ratio. Allows lowering the cache size on low-memory systems.

cannot_allocate_thread_fault_injection_probability [#cannot_allocate_thread_fault_injection_probability]

**Type:** `Double`\
**Default:** `0`\
**Changeable without restart:** `No`\
For testing purposes.

cgroups_memory_usage_observer_wait_time [#cgroups_memory_usage_observer_wait_time]

**Type:** `UInt64`\
**Default:** `15`\
**Changeable without restart:** `No`\
Interval in seconds during which the server's maximum allowed memory consumption is adjusted by the corresponding threshold in cgroups. To disable the cgroup observer, set this value to `0`.

compiled_expression_cache_elements_size [#compiled_expression_cache_elements_size]

**Type:** `UInt64`\
**Default:** `10000`\
**Changeable without restart:** `No`\
Sets the cache size (in elements) for [compiled expressions](/concepts/features/performance/caches/caches).

compiled_expression_cache_size [#compiled_expression_cache_size]

**Type:** `UInt64`\
**Default:** `134217728`\
**Changeable without restart:** `No`\
Sets the cache size (in bytes) for [compiled expressions](/concepts/features/performance/caches/caches).

concurrent_threads_lazy_allocation [#concurrent_threads_lazy_allocation]

**Type:** `Bool`\
**Default:** `1`\
**Changeable without restart:** `Yes`\
Controls how CPU slots are allocated to queries. When `true` (default), a query starts with one CPU slot and requests additional slots from the scheduler only when its pipeline actually pushes more parallelizable work. This avoids the situation where a query reserves up to `max_threads` slots but only ever uses a fraction of them, starving other concurrent queries. Applies both to concurrency control and to the preemptive CPU scheduler for workloads. When `false`, the query requests all `max_threads` slots up front at start.

concurrent_threads_scheduler [#concurrent_threads_scheduler]

**Type:** `String`\
**Default:** `max_min_fair`\
**Changeable without restart:** `Yes`\
The policy on how to perform a scheduling of CPU slots specified by `concurrent_threads_soft_limit_num` and `concurrent_threads_soft_limit_ratio_to_cores`. Algorithm used to govern how limited number of CPU slots are distributed among concurrent queries. Scheduler may be changed at runtime without server restart. Possible values: - `round_robin` — Every query with setting `use_concurrency_control` = 1 allocates up to `max_threads` CPU slots. One slot per thread. On contention CPU slot are granted to queries using round-robin. Note that the first slot is granted unconditionally, which could lead to unfairness and increased latency of queries having high `max_threads` in presence of high number of queries with `max_threads` = 1. - `fair_round_robin` — Every query with setting `use_concurrency_control` = 1 allocates up to `max_threads - 1` CPU slots. Variation of `round_robin` that does not require a CPU slot for the first thread of every query. This way queries having `max_threads` = 1 do not require any slot and could not unfairly allocate all slots. There are no slots granted unconditionally. - `max_min_fair` — Every query with setting `use_concurrency_control` = 1 allocates up to `max_threads - 1` CPU slots. Similar to `fair_round_robin`, but released slots are always granted to the query with the minimum number of currently allocated slots. This provides better fairness under high oversubscription, where many queries compete for limited CPU slots. Short-running queries are not penalized by long-running queries that have accumulated more slots over time.

concurrent_threads_soft_limit_num [#concurrent_threads_soft_limit_num]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
The maximum number of query processing threads, excluding threads for retrieving data from remote servers, allowed to run all queries. This is not a hard limit. In case if the limit is reached the query will still get at least one thread to run. Query can upscale to desired number of threads during execution if more threads become available. :::note A value of `0` (default) means unlimited. :::

concurrent_threads_soft_limit_ratio_to_cores [#concurrent_threads_soft_limit_ratio_to_cores]

**Type:** `UInt64`\
**Default:** `2`\
**Changeable without restart:** `Yes`\
Same as [`concurrent_threads_soft_limit_num`](#concurrent_threads_soft_limit_num), but with ratio to cores.

config-file [#config-file]

**Type:** `String`\
**Default:** `config.xml`\
**Changeable without restart:** `No`\
Points to the server config file.

config_reload_interval_ms [#config_reload_interval_ms]

**Type:** `UInt64`\
**Default:** `2000`\
**Changeable without restart:** `Yes`\
How often rawtree will reload config and check for new changes

cpu_slot_preemption [#cpu_slot_preemption]

**Type:** `Bool`\
**Default:** `1`\
**Changeable without restart:** `Yes`\
Defines how workload scheduling for CPU resources (MASTER THREAD and WORKER THREAD) is done. - If `true` (default), accounting is done based on actual CPU time consumed. A fair number of CPU time would be allocated to competing workloads. Slots are allocated for a limited amount of time and re-requested after expiry. Slot requesting may block thread execution in case of CPU resource overload, i.e., preemption may happen. This ensures CPU-time fairness. - If `false`, accounting is based on the number of CPU slots allocated. A fair number of CPU slots would be allocated to competing workloads. A slot is allocated when a thread starts, held continuously, and released when the thread ends execution. The number of threads allocated for query execution may only increase from 1 to `max_threads` and never decrease. This is more favorable to long-running queries and may lead to CPU starvation of short queries. **Example** `xml <cpu_slot_preemption>true</cpu_slot_preemption> ` **See Also** - [Workload Scheduling](/concepts/features/configuration/server-config/workload-scheduling)

cpu_slot_preemption_timeout_ms [#cpu_slot_preemption_timeout_ms]

**Type:** `UInt64`\
**Default:** `1000`\
**Changeable without restart:** `Yes`\
It defines how many milliseconds could a worker thread wait during preemption, i.e. while waiting for another CPU slot to be granted. After this timeout, if thread was unable to acquire a new CPU slot it will exit and the query is scaled down to a lower number of concurrently executing threads dynamically. Note that master thread never downscaled, but could be preempted indefinitely. Makes sense only when `cpu_slot_preemption` is enabled and CPU resource is defined for WORKER THREAD. **Example** `xml <cpu_slot_preemption_timeout_ms>1000</cpu_slot_preemption_timeout_ms> ` **See Also** - [Workload Scheduling](/concepts/features/configuration/server-config/workload-scheduling)

cpu_slot_quantum_ns [#cpu_slot_quantum_ns]

**Type:** `UInt64`\
**Default:** `10000000`\
**Changeable without restart:** `Yes`\
It defines how many CPU nanoseconds a thread is allowed to consume after acquired a CPU slot and before it should request another CPU slot. Makes sense only if `cpu_slot_preemption` is enabled and CPU resource is defined for MASTER THREAD or WORKER THREAD. **Example** `xml <cpu_slot_quantum_ns>10000000</cpu_slot_quantum_ns> ` **See Also** - [Workload Scheduling](/concepts/features/configuration/server-config/workload-scheduling)

database_atomic_delay_before_drop_table_sec [#database_atomic_delay_before_drop_table_sec]

**Type:** `UInt64`\
**Default:** `480`\
**Changeable without restart:** `No`\
The delay during which a dropped table can be restored using the [`UNDROP`](/reference/statements/undrop) statement. If `DROP TABLE` ran with a `SYNC` modifier, the setting is ignored. The default for this setting is `480` (8 minutes).

database_catalog_drop_error_cooldown_sec [#database_catalog_drop_error_cooldown_sec]

**Type:** `UInt64`\
**Default:** `5`\
**Changeable without restart:** `No`\
In case of a failed table drop, RawTree will wait for this time-out before retrying the operation.

database_catalog_drop_table_concurrency [#database_catalog_drop_table_concurrency]

**Type:** `UInt64`\
**Default:** `16`\
**Changeable without restart:** `No`\
The size of the threadpool used for dropping tables.

database_catalog_unused_dir_cleanup_period_sec [#database_catalog_unused_dir_cleanup_period_sec]

**Type:** `UInt64`\
**Default:** `86400`\
**Changeable without restart:** `No`\
Parameter of a task that cleans up garbage from `store/` directory. Sets scheduling period of the task. :::note A value of `0` means "never". The default value corresponds to 1 day. :::

database_catalog_unused_dir_hide_timeout_sec [#database_catalog_unused_dir_hide_timeout_sec]

**Type:** `UInt64`\
**Default:** `3600`\
**Changeable without restart:** `No`\
Parameter of a task that cleans up garbage from `store/` directory. If some subdirectory is not used by rawtree-server and this directory was not modified for last [`database_catalog_unused_dir_hide_timeout_sec`](/reference/settings/server-settings/settings/database-catalog#database_catalog_unused_dir_hide_timeout_sec) seconds, the task will "hide" this directory by removing all access rights. It also works for directories that rawtree-server does not expect to see inside `store/`. :::note A value of `0` means "immediately". :::

database_catalog_unused_dir_rm_timeout_sec [#database_catalog_unused_dir_rm_timeout_sec]

**Type:** `UInt64`\
**Default:** `2592000`\
**Changeable without restart:** `No`\
Parameter of a task that cleans up garbage from `store/` directory. If some subdirectory is not used by rawtree-server and it was previously "hidden" (see [database\_catalog\_unused\_dir\_hide\_timeout\_sec](/reference/settings/server-settings/settings/database-catalog#database_catalog_unused_dir_hide_timeout_sec)) and this directory was not modified for last [`database_catalog_unused_dir_rm_timeout_sec`](/reference/settings/server-settings/settings/database-catalog#database_catalog_unused_dir_rm_timeout_sec) seconds, the task will remove this directory. It also works for directories that rawtree-server does not expect to see inside `store/`. :::note A value of `0` means "never". The default value corresponds to 30 days. :::

database_replicated_allow_detach_permanently [#database_replicated_allow_detach_permanently]

**Type:** `Bool`\
**Default:** `1`\
**Changeable without restart:** `No`\
Allow detaching tables permanently in Replicated databases

database_replicated_drop_broken_tables [#database_replicated_drop_broken_tables]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Drop unexpected tables from Replicated databases instead of moving them to a separate local database

default_database [#default_database]

**Type:** `String`\
**Default:** `default`\
**Changeable without restart:** `No`\
The default database name.

default_replica_name [#default_replica_name]

**Type:** `String`\
**Default:** `{replica}`\
**Changeable without restart:** `No`\
The replica name in ZooKeeper. **Example** `xml <default_replica_name>{replica}</default_replica_name> `

default_replica_path [#default_replica_path]

**Type:** `String`\
**Default:** `/rawtree/tables/{uuid}/{shard}`\
**Changeable without restart:** `No`\
The path to the table in ZooKeeper. **Example** `xml <default_replica_path>/rawtree/tables/{uuid}/{shard}</default_replica_path> `

default_session_user [#default_session_user]

**Type:** `String`\
**Default:** `default`\
**Changeable without restart:** `No`\
The user name that is used for authentication when a client connects without specifying a user name: an HTTP request without the `user` parameter and `X-RawTree-User` header, a native protocol `Hello` packet with an empty user name, a MySQL or PostgreSQL handshake with an empty user name, a gRPC query without `user_name`, an Arrow Flight call without an `authorization` header (or with Basic credentials with an empty user name), or a [web terminal](/interfaces/web-terminal) WebSocket `auth` message with an omitted or empty `user` field. The empty user name is resolved to this value before authentication, so the connection is still subject to the substituted user's authentication: the password, network, and other access checks apply as usual. An empty user name is merely an alias for the configured user name, and accepting it grants no access beyond what specifying the same user name explicitly already gives. In versions before this setting was introduced, the fallback of an empty user name to `default` existed only for the plain HTTP query-parameter path, gRPC queries, Arrow Flight calls, and the web terminal, while the native, MySQL, and PostgreSQL protocols rejected an empty user name; now all of them accept it. HTTP Basic authentication with an empty user name and requests with `X-RawTree-Key` but without `X-RawTree-User` also rejected an empty user name before this setting was introduced. If set to an empty string, connections without a user name are rejected. HTTP handlers with a fixed user (the `user` key inside `handler` of an `http_handlers` rule, or the `user` key inside `handler` of a `prometheus.handlers` rule) authenticate as their configured user and are not affected. When the `session_log` section is enabled in the server configuration, every such reject is recorded in [`system.session_log`](/operations/system-tables/session_log) as a `LoginFailure` event with an empty `user`, so that prohibited connections without a user name can be audited on every interface. The default session user is never applied to interserver connections: they identify themselves with a special marker instead of a user name and are authenticated by the cluster secret and the initial user. The value can be overridden for a specific endpoint of a composable protocol with the `default_session_user` key in the `protocols` section, see [Composable protocols](/operations/settings/composable-protocols).

dictionaries_lazy_load [#dictionaries_lazy_load]

**Type:** `Bool`\
**Default:** `1`\
**Changeable without restart:** `No`\
Lazy loading of dictionaries. - If `true`, then each dictionary is loaded on the first use. If the loading is failed, the function that was using the dictionary throws an exception. - If `false`, then the server loads all dictionaries at startup. :::note The server will wait at startup until all the dictionaries finish their loading before receiving any connections (exception: if [`wait_dictionaries_load_at_startup`](/reference/settings/server-settings/settings/other#wait_dictionaries_load_at_startup) is set to `false`). ::: **Example** `xml <dictionaries_lazy_load>true</dictionaries_lazy_load> `

dictionary_background_reconnect_interval [#dictionary_background_reconnect_interval]

**Type:** `UInt64`\
**Default:** `1000`\
**Changeable without restart:** `No`\
Interval in milliseconds for reconnection attempts of failed MySQL and Postgres dictionaries having `background_reconnect` enabled.

disable_insertion_and_mutation [#disable_insertion_and_mutation]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Disables `INSERT`, `ALTER`, and `DELETE` queries so read-only replicas do not create data parts, mutations, or merge work that affects read performance. Writes to external storage through engines such as `S3`, `DataLake`, `MySQL`, `PostgreSQL`, and `Kafka` remain allowed. Background streaming from `Kafka`, `RabbitMQ`, `NATS`, and `S3Queue` tables into attached materialized views is disabled because it produces `MergeTree` parts and merge work on this replica.

disable_internal_dns_cache [#disable_internal_dns_cache]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Disables the internal DNS cache. Recommended for operating RawTree in systems with frequently changing infrastructure such as Kubernetes.

disk_connections_hard_limit [#disk_connections_hard_limit]

**Type:** `UInt64`\
**Default:** `200000`\
**Changeable without restart:** `No`\
Exception is thrown at a creation attempt when this limit is reached. Set to 0 to turn off hard limitation. The limit applies to the disks connections.

disk_connections_rcvbuf [#disk_connections_rcvbuf]

**Type:** `UInt64`\
**Default:** `204800`\
**Changeable without restart:** `Yes`\
The size of the SO\_RCVBUF option for disk (S3, Azure, GCS) connections. Defaults to 204800 (200 KB): object storage is reached intra-region where the bandwidth-delay product is well below 100 KB, so a small cap delivers full throughput while avoiding the multi-MiB per-socket buffers kernel autotuning would otherwise allocate. Set to 0 to use kernel TCP autotuning for the receive buffer instead. Note: changing this setting back to 0 restores autotuning only for newly created connections; existing pooled connections retain fixed buffer sizes until they are recreated.

disk_connections_sndbuf [#disk_connections_sndbuf]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
The size of the SO\_SNDBUF option for disk (S3, Azure, GCS) connections. If set to a value greater than 0, overrides the kernel TCP autotuning for the send buffer. 0 = kernel default (autotuning). Note: changing this setting back to 0 restores autotuning only for newly created connections; existing pooled connections retain fixed buffer sizes until they are recreated.

disk_connections_soft_limit [#disk_connections_soft_limit]

**Type:** `UInt64`\
**Default:** `5000`\
**Changeable without restart:** `No`\
Connections above this limit have significantly shorter time to live. The limit applies to the disks connections.

disk_connections_store_limit [#disk_connections_store_limit]

**Type:** `UInt64`\
**Default:** `10000`\
**Changeable without restart:** `No`\
Connections above this limit reset after use. Set to 0 to turn connection cache off. The limit applies to the disks connections.

disk_connections_warn_limit [#disk_connections_warn_limit]

**Type:** `UInt64`\
**Default:** `8000`\
**Changeable without restart:** `No`\
Warning massages are written to the logs if number of in-use connections are higher than this limit. The limit applies to the disks connections.

disk_transaction_wait_for_blob_removal [#disk_transaction_wait_for_blob_removal]

**Type:** `Bool`\
**Default:** `1`\
**Changeable without restart:** `No`\
Default value for the per-disk `wait_for_blob_removal` setting. When enabled, the server waits for background blob removal to complete before acknowledging the operation.

display_secrets_in_show_and_select [#display_secrets_in_show_and_select]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Enables or disables showing secrets in `SHOW` and `SELECT` queries for tables, databases, table functions, and dictionaries. User wishing to see secrets must also have [`format_display_secrets_in_show_and_select` format setting](/reference/settings/formats/format#format_display_secrets_in_show_and_select) turned on and a [`displaySecretsInShowAndSelect`](/reference/statements/grant) privilege. Possible values: - `0` — Disabled. - `1` — Enabled.

distributed_cache_apply_throttling_settings_from_client [#distributed_cache_apply_throttling_settings_from_client]

**Type:** `Bool`\
**Default:** `1`\
**Changeable without restart:** `No`\
Whether cache server should apply throttling settings received from client.

distributed_cache_keep_up_free_connections_ratio [#distributed_cache_keep_up_free_connections_ratio]

**Type:** `Float`\
**Default:** `0.1`\
**Changeable without restart:** `No`\
Soft limit for number of active connection distributed cache will try to keep free. After the number of free connections goes below distributed\_cache\_keep\_up\_free\_connections\_ratio \* max\_connections, connections with oldest activity will be closed until the number goes above the limit.

distributed_cache_write_pool_size [#distributed_cache_write_pool_size]

**Type:** `UInt64`\
**Default:** `100`\
**Changeable without restart:** `No`\
The maximum number of distributed cache write requests that run on a background thread at the same time (across all queries). When the limit is reached, a write goes through the cache inline (on the calling thread) instead of on a background thread, so it neither blocks waiting for a slot nor creates an unbounded number of threads.

distributed_ddl.cleanup_delay_period [#distributed_ddlcleanup_delay_period]

**Type:** `UInt64`\
**Default:** `60`\
**Changeable without restart:** `No`\
cleaning starts after new node event is received if the last cleaning wasn't made sooner than `<cleanup_delay_period>` seconds ago.

distributed_ddl.max_tasks_in_queue [#distributed_ddlmax_tasks_in_queue]

**Type:** `UInt64`\
**Default:** `1000`\
**Changeable without restart:** `No`\
the maximum number of tasks that can be in the queue.

distributed_ddl.path [#distributed_ddlpath]

**Type:** `String`\
**Default:** `/rawtree/task_queue/ddl/`\
**Changeable without restart:** `No`\
the path in Keeper for the `<task_queue>` for DDL queries

distributed_ddl.pool_size [#distributed_ddlpool_size]

**Type:** `Int32`\
**Default:** `1`\
**Changeable without restart:** `No`\
how many `<ON CLUSTER>` queries can be run simultaneously

distributed_ddl.profile [#distributed_ddlprofile]

**Type:** `String`\
**Default:** \`\`\
**Changeable without restart:** `No`\
the profile used to execute the DDL queries

distributed_ddl.replicas_path [#distributed_ddlreplicas_path]

**Type:** `String`\
**Default:** `/rawtree/task_queue/replicas/`\
**Changeable without restart:** `No`\
the path in Keeper for the `<task_queue>` for replicas

distributed_ddl.task_max_lifetime [#distributed_ddltask_max_lifetime]

**Type:** `UInt64`\
**Default:** `604800`\
**Changeable without restart:** `No`\
delete node if its age is greater than this value.

distributed_ddl_use_initial_user_and_roles [#distributed_ddl_use_initial_user_and_roles]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
If enabled, ON CLUSTER queries will preserve and use the initiator's user and roles for execution on remote shards. This ensures consistent access control across the cluster but requires that the user and roles exist on all nodes.

dns_allow_resolve_names_to_ipv4 [#dns_allow_resolve_names_to_ipv4]

**Type:** `Bool`\
**Default:** `1`\
**Changeable without restart:** `Yes`\
Allows resolve names to ipv4 addresses.

dns_allow_resolve_names_to_ipv6 [#dns_allow_resolve_names_to_ipv6]

**Type:** `Bool`\
**Default:** `1`\
**Changeable without restart:** `Yes`\
Allows resolve names to ipv6 addresses.

dns_cache_max_entries [#dns_cache_max_entries]

**Type:** `UInt64`\
**Default:** `10000`\
**Changeable without restart:** `No`\
Internal DNS cache max entries.

dns_cache_update_period [#dns_cache_update_period]

**Type:** `Int32`\
**Default:** `15`\
**Changeable without restart:** `No`\
Internal DNS cache update period in seconds.

dns_max_consecutive_failures [#dns_max_consecutive_failures]

**Type:** `UInt32`\
**Default:** `5`\
**Changeable without restart:** `No`\
Stop further attempts to update a hostname's DNS cache after this number of consecutive failures. The information still remains in the DNS cache. Zero means unlimited. **See also** - [`SYSTEM DROP DNS CACHE`](/reference/statements/system#drop-dns-cache)

drop_distributed_cache_pool_size [#drop_distributed_cache_pool_size]

**Type:** `UInt64`\
**Default:** `8`\
**Changeable without restart:** `No`\
The size of the threadpool used for dropping distributed cache.

drop_distributed_cache_queue_size [#drop_distributed_cache_queue_size]

**Type:** `UInt64`\
**Default:** `1000`\
**Changeable without restart:** `No`\
The queue size of the threadpool used for dropping distributed cache.

dynamic_user_defined_executable_functions_path [#dynamic_user_defined_executable_functions_path]

**Type:** `String`\
**Default:** `/var/lib/rawtree/dynamic_user_defined_executable_functions/`\
**Changeable without restart:** `No`\
The directory used to keep configuration files of executable UDFs created dynamically by drivers (see `CREATE FUNCTION ... ENGINE = DriverName(...)`). On server restart, the directory is scanned for configuration files and the corresponding UDFs are loaded without invoking the driver again. **Example** `xml <dynamic_user_defined_executable_functions_path>/var/lib/rawtree/dynamic_user_defined_executable_functions/</dynamic_user_defined_executable_functions_path> `

enable_azure_sdk_logging [#enable_azure_sdk_logging]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Enables logging from Azure sdk

enable_read_through_distributed_cache [#enable_read_through_distributed_cache]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
Only has an effect in ClickHouse Cloud. Allow reading from distributed cache. This is a server-level switch, applied without a restart, so that background operations which do not have a query profile of their own (merges, mutations, `Buffer` table flushes) follow it as well. Individual queries can deviate from it with the `force_read_through_distributed_cache` setting.

enable_webterminal [#enable_webterminal]

**Type:** `Bool`\
**Default:** `1`\
**Changeable without restart:** `No`\
Enable the web terminal interface at the `/webterminal` HTTP endpoint. Provides an interactive `clickhouse-client` session in the browser via WebSocket. When `false`, requests to `/webterminal` return HTTP status `403 Forbidden`.

enable_write_through_distributed_cache [#enable_write_through_distributed_cache]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
Only has an effect in ClickHouse Cloud. Allow writing to distributed cache (writing to s3 will also be done by distributed cache). This is a server-level switch, applied without a restart, so that background operations which do not have a query profile of their own (merges, mutations, `Buffer` table flushes) follow it as well. Individual queries can deviate from it with the `force_write_through_distributed_cache` setting.

encryption_header_cache_policy [#encryption_header_cache_policy]

**Type:** `String`\
**Default:** `SLRU`\
**Changeable without restart:** `No`\
Encryption header cache policy name.

encryption_header_cache_size [#encryption_header_cache_size]

**Type:** `UInt64`\
**Default:** `52428800`\
**Changeable without restart:** `Yes`\
Maximum size of the cache of encryption headers read from encrypted files. Used only by the experimental ReaderExecutor read path. :::note This setting can be modified at runtime and will take effect immediately. :::

encryption_header_cache_size_ratio [#encryption_header_cache_size_ratio]

**Type:** `Double`\
**Default:** `0.5`\
**Changeable without restart:** `No`\
The size of the protected queue (in case of SLRU policy) in the encryption header cache relative to the cache's total size.

enforce_keeper_component_tracking [#enforce_keeper_component_tracking]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
If enabled, every ZooKeeper request must have a component name set via `Coordination::setCurrentComponent`. Throws a `LOGICAL_ERROR` exception if the component is missing.

filesystem_caches_path [#filesystem_caches_path]

**Type:** `String`\
**Default:** \`\`\
**Changeable without restart:** `No`\
This setting specifies the cache path. **Example** `xml <filesystem_caches_path>/var/lib/rawtree/filesystem_caches/</filesystem_caches_path> `

format_parsing_thread_pool_queue_size [#format_parsing_thread_pool_queue_size]

**Type:** `UInt64`\
**Default:** `10000`\
**Changeable without restart:** `Yes`\
The maximum number of jobs that can be scheduled on thread pool for parsing input. :::note A value of `0` means unlimited. :::

format_schema_path [#format_schema_path]

**Type:** `String`\
**Default:** `/var/lib/rawtree/format_schemas/`\
**Changeable without restart:** `No`\
The path to the directory with the schemes for the input data, such as schemas for the [CapnProto](/reference/formats/CapnProto) format. **Example** `xml <!-- Directory containing schema files for various input formats. --> <format_schema_path>/var/lib/rawtree/format_schemas/</format_schema_path> `

global_profiler_cpu_time_period_ns [#global_profiler_cpu_time_period_ns]

**Type:** `UInt64`\
**Default:** `10000000000`\
**Changeable without restart:** `No`\
Period for CPU clock timer of global profiler (in nanoseconds). Set 0 value to turn off the CPU clock global profiler. Recommended value is at least 10000000 (100 times a second) for single queries or 1000000000 (once a second) for cluster-wide profiling.

global_profiler_real_time_period_ns [#global_profiler_real_time_period_ns]

**Type:** `UInt64`\
**Default:** `10000000000`\
**Changeable without restart:** `No`\
Period for real clock timer of global profiler (in nanoseconds). Set 0 value to turn off the real clock global profiler. Recommended value is at least 10000000 (100 times a second) for single queries or 1000000000 (once a second) for cluster-wide profiling.

google_protos_path [#google_protos_path]

**Type:** `String`\
**Default:** `/usr/share/rawtree/protos/`\
**Changeable without restart:** `No`\
Defines a directory containing proto files for Protobuf types. **Example** `xml <google_protos_path>/usr/share/rawtree/protos/</google_protos_path> `

handshake_timeout_milliseconds [#handshake_timeout_milliseconds]

**Type:** `UInt64`\
**Default:** `30000`\
**Changeable without restart:** `No`\
Wall-clock timeout in milliseconds for the entire TCP handshake phase (Hello + Addendum). Limits how long an unauthenticated connection can hold a thread. Set to 0 to disable.

hdfs.libhdfs3_conf [#hdfslibhdfs3_conf]

**Type:** `String`\
**Default:** \`\`\
**Changeable without restart:** `No`\
Points libhdfs3 to the right location for its config.

http_allow_path_requests [#http_allow_path_requests]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Allow the HTTP interface to route path-style requests (such as `/my_db/my_table.csv`) to the query handler. This flag gates the routing decision only, which is made before the request is authenticated, so it cannot depend on a per-user setting. After routing, the per-user settings [`http_allow_database_as_path`](/operations/settings/settings#http_allow_database_as_path), [`http_allow_table_as_file`](/operations/settings/settings#http_allow_table_as_file), and [`http_allow_filters_as_path`](/operations/settings/settings#http_allow_filters_as_path) control whether the routed path is actually interpreted for the authenticated user. When this flag is off, unknown paths return a plain `404`. **Example** `xml <http_allow_path_requests>1</http_allow_path_requests> `

http_connections_hard_limit [#http_connections_hard_limit]

**Type:** `UInt64`\
**Default:** `200000`\
**Changeable without restart:** `No`\
Exception is thrown at a creation attempt when this limit is reached. Set to 0 to turn off hard limitation. The limit applies to the http connections which do not belong to any disk or storage.

http_connections_rcvbuf [#http_connections_rcvbuf]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
The size of the SO\_RCVBUF option for general HTTP connections. If set to a value greater than 0, overrides the kernel TCP autotuning for the receive buffer. 0 = kernel default (autotuning). Note: changing this setting back to 0 restores autotuning only for newly created connections; existing pooled connections retain fixed buffer sizes until they are recreated.

http_connections_sndbuf [#http_connections_sndbuf]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
The size of the SO\_SNDBUF option for general HTTP connections. If set to a value greater than 0, overrides the kernel TCP autotuning for the send buffer. 0 = kernel default (autotuning). Note: changing this setting back to 0 restores autotuning only for newly created connections; existing pooled connections retain fixed buffer sizes until they are recreated.

http_connections_soft_limit [#http_connections_soft_limit]

**Type:** `UInt64`\
**Default:** `100`\
**Changeable without restart:** `No`\
Connections above this limit have significantly shorter time to live. The limit applies to the http connections which do not belong to any disk or storage.

http_connections_store_limit [#http_connections_store_limit]

**Type:** `UInt64`\
**Default:** `1000`\
**Changeable without restart:** `No`\
Connections above this limit reset after use. Set to 0 to turn connection cache off. The limit applies to the http connections which do not belong to any disk or storage.

http_connections_warn_limit [#http_connections_warn_limit]

**Type:** `UInt64`\
**Default:** `500`\
**Changeable without restart:** `No`\
Warning massages are written to the logs if number of in-use connections are higher than this limit. The limit applies to the http connections which do not belong to any disk or storage.

iceberg_background_schedule_pool_size [#iceberg_background_schedule_pool_size]

**Type:** `UInt64`\
**Default:** `10`\
**Changeable without restart:** `No`\
Size of thread pool to asynchronously fetch the latest metadata from a remote iceberg catalog; the pool is shared by all the active tables.

iceberg_catalog_threadpool_pool_size [#iceberg_catalog_threadpool_pool_size]

**Type:** `UInt64`\
**Default:** `50`\
**Changeable without restart:** `No`\
Size of background pool for iceberg catalog

iceberg_catalog_threadpool_queue_size [#iceberg_catalog_threadpool_queue_size]

**Type:** `UInt64`\
**Default:** `10000`\
**Changeable without restart:** `No`\
Number of tasks which is possible to push into iceberg catalog pool

iceberg_compaction_threadpool_pool_size [#iceberg_compaction_threadpool_pool_size]

**Type:** `UInt64`\
**Default:** `50`\
**Changeable without restart:** `No`\
Size of background pool for iceberg compaction

iceberg_compaction_threadpool_queue_size [#iceberg_compaction_threadpool_queue_size]

**Type:** `UInt64`\
**Default:** `1000000`\
**Changeable without restart:** `No`\
Number of tasks which is possible to push into iceberg compaction pool

iceberg_manifest_decode_thread_pool_queue_size [#iceberg_manifest_decode_thread_pool_queue_size]

**Type:** `UInt64`\
**Default:** `10000`\
**Changeable without restart:** `Yes`\
The maximum number of jobs that can be scheduled on the thread pool for decoding Iceberg data manifest files.

iceberg_metadata_files_cache_max_entries [#iceberg_metadata_files_cache_max_entries]

**Type:** `UInt64`\
**Default:** `1000`\
**Changeable without restart:** `No`\
Maximum size of iceberg metadata files cache in entries. Zero means disabled.

iceberg_metadata_files_cache_policy [#iceberg_metadata_files_cache_policy]

**Type:** `String`\
**Default:** `SLRU`\
**Changeable without restart:** `No`\
Iceberg metadata cache policy name.

iceberg_metadata_files_cache_size [#iceberg_metadata_files_cache_size]

**Type:** `UInt64`\
**Default:** `134217728`\
**Changeable without restart:** `Yes`\
Maximum size of iceberg metadata cache in bytes. Zero means disabled.

iceberg_metadata_files_cache_size_ratio [#iceberg_metadata_files_cache_size_ratio]

**Type:** `Double`\
**Default:** `0.5`\
**Changeable without restart:** `No`\
The size of the protected queue (in case of SLRU policy) in the iceberg metadata cache relative to the cache's total size.

iceberg_scheduler_compaction_threadpool_pool_size [#iceberg_scheduler_compaction_threadpool_pool_size]

**Type:** `UInt64`\
**Default:** `50`\
**Changeable without restart:** `No`\
Size of background pool for iceberg compaction scheduler

iceberg_scheduler_compaction_threadpool_queue_size [#iceberg_scheduler_compaction_threadpool_queue_size]

**Type:** `UInt64`\
**Default:** `1000000`\
**Changeable without restart:** `No`\
Number of tasks which is possible to push into iceberg compaction scheduler pool

ignore_empty_sql_security_in_create_view_query [#ignore_empty_sql_security_in_create_view_query]

**Type:** `Bool`\
**Default:** `1`\
**Changeable without restart:** `No`\
If true, a `CREATE VIEW` or `CREATE MATERIALIZED VIEW` query that specifies neither `DEFINER` nor `SQL SECURITY` is stored as written, and the view gets an empty SQL security type. Specifying `DEFINER` alone counts as `SQL SECURITY DEFINER`, so such a query is unaffected by this setting. A normal view with an empty SQL security type runs with the permissions of the invoker. For a materialized view with an explicitly specified target table, the access checks on the target table are skipped: inserting into the source table does not require the `INSERT` privilege on the target table, and reading from the view does not require the `SELECT` privilege on it. If false, the defaults from the [`default_normal_view_sql_security`](/reference/settings/session-settings#default_normal_view_sql_security), [`default_materialized_view_sql_security`](/reference/settings/session-settings#default_materialized_view_sql_security), and [`default_view_definer`](/reference/settings/session-settings#default_view_definer) settings are written into the view definition at creation time. With the default values of those settings, a materialized view created with neither clause records the creating user as its definer and runs with that user's permissions. Refreshable materialized views always receive the defaults, regardless of this setting. :::note Changing this setting affects only views created afterwards; the stored definitions of existing views stay unchanged. :::

include_from [#include_from]

**Type:** `String`\
**Default:** \`\`\
**Changeable without restart:** `No`\
The path to the file with substitutions. Both XML and YAML formats are supported. For more information, see the section [Configuration files](/concepts/features/configuration/server-config/configuration-files). Empty by default, which means that no substitutions file is used. Before version 26.8 the file `/etc/metrika.xml` was used implicitly whenever it existed; if you rely on it, specify the path explicitly. Note that configuration files that are loaded separately from the main server configuration — the users' configuration (e.g. `users.xml` when it is not included in the main file) and XML dictionary configurations — read the `include_from` element from their own contents, not from the server configuration. Each such file that relies on substitutions needs its own `include_from` element. **Example** `xml <include_from>/etc/rawtree-server/substitutions.xml</include_from> `

index_mark_cache_policy [#index_mark_cache_policy]

**Type:** `String`\
**Default:** `SLRU`\
**Changeable without restart:** `No`\
Secondary index mark cache policy name.

index_mark_cache_prewarm_ratio [#index_mark_cache_prewarm_ratio]

**Type:** `Double`\
**Default:** `0.95`\
**Changeable without restart:** `No`\
The ratio of total size of index mark cache to fill during prewarm.

index_mark_cache_size [#index_mark_cache_size]

**Type:** `UInt64`\
**Default:** `5368709120`\
**Changeable without restart:** `Yes`\
Maximum size of cache for index marks. :::note A value of `0` means disabled. This setting can be modified at runtime and will take effect immediately. :::

index_mark_cache_size_ratio [#index_mark_cache_size_ratio]

**Type:** `Double`\
**Default:** `0.3`\
**Changeable without restart:** `No`\
The size of the protected queue (in case of SLRU policy) in the secondary index mark cache relative to the cache's total size.

index_uncompressed_cache_policy [#index_uncompressed_cache_policy]

**Type:** `String`\
**Default:** `SLRU`\
**Changeable without restart:** `No`\
Secondary index uncompressed cache policy name.

index_uncompressed_cache_size [#index_uncompressed_cache_size]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
Maximum size of cache for uncompressed blocks of `MergeTree` indices. :::note A value of `0` means disabled. This setting can be modified at runtime and will take effect immediately. :::

index_uncompressed_cache_size_ratio [#index_uncompressed_cache_size_ratio]

**Type:** `Double`\
**Default:** `0.5`\
**Changeable without restart:** `No`\
The size of the protected queue (in case of SLRU policy) in the secondary index uncompressed cache relative to the cache's total size.

insert_deduplication_version [#insert_deduplication_version]

**Type:** `String`\
**Default:** `new_unified_hash`\
**Changeable without restart:** `No`\
Deprecated migration guard. This version supports only the unified insert deduplication hash (`new_unified_hash`); the server refuses to start if this setting is present with any other value (such as `old_separate_hashes` or `compatible_double_hashes`). Complete the deduplication migration on the previous version before upgrading by running `compatible_double_hashes` (which writes both the legacy and unified hashes). For replicated tables run it for at least `replicated_deduplication_window_seconds` (one hour by default); the default windows retain the unified hashes of all inserts for that window, which is considered enough to cover an insert retry loop. For non-replicated tables with `non_replicated_deduplication_window` > 0 the window is count-based rather than time-based, so run `compatible_double_hashes` for at least that many inserts before upgrading.

interserver_http_host [#interserver_http_host]

**Type:** `String`\
**Default:** \`\`\
**Changeable without restart:** `No`\
The hostname that can be used by other servers to access this server. If omitted, it is defined in the same way as the `<hostname -f>` command. Useful for breaking away from a specific network interface. **Example** `xml <interserver_http_host>example.rawtree.com</interserver_http_host> `

interserver_http_port [#interserver_http_port]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `No`\
Port for exchanging data between RawTree servers. **Example** `xml <interserver_http_port>9009</interserver_http_port> `

interserver_https_host [#interserver_https_host]

**Type:** `String`\
**Default:** \`\`\
**Changeable without restart:** `No`\
Similar to `<interserver_http_host>`, except that this hostname can be used by other servers to access this server over `<HTTPS>`. **Example** `xml <interserver_https_host>example.rawtree.com</interserver_https_host> `

interserver_https_port [#interserver_https_port]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `No`\
Port for exchanging data between RawTree servers over `<HTTPS>`. **Example** `xml <interserver_https_port>9010</interserver_https_port> `

interserver_tables_status_require_auth [#interserver_tables_status_require_auth]

**Type:** `Bool`\
**Default:** `1`\
**Changeable without restart:** `No`\
Require interserver `TablesStatusRequest` to be authenticated with the cluster `<secret>`. Clients new enough to send a secret hash (protocol revision `DBMS_MIN_REVISION_WITH_INTERSERVER_SECRET_TABLES_STATUS`) are always validated; this setting additionally rejects older clients that send no hash, which is what closes the unauthenticated table-status disclosure by default. Defaults to `true` (secure by default). During a rolling upgrade a not-yet-upgraded node speaks the old protocol and sends no hash, so a `Distributed` query initiated on such a node against an already-upgraded node would have its `TablesStatusRequest` rejected. If you must run a mixed-version cluster, set this to `false` on the upgraded nodes until every node is upgraded, then remove the override.

io_thread_pool_queue_size [#io_thread_pool_queue_size]

**Type:** `UInt64`\
**Default:** `10000`\
**Changeable without restart:** `Yes`\
The maximum number of jobs that can be scheduled on the IO Thread pool. :::note A value of `0` means unlimited. :::

jemalloc_collect_global_profile_samples_in_trace_log [#jemalloc_collect_global_profile_samples_in_trace_log]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Store jemalloc's sampled allocations in system.trace\_log

jemalloc_enable_background_threads [#jemalloc_enable_background_threads]

**Type:** `Bool`\
**Default:** `1`\
**Changeable without restart:** `No`\
Enable jemalloc background threads. Jemalloc uses background threads to cleanup unused memory pages. Disabling it could lead to performance degradation.

jemalloc_enable_global_profiler [#jemalloc_enable_global_profiler]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Enable jemalloc's allocation profiler for all threads. Jemalloc will sample allocations and all deallocations for sampled allocations. Profiles can be flushed using SYSTEM JEMALLOC FLUSH PROFILE which can be used for allocation analysis. Samples can also be stored in system.trace\_log using config jemalloc\_collect\_global\_profile\_samples\_in\_trace\_log or with query setting jemalloc\_collect\_profile\_samples\_in\_trace\_log. See [Allocation Profiling](/concepts/features/performance/allocation-profiling)

jemalloc_flush_profile_interval_bytes [#jemalloc_flush_profile_interval_bytes]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `No`\
Flushing jemalloc profile will be done after global peak memory usage increased by jemalloc\_flush\_profile\_interval\_bytes

jemalloc_flush_profile_on_memory_exceeded [#jemalloc_flush_profile_on_memory_exceeded]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Flushing jemalloc profile will be done on total memory exceeded errors

jemalloc_flush_profile_on_memory_exceeded_interval [#jemalloc_flush_profile_on_memory_exceeded_interval]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `No`\
If non-zero, sets the minimum interval in seconds between flushing jemalloc profiles on total memory exceeded errors. For example, 5 means at most one profile flush every 5 seconds. Takes priority over `jemalloc_flush_profile_on_memory_exceeded`.

jemalloc_max_background_threads_num [#jemalloc_max_background_threads_num]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `No`\
Maximum amount of jemalloc background threads to create, set to 0 to use jemalloc's default value

jemalloc_merge_tree_arenas [#jemalloc_merge_tree_arenas]

**Type:** `UInt64`\
**Default:** `1`\
**Changeable without restart:** `No`\
Number of dedicated jemalloc arenas for long-lived MergeTree per-part and per-table metadata. `0` disables the dedicated arena (metadata uses the default per-CPU arenas). `1` uses a single shared arena. `N > 1` creates a pool of `N` arenas and routes allocations per CPU; on many-core machines this avoids serializing metadata allocation on a single arena's locks. Capped at the number of CPUs the process may run on (its affinity mask), so a large value (or the core count) yields one arena per allowed CPU. Applied at startup.

jemalloc_profiler_sampling_rate [#jemalloc_profiler_sampling_rate]

**Type:** `UInt64`\
**Default:** `19`\
**Changeable without restart:** `No`\
Controls jemalloc's `lg_prof_sample` — the base-2 logarithm of the average interval (in bytes) between allocation samples. The default value of 19 corresponds to 512 KiB. Setting it to a smaller value increases sampling frequency (more overhead, more detail), and a larger value decreases it. Changing this value calls `prof.reset` which resets all accumulated profiling statistics. Requires profiling to be enabled (`MALLOC_CONF=prof:true`).

keep_alive_timeout [#keep_alive_timeout]

**Type:** `Seconds`\
**Default:** `30`\
**Changeable without restart:** `No`\
The number of seconds that RawTree waits for incoming requests for HTTP protocol before closing the connection. **Example** `xml <keep_alive_timeout>30</keep_alive_timeout> `

keeper_hosts [#keeper_hosts]

**Type:** `String`\
**Default:** \`\`\
**Changeable without restart:** `No`\
Dynamic setting. Contains a set of \[Zoo]Keeper hosts RawTree can potentially connect to. Doesn't expose information from `<auxiliary_zookeepers>`

keeper_multiread_batch_size [#keeper_multiread_batch_size]

**Type:** `UInt64`\
**Default:** `10000`\
**Changeable without restart:** `No`\
Maximum size of batch for MultiRead request to \[Zoo]Keeper that support batching. If set to 0, batching is disabled. Available only in RawTree Cloud.

keeper_server.socket_receive_timeout_sec [#keeper_serversocket_receive_timeout_sec]

**Type:** `UInt64`\
**Default:** `300`\
**Changeable without restart:** `No`\
Keeper socket receive timeout.

keeper_server.socket_send_timeout_sec [#keeper_serversocket_send_timeout_sec]

**Type:** `UInt64`\
**Default:** `300`\
**Changeable without restart:** `No`\
Keeper socket send timeout.

license_file [#license_file]

**Type:** `String`\
**Default:** \`\`\
**Changeable without restart:** `Yes`\
License file contents for RawTree Enterprise Edition

license_public_key_for_testing [#license_public_key_for_testing]

**Type:** `String`\
**Default:** \`\`\
**Changeable without restart:** `No`\
Licensing demo key, for CI use only

listen_backlog [#listen_backlog]

**Type:** `UInt32`\
**Default:** `4096`\
**Changeable without restart:** `No`\
Backlog (queue size of pending connections) of the listen socket. The default value of `<4096>` is the same as that of linux 5.4+). Usually this value does not need to be changed, since: - The default value is large enough, - For accepting client's connections server has separate thread. So even if you have `<TcpExtListenOverflows>` (from `<nstat>`) non-zero and this counter grows for RawTree server it does not mean that this value needs to be increased, since: - Usually if `<4096>` is not enough it shows some internal RawTree scaling issue, so it is better to report an issue. - It does not mean that the server can handle more connections later (and even if it could, by that moment clients may be gone or disconnected). **Example** `xml <listen_backlog>4096</listen_backlog> `

listen_reuse_port [#listen_reuse_port]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Allow multiple servers to listen on the same address:port. Requests will be routed to a random server by the operating system. Enabling this setting is not recommended. **Example** `xml <listen_reuse_port>0</listen_reuse_port> `

listen_try [#listen_try]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
The server will not exit if IPv6 or IPv4 networks are unavailable while trying to listen. **Example** `xml <listen_try>0</listen_try> `

load_marks_threadpool_pool_size [#load_marks_threadpool_pool_size]

**Type:** `UInt64`\
**Default:** `50`\
**Changeable without restart:** `No`\
Size of background pool for marks loading

load_marks_threadpool_queue_size [#load_marks_threadpool_queue_size]

**Type:** `UInt64`\
**Default:** `10000`\
**Changeable without restart:** `No`\
Number of tasks which is possible to push into prefetches pool

logger.async [#loggerasync]

**Type:** `Bool`\
**Default:** `1`\
**Changeable without restart:** `No`\
When `<true>` (default) logging will happen asynchronously (one background thread per output channel). Otherwise it will log inside the thread calling LOG.

logger.async_queye_max_size [#loggerasync_queye_max_size]

**Type:** `UInt64`\
**Default:** `65536`\
**Changeable without restart:** `No`\
When using async logging, the max amount of messages that will be kept in the the queue waiting for flushing. Extra messages will be dropped. Rounded up to the next power of two (e.g. `100000` becomes `131072`).

logger.console [#loggerconsole]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Enable logging to the console. Set to `<1>` or `<true>` to enable. Default is `<1>` if RawTree does not run in daemon mode, `<0>` otherwise.

logger.console_log_level [#loggerconsole_log_level]

**Type:** `String`\
**Default:** `trace`\
**Changeable without restart:** `No`\
Log level for console output. Defaults to `<level>`.

logger.count [#loggercount]

**Type:** `UInt64`\
**Default:** `1`\
**Changeable without restart:** `No`\
Rotation policy: How many historical log files RawTree are kept at most.

logger.errorlog [#loggererrorlog]

**Type:** `String`\
**Default:** \`\`\
**Changeable without restart:** `No`\
The path to the error log file.

logger.formatting.type [#loggerformattingtype]

**Type:** `String`\
**Default:** `json`\
**Changeable without restart:** `No`\
Log format for console output. Currently, only `<json>` is supported.

logger.level [#loggerlevel]

**Type:** `String`\
**Default:** `trace`\
**Changeable without restart:** `No`\
Log level. Acceptable values: `<none>` (turn logging off), `<fatal>`, `<critical>`, `<error>`, `<warning>`, `<notice>`, `<information>`, `<debug>`, `<trace>`, `<test>`.

logger.log [#loggerlog]

**Type:** `String`\
**Default:** \`\`\
**Changeable without restart:** `No`\
The path to the log file.

logger.rotation [#loggerrotation]

**Type:** `String`\
**Default:** `100M`\
**Changeable without restart:** `No`\
Rotation policy: Controls when log files are rotated. Rotation can be based on size, time, or a combination of both. Examples: 100M, daily, 100M,daily. Once the log file exceeds the specified size or when the specified time interval is reached, it is renamed and archived, and a new log file is created.

logger.shutdown_level [#loggershutdown_level]

**Type:** `String`\
**Default:** \`\`\
**Changeable without restart:** `No`\
Shutdown level is used to set the root logger level at server Shutdown.

logger.size [#loggersize]

**Type:** `String`\
**Default:** `100M`\
**Changeable without restart:** `No`\
Rotation policy: Maximum size of the log files in bytes. Once the log file size exceeds this threshold, it is renamed and archived, and a new log file is created.

logger.startup_level [#loggerstartup_level]

**Type:** `String`\
**Default:** \`\`\
**Changeable without restart:** `No`\
Startup level is used to set the root logger level at server startup. After startup log level is reverted to the `<level>` setting.

logger.stream_compress [#loggerstream_compress]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Compress log messages using LZ4. Set to `<1>` or `<true>` to enable.

logger.syslog_level [#loggersyslog_level]

**Type:** `String`\
**Default:** `trace`\
**Changeable without restart:** `No`\
Log level for logging to syslog.

logger.use_syslog [#loggeruse_syslog]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Also forward log output to syslog.

mark_cache_policy [#mark_cache_policy]

**Type:** `String`\
**Default:** `SLRU`\
**Changeable without restart:** `No`\
Mark cache policy name.

mark_cache_prewarm_ratio [#mark_cache_prewarm_ratio]

**Type:** `Double`\
**Default:** `0.95`\
**Changeable without restart:** `No`\
The ratio of total size of mark cache to fill during prewarm.

mark_cache_size [#mark_cache_size]

**Type:** `UInt64`\
**Default:** `5368709120`\
**Changeable without restart:** `Yes`\
Maximum size of cache for marks (index of [`MergeTree`](/reference/engines/table-engines/mergetree-family) family of tables). :::note This setting can be modified at runtime and will take effect immediately. :::

mark_cache_size_ratio [#mark_cache_size_ratio]

**Type:** `Double`\
**Default:** `0.5`\
**Changeable without restart:** `No`\
The size of the protected queue (in case of SLRU policy) in the mark cache relative to the cache's total size.

max_active_parts_loading_thread_pool_size [#max_active_parts_loading_thread_pool_size]

**Type:** `UInt64`\
**Default:** `64`\
**Changeable without restart:** `Yes`\
The number of threads to load active set of data parts (Active ones) at startup.

max_authentication_methods_per_user [#max_authentication_methods_per_user]

**Type:** `UInt64`\
**Default:** `100`\
**Changeable without restart:** `No`\
The maximum number of authentication methods a user can be created with or altered to. Changing this setting does not affect existing users. Create/alter authentication-related queries will fail if they exceed the limit specified in this setting. Non authentication create/alter queries will succeed. :::note A value of `0` means unlimited. :::

max_backup_bandwidth_for_server [#max_backup_bandwidth_for_server]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `No`\
The maximum read speed in bytes per second for all backups on server. Zero means unlimited.

max_backups_io_thread_pool_free_size [#max_backups_io_thread_pool_free_size]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
If the number of **idle** threads in the Backups IO Thread pool exceeds `max_backup_io_thread_pool_free_size`, RawTree will release resources occupied by idling threads and decrease the pool size. Threads can be created again if necessary.

max_backups_io_thread_pool_size [#max_backups_io_thread_pool_size]

**Type:** `UInt64`\
**Default:** `1000`\
**Changeable without restart:** `Yes`\
RawTree uses threads from the Backups IO Thread pool to do S3 backup IO operations. `max_backups_io_thread_pool_size` limits the maximum number of threads in the pool.

max_build_vector_similarity_index_thread_pool_size [#max_build_vector_similarity_index_thread_pool_size]

**Type:** `UInt64`\
**Default:** `16`\
**Changeable without restart:** `No`\
The maximum number of threads to use for building vector indexes. :::note A value of `0` means all cores. :::

max_concurrent_insert_queries [#max_concurrent_insert_queries]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
Limit on total number of concurrent insert queries. :::note A value of `0` (default) means unlimited. This setting can be modified at runtime and will take effect immediately. Queries that are already running will remain unchanged. :::

max_concurrent_queries [#max_concurrent_queries]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
Limit on total number of concurrently executed queries. Note that limits on `INSERT` and `SELECT` queries, and on the maximum number of queries for users must also be considered. See also: - [`max_concurrent_insert_queries`](/reference/settings/server-settings/settings/max-concurrent#max_concurrent_insert_queries) - [`max_concurrent_select_queries`](/reference/settings/server-settings/settings/max-concurrent#max_concurrent_select_queries) - [`max_concurrent_queries_for_all_users`](/reference/settings/session-settings/max-concurrent#max_concurrent_queries_for_all_users) :::note A value of `0` (default) means unlimited. This setting can be modified at runtime and will take effect immediately. Queries that are already running will remain unchanged. :::

max_concurrent_select_queries [#max_concurrent_select_queries]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
Limit on total number of concurrently select queries. :::note A value of `0` (default) means unlimited. This setting can be modified at runtime and will take effect immediately. Queries that are already running will remain unchanged. :::

max_connections [#max_connections]

**Type:** `Int32`\
**Default:** `4096`\
**Changeable without restart:** `No`\
Max server connections.

max_database_num_to_throw [#max_database_num_to_throw]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
If number of databases is greater than this value, server will throw an exception. 0 means no limitation.

max_database_num_to_warn [#max_database_num_to_warn]

**Type:** `UInt64`\
**Default:** `1000`\
**Changeable without restart:** `Yes`\
If the number of attached databases exceeds the specified value, rawtree server will add warning messages to `system.warnings` table. **Example** `xml <max_database_num_to_warn>50</max_database_num_to_warn> `

max_database_replicated_create_table_thread_pool_size [#max_database_replicated_create_table_thread_pool_size]

**Type:** `UInt32`\
**Default:** `1`\
**Changeable without restart:** `No`\
The number of threads to create tables during replica recovery in DatabaseReplicated. Zero means number of threads equal number of cores.

max_dictionary_num_to_throw [#max_dictionary_num_to_throw]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
If the number of dictionaries is greater than this value, the server will throw an exception. Only counts tables for database engines: - Atomic - Ordinary - Replicated - Lazy :::note A value of `0` means no limitation. ::: **Example** `xml <max_dictionary_num_to_throw>400</max_dictionary_num_to_throw> `

max_dictionary_num_to_warn [#max_dictionary_num_to_warn]

**Type:** `UInt64`\
**Default:** `1000`\
**Changeable without restart:** `Yes`\
If the number of attached dictionaries exceeds the specified value, rawtree server will add warning messages to `system.warnings` table. **Example** `xml <max_dictionary_num_to_warn>400</max_dictionary_num_to_warn> `

max_distributed_cache_read_bandwidth_for_server [#max_distributed_cache_read_bandwidth_for_server]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
The maximum total read speed from distributed cache on server in bytes per second. Zero means unlimited.

max_distributed_cache_write_bandwidth_for_server [#max_distributed_cache_write_bandwidth_for_server]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
The maximum total write speed to distributed cache on server in bytes per second. Zero means unlimited.

max_entries_for_hash_table_stats [#max_entries_for_hash_table_stats]

**Type:** `UInt64`\
**Default:** `10000`\
**Changeable without restart:** `No`\
How many entries hash table statistics collected during aggregation is allowed to have

max_fetch_partition_thread_pool_size [#max_fetch_partition_thread_pool_size]

**Type:** `UInt64`\
**Default:** `64`\
**Changeable without restart:** `Yes`\
The number of threads for ALTER TABLE FETCH PARTITION.

max_format_parsing_thread_pool_free_size [#max_format_parsing_thread_pool_free_size]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
Maximum number of idle standby threads to keep in the thread pool for parsing input.

max_format_parsing_thread_pool_size [#max_format_parsing_thread_pool_size]

**Type:** `UInt64`\
**Default:** `100`\
**Changeable without restart:** `Yes`\
Maximum total number of threads to use for parsing input.

max_held_snapshots [#max_held_snapshots]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `No`\
Maximum number of lightweight snapshots that can be held at the same time. Zero means unlimited. If the number of snapshots reaches this limit, an exception is thrown when trying to create a new snapshot.

max_http_index_page_size [#max_http_index_page_size]

**Type:** `UInt64`\
**Default:** `10485760`\
**Changeable without restart:** `No`\
Maximum size of an HTTP index page response used for directory listing over HTTP. If the response exceeds this limit, the query fails with an error. Default: `10485760` (10 MiB).

max_iceberg_manifest_decode_thread_pool_free_size [#max_iceberg_manifest_decode_thread_pool_free_size]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
Maximum number of idle standby threads to keep in the thread pool for decoding Iceberg data manifest files.

max_iceberg_manifest_decode_thread_pool_size [#max_iceberg_manifest_decode_thread_pool_size]

**Type:** `UInt64`\
**Default:** `100`\
**Changeable without restart:** `Yes`\
Maximum total number of threads to use for decoding Iceberg data manifest files. The pool is separate from the IO pool on purpose: a decode task can block until the query consumes the entries it has produced, while the delete manifest decode waits for its tasks on the IO pool before any entry is consumed - sharing one pool could deadlock.

max_io_thread_pool_free_size [#max_io_thread_pool_free_size]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
If the number of **idle** threads in the IO Thread pool exceeds `max_io_thread_pool_free_size`, RawTree will release resources occupied by idling threads and decrease the pool size. Threads can be created again if necessary.

max_io_thread_pool_size [#max_io_thread_pool_size]

**Type:** `UInt64`\
**Default:** `100`\
**Changeable without restart:** `Yes`\
RawTree uses threads from the IO Thread pool to do some IO operations (e.g. to interact with S3). `max_io_thread_pool_size` limits the maximum number of threads in the pool.

max_keep_alive_requests [#max_keep_alive_requests]

**Type:** `UInt64`\
**Default:** `10000`\
**Changeable without restart:** `No`\
Maximal number of requests through a single keep-alive connection until it will be closed by RawTree server. **Example** `xml <max_keep_alive_requests>10</max_keep_alive_requests> `

max_local_read_bandwidth_for_server [#max_local_read_bandwidth_for_server]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
The maximum speed of local reads in bytes per second. :::note A value of `0` means unlimited. :::

max_local_write_bandwidth_for_server [#max_local_write_bandwidth_for_server]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
The maximum speed of local writes in bytes per seconds. :::note A value of `0` means unlimited. :::

max_materialized_views_count_for_table [#max_materialized_views_count_for_table]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `No`\
A limit on the number of materialized views attached to a table. :::note Only directly dependent views are considered here, and the creation of one view on top of another view is not considered. :::

max_merges_bandwidth_for_server [#max_merges_bandwidth_for_server]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `No`\
The maximum read speed of all merges on server in bytes per second. Zero means unlimited.

max_mutations_bandwidth_for_server [#max_mutations_bandwidth_for_server]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `No`\
The maximum read speed of all mutations on server in bytes per second. Zero means unlimited.

max_named_collection_num_to_throw [#max_named_collection_num_to_throw]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
If number of named collections is greater than this value, server will throw an exception. :::note A value of `0` means no limitation. ::: **Example** `xml <max_named_collection_num_to_throw>400</max_named_collection_num_to_throw> `

max_named_collection_num_to_warn [#max_named_collection_num_to_warn]

**Type:** `UInt64`\
**Default:** `1000`\
**Changeable without restart:** `Yes`\
If the number of named collections exceeds the specified value, rawtree server will add warning messages to `system.warnings` table. **Example** `xml <max_named_collection_num_to_warn>400</max_named_collection_num_to_warn> `

max_open_files [#max_open_files]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `No`\
The maximum number of open files. :::note We recommend using this option in macOS since the getrlimit() function returns an incorrect value. :::

max_os_cpu_wait_time_ratio_to_drop_connection [#max_os_cpu_wait_time_ratio_to_drop_connection]

**Type:** `Float`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
Max ratio between OS CPU wait (OSCPUWaitMicroseconds metric) and busy (OSCPUVirtualTimeMicroseconds metric) times to consider dropping connections. Linear interpolation between min and max ratio is used to calculate the probability, the probability is 1 at this point. See [Controlling behavior on server CPU overload](/concepts/features/configuration/settings/server-overload) for more details.

max_outdated_parts_loading_thread_pool_size [#max_outdated_parts_loading_thread_pool_size]

**Type:** `UInt64`\
**Default:** `32`\
**Changeable without restart:** `Yes`\
The number of threads to load inactive set of data parts (Outdated ones) at startup.

max_part_num_to_warn [#max_part_num_to_warn]

**Type:** `UInt64`\
**Default:** `100000`\
**Changeable without restart:** `Yes`\
If the number of active parts exceeds the specified value, rawtree server will add warning messages to `system.warnings` table. **Example** `xml <max_part_num_to_warn>400</max_part_num_to_warn> `

max_partition_size_to_drop [#max_partition_size_to_drop]

**Type:** `UInt64`\
**Default:** `50000000000`\
**Changeable without restart:** `Yes`\
Restriction on dropping partitions. If the size of a [MergeTree](/reference/engines/table-engines/mergetree-family/mergetree) table exceeds [`max_partition_size_to_drop`](#max_partition_size_to_drop) (in bytes), you can't drop a partition using a [DROP PARTITION](/reference/statements/alter/partition#drop-partitionpart) query. This setting does not require a restart of the RawTree server to apply. Another way to disable the restriction is to create the `<rawtree-path>/flags/force_drop_table` file. :::note The value `0` means that you can drop partitions without any restrictions. This limitation does not restrict drop table and truncate table, see [max\_table\_size\_to\_drop](/reference/settings/session-settings/max#max_table_size_to_drop) ::: **Example** `xml <max_partition_size_to_drop>0</max_partition_size_to_drop> `

max_parts_cleaning_thread_pool_size [#max_parts_cleaning_thread_pool_size]

**Type:** `UInt64`\
**Default:** `128`\
**Changeable without restart:** `Yes`\
The number of threads for concurrent removal of inactive data parts.

max_pending_mutations_execution_time_to_warn [#max_pending_mutations_execution_time_to_warn]

**Type:** `UInt64`\
**Default:** `86400`\
**Changeable without restart:** `Yes`\
If any of the pending mutations exceeds the specified value in seconds, rawtree server will add warning messages to `system.warnings` table. **Example** `xml <max_pending_mutations_execution_time_to_warn>10000</max_pending_mutations_execution_time_to_warn> `

max_pending_mutations_to_warn [#max_pending_mutations_to_warn]

**Type:** `UInt64`\
**Default:** `500`\
**Changeable without restart:** `Yes`\
If the number of pending mutations exceeds the specified value, rawtree server will add warning messages to `system.warnings` table. **Example** `xml <max_pending_mutations_to_warn>400</max_pending_mutations_to_warn> `

max_per_cpu_untracked_memory [#max_per_cpu_untracked_memory]

**Type:** `UInt64`\
**Default:** `8388608`\
**Changeable without restart:** `Yes`\
Upper bound, in bytes, on the untracked memory all threads running on one CPU may hold at once before it is flushed to the memory tracker. While `max_untracked_memory` bounds a single thread, this bounds the per-CPU total, so many threads cannot multiply their per-thread allowance into a large server-wide overcommit. The total untracked memory is therefore bounded by roughly `number_of_cpus * max_per_cpu_untracked_memory`. A value of `0` disables the per-CPU bound (only the per-thread `max_untracked_memory` applies). Linux only.

max_prefixes_deserialization_thread_pool_free_size [#max_prefixes_deserialization_thread_pool_free_size]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
If the number of **idle** threads in the prefixes deserialization Thread pool exceeds `max_prefixes_deserialization_thread_pool_free_size`, RawTree will release resources occupied by idling threads and decrease the pool size. Threads can be created again if necessary.

max_prefixes_deserialization_thread_pool_size [#max_prefixes_deserialization_thread_pool_size]

**Type:** `UInt64`\
**Default:** `100`\
**Changeable without restart:** `Yes`\
RawTree uses threads from the prefixes deserialization Thread pool for parallel reading of metadata of columns and subcolumns from file prefixes in Wide parts in MergeTree. `max_prefixes_deserialization_thread_pool_size` limits the maximum number of threads in the pool.

max_remote_read_connections [#max_remote_read_connections]

**Type:** `UInt64`\
**Default:** `1000`\
**Changeable without restart:** `No`\
Maximum number of open remote read connections kept alive by `ReaderExecutor` for sequential read optimization. 0 disables connection reuse.

max_remote_read_network_bandwidth_for_server [#max_remote_read_network_bandwidth_for_server]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
The maximum speed of data exchange over the network in bytes per second for read. :::note A value of `0` (default) means unlimited. :::

max_remote_write_network_bandwidth_for_server [#max_remote_write_network_bandwidth_for_server]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
The maximum speed of data exchange over the network in bytes per second for write. :::note A value of `0` (default) means unlimited. :::

max_replicated_fetches_network_bandwidth_for_server [#max_replicated_fetches_network_bandwidth_for_server]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `No`\
The maximum speed of data exchange over the network in bytes per second for replicated fetches. Zero means unlimited.

max_replicated_sends_network_bandwidth_for_server [#max_replicated_sends_network_bandwidth_for_server]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `No`\
The maximum speed of data exchange over the network in bytes per second for replicated sends. Zero means unlimited.

max_replicated_table_num_to_throw [#max_replicated_table_num_to_throw]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
If the number of replicated tables is greater than this value, the server will throw an exception. Only counts tables for database engines: - Atomic - Ordinary - Replicated - Lazy :::note A value of `0` means no limitation. ::: **Example** `xml <max_replicated_table_num_to_throw>400</max_replicated_table_num_to_throw> `

max_server_memory_usage [#max_server_memory_usage]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
The maximum amount of memory the server is allowed to use, expressed in bytes. :::note The maximum memory consumption of the server is further restricted by setting `max_server_memory_usage_to_ram_ratio`. ::: As a special case, a value of `0` (default) means the server may consume all available memory (excluding further restrictions imposed by `max_server_memory_usage_to_ram_ratio`).

max_server_memory_usage_to_ram_ratio [#max_server_memory_usage_to_ram_ratio]

**Type:** `Double`\
**Default:** `0.9`\
**Changeable without restart:** `No`\
The maximum amount of memory the server is allowed to use, expressed as a ratio to all available memory. For example, a value of `0.9` (default) means that the server may consume 90% of the available memory. Allows lowering the memory usage on low-memory systems. On hosts with low RAM and swap, you may possibly need setting [`max_server_memory_usage_to_ram_ratio`](#max_server_memory_usage_to_ram_ratio) set larger than 1. This ratio is applied in two ways: - At startup (and on configuration reload) it caps the server's hard memory limit at this fraction of the total physical RAM, as described above. - At runtime, the background memory worker periodically recomputes the hard memory limit as `(resident memory + system available memory) * max_server_memory_usage_to_ram_ratio`, so the server leaves headroom for other processes running on the same host. When running inside a cgroup with a finite memory limit, the cgroup's available memory is used instead of the host-wide value. As other processes grow and the available memory shrinks, the server's hard limit follows it down, capping growth before the host (or the cgroup) runs out of memory. Setting the ratio to `0` disables both the startup cap and the runtime adjustment. The runtime adjustment is also a no-op on non-Linux systems and in `clickhouse-keeper`, which does not expose this setting. To keep the static startup/reload cap but disable the runtime adjustment (the behavior of previous versions), set `memory_worker_dynamic_hard_limit` to `0`. :::note The maximum memory consumption of the server is further restricted by setting `max_server_memory_usage`. :::

max_snapshot_commit_thread_pool_free_size [#max_snapshot_commit_thread_pool_free_size]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
If the number of idle threads in the snapshot commit thread pool exceeds `max_snapshot_commit_thread_pool_free_size`, RawTree will release resources occupied by idling threads and decrease the pool size. Threads can be created again if necessary.

max_snapshot_commit_thread_pool_size [#max_snapshot_commit_thread_pool_size]

**Type:** `UInt64`\
**Default:** `16`\
**Changeable without restart:** `Yes`\
The number of threads to commit snapshot.

max_table_num_to_throw [#max_table_num_to_throw]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
If number of tables is greater than this value, server will throw an exception. The following tables are not counted: - view - remote - dictionary - system Only counts tables for database engines: - Atomic - Ordinary - Replicated - Lazy :::note A value of `0` means no limitation. ::: **Example** `xml <max_table_num_to_throw>400</max_table_num_to_throw> `

max_table_num_to_warn [#max_table_num_to_warn]

**Type:** `UInt64`\
**Default:** `5000`\
**Changeable without restart:** `Yes`\
If the number of attached tables exceeds the specified value, rawtree server will add warning messages to `system.warnings` table. **Example** `xml <max_table_num_to_warn>400</max_table_num_to_warn> `

max_table_size_to_drop [#max_table_size_to_drop]

**Type:** `UInt64`\
**Default:** `50000000000`\
**Changeable without restart:** `Yes`\
Restriction on deleting tables. If the size of a [MergeTree](/reference/engines/table-engines/mergetree-family/mergetree) table exceeds `max_table_size_to_drop` (in bytes), you can't delete it using a [`DROP`](/reference/statements/drop) query or [`TRUNCATE`](/reference/statements/truncate) query. :::note A value of `0` means that you can delete all tables without any restrictions. This setting does not require a restart of the RawTree server to apply. Another way to disable the restriction is to create the `<rawtree-path>/flags/force_drop_table` file. ::: **Example** `xml <max_table_size_to_drop>0</max_table_size_to_drop> `

max_temporary_data_on_disk_size [#max_temporary_data_on_disk_size]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `No`\
The maximum amount of storage that could be used for external aggregation, joins or sorting. Queries that exceed this limit will fail with an exception. :::note A value of `0` means unlimited. ::: See also: - [`max_temporary_data_on_disk_size_for_user`](/reference/settings/session-settings/max-temporary#max_temporary_data_on_disk_size_for_user) - [`max_temporary_data_on_disk_size_for_query`](/reference/settings/session-settings/max-temporary#max_temporary_data_on_disk_size_for_query)

max_thread_pool_free_size [#max_thread_pool_free_size]

**Type:** `UInt64`\
**Default:** `1000`\
**Changeable without restart:** `No`\
If the number of **idle** threads in the Global Thread pool is greater than [`max_thread_pool_free_size`](/reference/settings/server-settings/settings/max-thread#max_thread_pool_free_size), then RawTree releases resources occupied by some threads and the pool size is decreased. Threads can be created again if necessary. **Example** `xml <max_thread_pool_free_size>1200</max_thread_pool_free_size> `

max_thread_pool_size [#max_thread_pool_size]

**Type:** `UInt64`\
**Default:** `10000`\
**Changeable without restart:** `No`\
RawTree uses threads from the Global Thread pool to process queries. If there is no idle thread to process a query, then a new thread is created in the pool. `max_thread_pool_size` limits the maximum number of threads in the pool. **Example** `xml <max_thread_pool_size>12000</max_thread_pool_size> `

max_unexpected_parts_loading_thread_pool_size [#max_unexpected_parts_loading_thread_pool_size]

**Type:** `UInt64`\
**Default:** `8`\
**Changeable without restart:** `No`\
The number of threads to load inactive set of data parts (Unexpected ones) at startup.

max_view_num_to_throw [#max_view_num_to_throw]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
If the number of views is greater than this value, the server will throw an exception. Only counts tables for database engines: - Atomic - Ordinary - Replicated - Lazy :::note A value of `0` means no limitation. ::: **Example** `xml <max_view_num_to_throw>400</max_view_num_to_throw> `

max_view_num_to_warn [#max_view_num_to_warn]

**Type:** `UInt64`\
**Default:** `10000`\
**Changeable without restart:** `Yes`\
If the number of attached views exceeds the specified value, rawtree server will add warning messages to `system.warnings` table. **Example** `xml <max_view_num_to_warn>400</max_view_num_to_warn> `

max_waiting_queries [#max_waiting_queries]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
Limit on total number of concurrently waiting queries. Execution of a waiting query is blocked while required tables are loading asynchronously (see [`async_load_databases`](/reference/settings/server-settings/settings/async-load#async_load_databases). :::note Waiting queries are not counted when limits controlled by the following settings are checked: - [`max_concurrent_queries`](/reference/settings/server-settings/settings/max-concurrent#max_concurrent_queries) - [`max_concurrent_insert_queries`](/reference/settings/server-settings/settings/max-concurrent#max_concurrent_insert_queries) - [`max_concurrent_select_queries`](/reference/settings/server-settings/settings/max-concurrent#max_concurrent_select_queries) - [`max_concurrent_queries_for_user`](/reference/settings/session-settings/max-concurrent#max_concurrent_queries_for_user) - [`max_concurrent_queries_for_all_users`](/reference/settings/session-settings/max-concurrent#max_concurrent_queries_for_all_users) This correction is done to avoid hitting these limits just after server startup. ::: :::note A value of `0` (default) means unlimited. This setting can be modified at runtime and will take effect immediately. Queries that are already running will remain unchanged. :::

max_zookeeper_pooled_connections [#max_zookeeper_pooled_connections]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `No`\
Maximum number of lazily initialized ZooKeeper sessions per ZooKeeper cluster in the shared pool. A value of `0` disables pooled connections and keeps using a single session.

memory_worker_correct_memory_tracker [#memory_worker_correct_memory_tracker]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Whether background memory worker should correct internal memory tracker based on the information from external sources like jemalloc and cgroups

memory_worker_decay_adjustment_period_ms [#memory_worker_decay_adjustment_period_ms]

**Type:** `UInt64`\
**Default:** `5000`\
**Changeable without restart:** `No`\
Duration in milliseconds that memory pressure must persist before dynamically adjusting jemalloc's `dirty_decay_ms`. When memory usage remains above the purge threshold for this period, automatic dirty page decay is disabled (`dirty_decay_ms=0`) to aggressively reclaim memory. When usage stays below the threshold for this period, the default decay behavior is restored. Set to 0 to disable dynamic adjustment and use jemalloc's default decay settings.

memory_worker_dynamic_hard_limit [#memory_worker_dynamic_hard_limit]

**Type:** `Bool`\
**Default:** `1`\
**Changeable without restart:** `No`\
Whether the background memory worker periodically recomputes the server's hard memory limit at runtime as `(resident memory + system available memory) * max_server_memory_usage_to_ram_ratio`, so the server leaves headroom for other processes running on the same host. When disabled, `max_server_memory_usage_to_ram_ratio` only caps the hard memory limit statically, at startup and on configuration reload, as in previous versions. Has no effect when `max_server_memory_usage_to_ram_ratio` is `0`.

memory_worker_period_ms [#memory_worker_period_ms]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `No`\
Tick period of background memory worker which corrects memory tracker memory usages and cleans up unused pages during higher memory usage. If set to 0, default value will be used depending on the memory usage source

memory_worker_purge_dirty_pages_threshold_ratio [#memory_worker_purge_dirty_pages_threshold_ratio]

**Type:** `Double`\
**Default:** `0.2`\
**Changeable without restart:** `No`\
The threshold ratio for jemalloc dirty pages relative to the memory available to RawTree server. When dirty pages size exceeds this ratio, the background memory worker forces purging of dirty pages. If set to 0, forced purging based on dirty pages ratio is disabled.

memory_worker_purge_total_memory_threshold_ratio [#memory_worker_purge_total_memory_threshold_ratio]

**Type:** `Double`\
**Default:** `0.9`\
**Changeable without restart:** `No`\
The threshold ratio for purging jemalloc relative to the memory available to RawTree server. When total memory usage exceeds this ratio, the background memory worker forces purging of dirty pages. If set to 0, forced purging based on total memory is disabled.

memory_worker_rss_speculative_reserve_ratio [#memory_worker_rss_speculative_reserve_ratio]

**Type:** `Double`\
**Default:** `1`\
**Changeable without restart:** `No`\
On each `MemoryWorker` tick, reserve an additional `ratio * min(resident - previous_resident, resident - tracked)` on top of the observed RSS, on the assumption that the next tick may grow by the same amount as the last one (`resident - previous_resident` is the RSS growth over the last tick). The growth is capped by `resident - tracked`, the part of RSS not visible to the global memory tracker, because growth that is already tracked is handled by the ordinary hard-limit check. The reservation is applied to the `rss` counter that the global hard-limit check consults via `MemoryTracker::allocImpl`, so when the extrapolated value crosses `max_server_memory_usage`, subsequent allocations throw `MEMORY_LIMIT_EXCEEDED` before the kernel OOM-killer fires. A value of `0` disables speculation (falling back to `rss = resident`); the default `1` reserves one full growth delta of headroom for the next interval. Under sanitizers (`ASan`, `UBSan`, `MSan`, `TSan`) the default is `0`, because the `resident - tracked` gap is dominated by sanitizer shadow / runtime overhead rather than tracker bookkeeping lag.

memory_worker_use_cgroup [#memory_worker_use_cgroup]

**Type:** `Bool`\
**Default:** `1`\
**Changeable without restart:** `No`\
Use current cgroup memory usage information to correct memory tracking.

merge_workload [#merge_workload]

**Type:** `String`\
**Default:** `default`\
**Changeable without restart:** `Yes`\
Used to regulate how resources are utilized and shared between merges and other workloads. Specified value is used as `workload` setting value for all background merges. Can be overridden by a merge tree setting. **See Also** - [Workload Scheduling](/concepts/features/configuration/server-config/workload-scheduling)

merges_mutations_memory_usage_soft_limit [#merges_mutations_memory_usage_soft_limit]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `No`\
Sets the limit on how much RAM is allowed to use for performing merge and mutation operations. If RawTree reaches the limit set, it won't schedule any new background merge or mutation operations but will continue to execute already scheduled tasks. :::note A value of `0` means unlimited. ::: **Example** `xml <merges_mutations_memory_usage_soft_limit>0</merges_mutations_memory_usage_soft_limit> `

merges_mutations_memory_usage_to_ram_ratio [#merges_mutations_memory_usage_to_ram_ratio]

**Type:** `Double`\
**Default:** `0.5`\
**Changeable without restart:** `No`\
The default `merges_mutations_memory_usage_soft_limit` value is calculated as `memory_amount * merges_mutations_memory_usage_to_ram_ratio`. **See also:** - [max\_memory\_usage](/reference/settings/session-settings/max-memory-usage#max_memory_usage) - [merges\_mutations\_memory\_usage\_soft\_limit](/reference/settings/server-settings/settings/merges-mutations#merges_mutations_memory_usage_soft_limit)

message_queue_disable_insertion [#message_queue_disable_insertion]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Disable insertion from message queue engines (Kafka, RabbitMQ, NATS) into attached materialized views

min_allocation_size_to_throw_on_memory_limit [#min_allocation_size_to_throw_on_memory_limit]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
Minimum size, in bytes, of a generic C++ allocation (the kind made by standard containers, strings, `std::vector` growth, smart pointers, etc.) that is allowed to raise `MEMORY_LIMIT_EXCEEDED` once `max_server_memory_usage` is reached. Smaller generic allocations are still counted against the memory tracker but are allowed to succeed even past the limit, which reduces spurious failures during cleanup and exception-handling paths near OOM. Allocations made by ClickHouse's own large buffers — column data, hash tables, arenas, query pipelines, IO buffers — always honour the memory limit and may throw regardless of this value. This setting only affects implicit allocations that flow through `operator new`. A value of `0` (default) preserves the legacy behaviour: implicit `operator new` allocations are never refused by the memory tracker, and only explicit ClickHouse allocations can raise `MEMORY_LIMIT_EXCEEDED`. Note, to avoid side effects it is recommended to set value greater then `max_untracked_memory`.

min_os_cpu_wait_time_ratio_to_drop_connection [#min_os_cpu_wait_time_ratio_to_drop_connection]

**Type:** `Float`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
Min ratio between OS CPU wait (OSCPUWaitMicroseconds metric) and busy (OSCPUVirtualTimeMicroseconds metric) times to consider dropping connections. Linear interpolation between min and max ratio is used to calculate the probability, the probability is 0 at this point. See [Controlling behavior on server CPU overload](/concepts/features/configuration/settings/server-overload) for more details.

mlock_executable [#mlock_executable]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Perform `<mlockall>` after startup to lower first queries latency and to prevent rawtree executable from being paged out under high IO load. :::note Enabling this option is recommended but will lead to increased startup time for up to a few seconds. Keep in mind that this setting would not work without "CAP\_IPC\_LOCK" capability. ::: **Example** `xml <mlock_executable>false</mlock_executable> `

mlock_executable_min_total_memory_amount_bytes [#mlock_executable_min_total_memory_amount_bytes]

**Type:** `UInt64`\
**Default:** `5000000000`\
**Changeable without restart:** `No`\
The minimum memory threshold for performing `<mlockall>`

mmap_cache_size [#mmap_cache_size]

**Type:** `UInt64`\
**Default:** `1024`\
**Changeable without restart:** `Yes`\
This setting allows avoiding frequent open/close calls (which are very expensive due to consequent page faults), and to reuse mappings from several threads and queries. The setting value is the number of mapped regions (usually equal to the number of mapped files). The amount of data in mapped files can be monitored in the following system tables with the following metrics: - `MMappedFiles`/`MMappedFileBytes`/`MMapCacheCells` in [`system.metrics`](/reference/system-tables/metrics), [`system.metric_log`](/reference/system-tables/metric_log) - `CreatedReadBufferMMap`/`CreatedReadBufferMMapFailed`/`MMappedFileCacheHits`/`MMappedFileCacheMisses` in [`system.events`](/reference/system-tables/events), [`system.processes`](/reference/system-tables/processes), [`system.query_log`](/reference/system-tables/query_log), [`system.query_thread_log`](/reference/system-tables/query_thread_log), [`system.query_views_log`](/reference/system-tables/query_views_log) :::note The amount of data in mapped files does not consume memory directly and is not accounted for in query or server memory usage — because this memory can be discarded similar to the OS page cache. The cache is dropped (the files are closed) automatically on the removal of old parts in tables of the MergeTree family, also it can be dropped manually by the `SYSTEM DROP MMAP CACHE` query. This setting can be modified at runtime and will take effect immediately. :::

mutation_workload [#mutation_workload]

**Type:** `String`\
**Default:** `default`\
**Changeable without restart:** `Yes`\
Used to regulate how resources are utilized and shared between mutations and other workloads. Specified value is used as `workload` setting value for all background mutations. Can be overridden by a merge tree setting. **See Also** - [Workload Scheduling](/concepts/features/configuration/server-config/workload-scheduling)

mysql_require_secure_transport [#mysql_require_secure_transport]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
If set to true, secure communication is required with clients over [mysql\_port](/reference/settings/server-settings/settings/mysql#mysql_port). Connection with option `<--ssl-mode=none>` will be refused. Use it with [OpenSSL](/reference/settings/server-settings/settings/other#openssl) settings.

named_collections_storage.type [#named_collections_storagetype]

**Type:** `String`\
**Default:** `local`\
**Changeable without restart:** `No`\
The storage type for named collections. Possible values are `local`, `local_encrypted`, `keeper`, `keeper_encrypted`, `zookeeper`, and `zookeeper_encrypted`. Configured as `named_collections_storage.type` (`<named_collections_storage><type>` in XML).

oom_canary_enable [#oom_canary_enable]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Experimental. Enable the OOM canary: a sacrificial child process that attracts the Linux OOM killer before the main ClickHouse server process, giving the server a chance to shed load. Requires Linux >= 5.3 (for `pidfd_open`); the canary is disabled at startup on older kernels. The OOM response requires cgroup v2 `memory.events.local` OOM-kill evidence and may run global query cancellation, merge cancellation, and `system.crash_log` writes. The canary cannot protect the server when cgroup v2 `memory.oom.group` is enabled for the server's cgroup: the kernel then kills the whole cgroup as one unit, including the server, so the OOM response never runs. A warning is logged at startup in this mode. Behavior may change between ClickHouse versions until production validation is complete.

oom_canary_initial_backoff_seconds [#oom_canary_initial_backoff_seconds]

**Type:** `UInt64`\
**Default:** `1`\
**Changeable without restart:** `No`\
Initial backoff delay in seconds between consecutive OOM canary relaunches. The delay doubles on each relaunch up to `oom_canary_max_backoff_seconds`.

oom_canary_max_backoff_seconds [#oom_canary_max_backoff_seconds]

**Type:** `UInt64`\
**Default:** `60`\
**Changeable without restart:** `No`\
Maximum backoff delay in seconds between consecutive OOM canary relaunches.

oom_canary_max_rapid_relaunches [#oom_canary_max_rapid_relaunches]

**Type:** `UInt64`\
**Default:** `10`\
**Changeable without restart:** `No`\
Maximum number of consecutive rapid OOM canary relaunches before automatic relaunch is disabled to avoid thrashing under sustained memory pressure. The counter and the relaunch backoff reset once a canary survives longer than `oom_canary_max_backoff_seconds`, so a canary that dies only sporadically over a long uptime is not eventually disabled. Applies only when `oom_canary_relaunch` is true.

oom_canary_relaunch [#oom_canary_relaunch]

**Type:** `Bool`\
**Default:** `1`\
**Changeable without restart:** `No`\
When true, the OOM canary is automatically relaunched after the canary process dies for any reason other than a permanent setup failure or server shutdown — including OOM kills, other signals, and transient exits — subject to `oom_canary_max_rapid_relaunches` and the backoff settings. The OOM response sequence itself runs only when cgroup v2 `memory.events.local` provides OOM-kill evidence.

oom_canary_size [#oom_canary_size]

**Type:** `UInt64`\
**Default:** `104857600`\
**Changeable without restart:** `No`\
Size in bytes of the memory region that the OOM canary child process allocates and touches. Locking the region with `mlock` is best-effort: it requires `CAP_IPC_LOCK` or a sufficient `RLIMIT_MEMLOCK`, and when locking fails the canary logs a warning and the memory remains allocated but may be swapped out. Default is 100 MB (104857600). Larger values make the canary a more attractive OOM target.

oom_score [#oom_score]

**Type:** `Int32`\
**Default:** `0`\
**Changeable without restart:** `No`\
On Linux systems this can control the behavior of OOM killer.

openSSL.client.cacheSessions [#opensslclientcachesessions]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Enables or disables caching sessions. Must be used in combination with `<sessionIdContext>`. Acceptable values: `<true>`, `<false>`.

openSSL.client.caConfig [#opensslclientcaconfig]

**Type:** `String`\
**Default:** \`\`\
**Changeable without restart:** `No`\
Path to the file or directory that contains trusted CA certificates. If this points to a file, it must be in PEM format and can contain several CA certificates. If this points to a directory, it must contain one .pem file per CA certificate. The filenames are looked up by the CA subject name hash value. Details can be found in the man page of [SSL\_CTX\_load\_verify\_locations](https://docs.openssl.org/3.0/man3/SSL_CTX_load_verify_locations/). The CA certificates are reloaded without a restart when the file changes or on `SYSTEM RELOAD CONFIG`; new connections are verified against the reloaded certificates.

openSSL.client.certificateFile [#opensslclientcertificatefile]

**Type:** `String`\
**Default:** \`\`\
**Changeable without restart:** `No`\
Path to the client/server certificate file in PEM format. You can omit it if `<privateKeyFile>` contains the certificate.

openSSL.client.cipherList [#opensslclientcipherlist]

**Type:** `String`\
**Default:** `ALL:!ADH:!LOW:!EXP:!MD5:!3DES:@STRENGTH`\
**Changeable without restart:** `No`\
Supported OpenSSL encryptions.

openSSL.client.disableProtocols [#opensslclientdisableprotocols]

**Type:** `String`\
**Default:** \`\`\
**Changeable without restart:** `No`\
Protocols that are not allowed to be used.

openSSL.client.extendedVerification [#opensslclientextendedverification]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
If enabled, verify that the certificate CN or SAN matches the peer hostname.

openSSL.client.fips [#opensslclientfips]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Activates OpenSSL FIPS mode. Supported if the library's OpenSSL version supports FIPS.

openSSL.client.invalidCertificateHandler.name [#opensslclientinvalidcertificatehandlername]

**Type:** `String`\
**Default:** `RejectCertificateHandler`\
**Changeable without restart:** `No`\
Class (a subclass of CertificateHandler) for verifying invalid certificates. For example: `<<invalidCertificateHandler> <name>RejectCertificateHandler</name> </invalidCertificateHandler>>`.

openSSL.client.loadDefaultCAFile [#opensslclientloaddefaultcafile]

**Type:** `Bool`\
**Default:** `1`\
**Changeable without restart:** `No`\
Determines whether built-in CA certificates for OpenSSL will be used. RawTree assumes that builtin CA certificates are in the file `</etc/ssl/cert.pem>` (resp. the directory `</etc/ssl/certs>`) or in file (resp. directory) specified by the environment variable `<SSL_CERT_FILE>` (resp. `<SSL_CERT_DIR>`).

openSSL.client.preferServerCiphers [#opensslclientpreferserverciphers]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Client-preferred server ciphers.

openSSL.client.privateKeyFile [#opensslclientprivatekeyfile]

**Type:** `String`\
**Default:** \`\`\
**Changeable without restart:** `No`\
Path to the file with the secret key of the PEM certificate. The file may contain a key and certificate at the same time.

openSSL.client.privateKeyPassphraseHandler.name [#opensslclientprivatekeypassphrasehandlername]

**Type:** `String`\
**Default:** `KeyConsoleHandler`\
**Changeable without restart:** `No`\
Class (PrivateKeyPassphraseHandler subclass) that requests the passphrase for accessing the private key. For example: `<<privateKeyPassphraseHandler>>`, `<<name>KeyFileHandler</name>>`, `<<options><password>test</password></options>>`, `<</privateKeyPassphraseHandler>>`

openSSL.client.requireTLSv1 [#opensslclientrequiretlsv1]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Require a TLSv1 connection. Acceptable values: `<true>`, `<false>`.

openSSL.client.requireTLSv1_1 [#opensslclientrequiretlsv1_1]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Require a TLSv1.1 connection. Acceptable values: `<true>`, `<false>`.

openSSL.client.requireTLSv1_2 [#opensslclientrequiretlsv1_2]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Require a TLSv1.2 connection. Acceptable values: `<true>`, `<false>`.

openSSL.client.verificationDepth [#opensslclientverificationdepth]

**Type:** `UInt64`\
**Default:** `9`\
**Changeable without restart:** `No`\
The maximum length of the verification chain. Verification will fail if the certificate chain length exceeds the set value.

openSSL.client.verificationMode [#opensslclientverificationmode]

**Type:** `String`\
**Default:** `relaxed`\
**Changeable without restart:** `No`\
The method for checking the node's certificates. Details are in the description of the [Context](https://github.com/ClickHouse/poco/blob/master/NetSSL_OpenSSL/include/Poco/Net/Context.h) class. Possible values: `<none>`, `<relaxed>`, `<strict>`, `<once>`.

openSSL.server.cacheSessions [#opensslservercachesessions]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Enables or disables caching sessions. Must be used in combination with `<sessionIdContext>`. Acceptable values: `<true>`, `<false>`.

openSSL.server.caConfig [#opensslservercaconfig]

**Type:** `String`\
**Default:** \`\`\
**Changeable without restart:** `No`\
Path to the file or directory that contains trusted CA certificates. If this points to a file, it must be in PEM format and can contain several CA certificates. If this points to a directory, it must contain one .pem file per CA certificate. The filenames are looked up by the CA subject name hash value. Details can be found in the man page of [SSL\_CTX\_load\_verify\_locations](https://docs.openssl.org/3.0/man3/SSL_CTX_load_verify_locations/). The CA certificates are reloaded without a restart when the file changes or on `SYSTEM RELOAD CONFIG`; new connections are verified against the reloaded certificates.

openSSL.server.certificateFile [#opensslservercertificatefile]

**Type:** `String`\
**Default:** \`\`\
**Changeable without restart:** `No`\
Path to the client/server certificate file in PEM format. You can omit it if `<privateKeyFile>` contains the certificate.

openSSL.server.cipherList [#opensslservercipherlist]

**Type:** `String`\
**Default:** `ALL:!ADH:!LOW:!EXP:!MD5:!3DES:@STRENGTH`\
**Changeable without restart:** `No`\
Supported OpenSSL encryptions.

openSSL.server.disableProtocols [#opensslserverdisableprotocols]

**Type:** `String`\
**Default:** \`\`\
**Changeable without restart:** `No`\
Protocols that are not allowed to be used.

openSSL.server.extendedVerification [#opensslserverextendedverification]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
If enabled, verify that the certificate CN or SAN matches the peer hostname.

openSSL.server.fips [#opensslserverfips]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Activates OpenSSL FIPS mode. Supported if the library's OpenSSL version supports FIPS.

openSSL.server.invalidCertificateHandler.name [#opensslserverinvalidcertificatehandlername]

**Type:** `String`\
**Default:** `RejectCertificateHandler`\
**Changeable without restart:** `No`\
Class (a subclass of CertificateHandler) for verifying invalid certificates. For example: `<<invalidCertificateHandler> <name>RejectCertificateHandler</name> </invalidCertificateHandler>>`.

openSSL.server.loadDefaultCAFile [#opensslserverloaddefaultcafile]

**Type:** `Bool`\
**Default:** `1`\
**Changeable without restart:** `No`\
Determines whether built-in CA certificates for OpenSSL will be used. RawTree assumes that builtin CA certificates are in the file `</etc/ssl/cert.pem>` (resp. the directory `</etc/ssl/certs>`) or in file (resp. directory) specified by the environment variable `<SSL_CERT_FILE>` (resp. `<SSL_CERT_DIR>`).

openSSL.server.preferServerCiphers [#opensslserverpreferserverciphers]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Client-preferred server ciphers.

openSSL.server.privateKeyFile [#opensslserverprivatekeyfile]

**Type:** `String`\
**Default:** \`\`\
**Changeable without restart:** `No`\
Path to the file with the secret key of the PEM certificate. The file may contain a key and certificate at the same time.

openSSL.server.privateKeyPassphraseHandler.name [#opensslserverprivatekeypassphrasehandlername]

**Type:** `String`\
**Default:** `KeyConsoleHandler`\
**Changeable without restart:** `No`\
Class (PrivateKeyPassphraseHandler subclass) that requests the passphrase for accessing the private key. For example: `<<privateKeyPassphraseHandler>>`, `<<name>KeyFileHandler</name>>`, `<<options><password>test</password></options>>`, `<</privateKeyPassphraseHandler>>`

openSSL.server.requireTLSv1 [#opensslserverrequiretlsv1]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Require a TLSv1 connection. Acceptable values: `<true>`, `<false>`.

openSSL.server.requireTLSv1_1 [#opensslserverrequiretlsv1_1]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Require a TLSv1.1 connection. Acceptable values: `<true>`, `<false>`.

openSSL.server.requireTLSv1_2 [#opensslserverrequiretlsv1_2]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Require a TLSv1.2 connection. Acceptable values: `<true>`, `<false>`.

openSSL.server.sessionCacheSize [#opensslserversessioncachesize]

**Type:** `UInt64`\
**Default:** `20480`\
**Changeable without restart:** `No`\
The maximum number of sessions that the server caches. A value of 0 means unlimited sessions.

openSSL.server.sessionIdContext [#opensslserversessionidcontext]

**Type:** `String`\
**Default:** `application.name`\
**Changeable without restart:** `No`\
A unique set of random characters that the server appends to each generated identifier. The length of the string must not exceed `<SSL_MAX_SSL_SESSION_ID_LENGTH>`. This parameter is always recommended since it helps avoid problems both if the server caches the session and if the client requested caching.

openSSL.server.sessionTimeout [#opensslserversessiontimeout]

**Type:** `UInt64`\
**Default:** `2`\
**Changeable without restart:** `No`\
Time for caching the session on the server in hours.

openSSL.server.verificationDepth [#opensslserververificationdepth]

**Type:** `UInt64`\
**Default:** `9`\
**Changeable without restart:** `No`\
The maximum length of the verification chain. Verification will fail if the certificate chain length exceeds the set value.

openSSL.server.verificationMode [#opensslserververificationmode]

**Type:** `String`\
**Default:** `relaxed`\
**Changeable without restart:** `No`\
The method for checking the node's certificates. Details are in the description of the [Context](https://github.com/ClickHouse/poco/blob/master/NetSSL_OpenSSL/include/Poco/Net/Context.h) class. Possible values: `<none>`, `<relaxed>`, `<strict>`, `<once>`.

os_collect_psi_metrics [#os_collect_psi_metrics]

**Type:** `Bool`\
**Default:** `1`\
**Changeable without restart:** `No`\
Enable accounting PSI metrics from /proc/pressure/ files.

os_cpu_busy_time_threshold [#os_cpu_busy_time_threshold]

**Type:** `UInt64`\
**Default:** `1000000`\
**Changeable without restart:** `No`\
Threshold of OS CPU busy time in microseconds (OSCPUVirtualTimeMicroseconds metric) to consider CPU doing some useful work, no CPU overload would be considered if busy time was below this value.

os_threads_nice_value_distributed_cache_tcp_handler [#os_threads_nice_value_distributed_cache_tcp_handler]

**Type:** `Int32`\
**Default:** `0`\
**Changeable without restart:** `No`\
Linux nice value for the threads of distributed cache TCP handler. Lower values mean higher CPU priority. Requires CAP\_SYS\_NICE capability, otherwise no-op. Possible values: -20 to 19.

os_threads_nice_value_merge_mutate [#os_threads_nice_value_merge_mutate]

**Type:** `Int32`\
**Default:** `0`\
**Changeable without restart:** `No`\
Linux nice value for merge and mutation threads. Lower values mean higher CPU priority. Requires CAP\_SYS\_NICE capability, otherwise no-op. Possible values: -20 to 19.

os_threads_nice_value_zookeeper_client_send_receive [#os_threads_nice_value_zookeeper_client_send_receive]

**Type:** `Int32`\
**Default:** `0`\
**Changeable without restart:** `No`\
Linux nice value for send and receive threads in ZooKeeper client. Lower values mean higher CPU priority. Requires CAP\_SYS\_NICE capability, otherwise no-op. Possible values: -20 to 19.

page_cache_free_memory_ratio [#page_cache_free_memory_ratio]

**Type:** `Double`\
**Default:** `0.15`\
**Changeable without restart:** `No`\
Fraction of the memory limit to keep free from the userspace page cache. Analogous to Linux min\_free\_kbytes setting.

page_cache_history_window_ms [#page_cache_history_window_ms]

**Type:** `UInt64`\
**Default:** `1000`\
**Changeable without restart:** `No`\
Delay before freed memory can be used by userspace page cache.

page_cache_max_size [#page_cache_max_size]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `No`\
Maximum size of the userspace page cache. Set to 0 to disable the cache. If greater than page\_cache\_min\_size, the cache size will be continuously adjusted within this range, to use most of the available memory while keeping the total memory usage below the limit (max\_server\_memory\_usage\[\_to\_ram\_ratio]).

page_cache_min_size [#page_cache_min_size]

**Type:** `UInt64`\
**Default:** `104857600`\
**Changeable without restart:** `No`\
Minimum size of the userspace page cache.

page_cache_policy [#page_cache_policy]

**Type:** `String`\
**Default:** `SLRU`\
**Changeable without restart:** `No`\
Userspace page cache policy name.

page_cache_shards [#page_cache_shards]

**Type:** `UInt64`\
**Default:** `4`\
**Changeable without restart:** `No`\
Stripe userspace page cache over this many shards to reduce mutex contention. Experimental, not likely to improve performance.

page_cache_size_ratio [#page_cache_size_ratio]

**Type:** `Double`\
**Default:** `0.5`\
**Changeable without restart:** `No`\
The size of the protected queue in the userspace page cache relative to the cache's total size.

paimon_metadata_files_cache_max_entries [#paimon_metadata_files_cache_max_entries]

**Type:** `UInt64`\
**Default:** `1000`\
**Changeable without restart:** `Yes`\
Maximum size of paimon metadata files cache in entries. Zero means no entry-count limit.

paimon_metadata_files_cache_policy [#paimon_metadata_files_cache_policy]

**Type:** `String`\
**Default:** `SLRU`\
**Changeable without restart:** `No`\
Paimon metadata cache policy name.

paimon_metadata_files_cache_size [#paimon_metadata_files_cache_size]

**Type:** `UInt64`\
**Default:** `1073741824`\
**Changeable without restart:** `Yes`\
Maximum size of paimon metadata cache in bytes. Zero means disabled.

paimon_metadata_files_cache_size_ratio [#paimon_metadata_files_cache_size_ratio]

**Type:** `Double`\
**Default:** `0.5`\
**Changeable without restart:** `No`\
The size of the protected queue (in case of SLRU policy) in the paimon metadata cache relative to the cache's total size.

parallel_vertical_merges_pool_size [#parallel_vertical_merges_pool_size]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `No`\
Size of the thread pool used to parallelize the vertical merge stage across parts and columns. 0 means the number of CPU cores.

parquet_metadata_cache_max_entries [#parquet_metadata_cache_max_entries]

**Type:** `UInt64`\
**Default:** `5000`\
**Changeable without restart:** `No`\
Maximum size of parquet metadata files cache in entries. Zero means disabled.

parquet_metadata_cache_policy [#parquet_metadata_cache_policy]

**Type:** `String`\
**Default:** `SLRU`\
**Changeable without restart:** `No`\
Parquet metadata cache policy name.

parquet_metadata_cache_size [#parquet_metadata_cache_size]

**Type:** `UInt64`\
**Default:** `536870912`\
**Changeable without restart:** `Yes`\
Maximum size of parquet metadata cache in bytes. Zero means disabled.

parquet_metadata_cache_size_ratio [#parquet_metadata_cache_size_ratio]

**Type:** `Double`\
**Default:** `0.5`\
**Changeable without restart:** `No`\
The size of the protected queue (in case of SLRU policy) in the parquet metadata cache relative to the cache's total size.

parts_kill_delay_period [#parts_kill_delay_period]

**Type:** `UInt64`\
**Default:** `30`\
**Changeable without restart:** `No`\
Period to completely remove parts for SharedMergeTree. Only available in RawTree Cloud

parts_kill_delay_period_random_add [#parts_kill_delay_period_random_add]

**Type:** `UInt64`\
**Default:** `10`\
**Changeable without restart:** `No`\
Add uniformly distributed value from 0 to x seconds to kill\_delay\_period to avoid thundering herd effect and subsequent DoS of ZooKeeper in case of very large number of tables. Only available in RawTree Cloud

parts_killer_max_condemned_parts_per_batch [#parts_killer_max_condemned_parts_per_batch]

**Type:** `NonZeroUInt64`\
**Default:** `100000`\
**Changeable without restart:** `No`\
Maximum number of condemned parts a SharedMergeTree table fetches from Keeper in a single cleanup cycle. Bounding the batch keeps the listing and multi-get within the Keeper operation timeout, so cleanup keeps making progress even when a table has accumulated a very large condemned-parts backlog. Must be greater than zero: a value of `0` would make Keeper return an empty listing every cycle, permanently stalling cleanup. Only available in RawTree Cloud

parts_killer_pool_size [#parts_killer_pool_size]

**Type:** `UInt64`\
**Default:** `128`\
**Changeable without restart:** `No`\
Threads for cleanup of shared merge tree parts killer threads. Only available in RawTree Cloud

path [#path]

**Type:** `String`\
**Default:** `/var/lib/rawtree/`\
**Changeable without restart:** `No`\
The path to the directory containing data. :::note The trailing slash is mandatory. ::: **Example** `xml <path>/var/lib/rawtree/</path> `

per_cpu_untracked_memory_thread_buffer [#per_cpu_untracked_memory_thread_buffer]

**Type:** `UInt64`\
**Default:** `32768`\
**Changeable without restart:** `Yes`\
Amount of untracked memory, in bytes, each thread may hold without touching the shared per-CPU budget. It amortizes the cost of the per-CPU bookkeeping for small allocations and is the slack added on top of `max_per_cpu_untracked_memory * number_of_cpus` in the worst case. A value of `0` removes the slack: every allocation updates the shared per-CPU counter (most precise, but more contention). Linux only.

point_in_polygon_cache_size [#point_in_polygon_cache_size]

**Type:** `UInt64`\
**Default:** `268435456`\
**Changeable without restart:** `Yes`\
Maximum size in bytes of the cache of preprocessed polygons used by the function `pointInPolygon` with a constant polygon argument. Entries above the limit are evicted in least recently used order. Setting it to `0` disables the cache: all cached polygons are evicted, and every subsequent query preprocesses its constant polygon anew. The cache can also be cleared manually, without changing this limit, with the [`SYSTEM DROP POINT IN POLYGON CACHE`](/reference/statements/system#drop-point-in-polygon-cache) query. :::note This setting can be modified at runtime and will take effect immediately. :::

postgresql_require_secure_transport [#postgresql_require_secure_transport]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
If set to true, secure communication is required with clients over [postgresql\_port](/reference/settings/server-settings/settings/postgresql#postgresql_port). Connection with option `<sslmode=disable>` will be refused. Use it with [OpenSSL](/reference/settings/server-settings/settings/other#openssl) settings.

prefetch_threadpool_pool_size [#prefetch_threadpool_pool_size]

**Type:** `NonZeroUInt64`\
**Default:** `100`\
**Changeable without restart:** `No`\
Size of background pool for prefetches for remote object storages

prefetch_threadpool_queue_size [#prefetch_threadpool_queue_size]

**Type:** `UInt64`\
**Default:** `10000`\
**Changeable without restart:** `No`\
Number of tasks which is possible to push into prefetches pool

prefixes_deserialization_thread_pool_thread_pool_queue_size [#prefixes_deserialization_thread_pool_thread_pool_queue_size]

**Type:** `UInt64`\
**Default:** `10000`\
**Changeable without restart:** `Yes`\
The maximum number of jobs that can be scheduled on the prefixes deserialization Thread pool. :::note A value of `0` means unlimited. :::

prepare_system_log_tables_on_startup [#prepare_system_log_tables_on_startup]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
If true, RawTree creates all configured `system.*_log` tables before the startup. It can be helpful if some startup scripts depend on these tables.

primary_index_cache_policy [#primary_index_cache_policy]

**Type:** `String`\
**Default:** `SLRU`\
**Changeable without restart:** `No`\
Primary index cache policy name.

primary_index_cache_prewarm_ratio [#primary_index_cache_prewarm_ratio]

**Type:** `Double`\
**Default:** `0.95`\
**Changeable without restart:** `No`\
The ratio of total size of mark cache to fill during prewarm.

primary_index_cache_size [#primary_index_cache_size]

**Type:** `UInt64`\
**Default:** `5368709120`\
**Changeable without restart:** `Yes`\
Maximum size of cache for primary index (index of MergeTree family of tables).

primary_index_cache_size_ratio [#primary_index_cache_size_ratio]

**Type:** `Double`\
**Default:** `0.5`\
**Changeable without restart:** `No`\
The size of the protected queue (in case of SLRU policy) in the primary index cache relative to the cache's total size.

process_query_plan_packet [#process_query_plan_packet]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
This setting allows reading QueryPlan packet. This packet is sent for distributed queries when serialize\_query\_plan is enabled. Disabled by default to avoid possible security issues which can be caused by bugs in query plan binary deserialization. **Example** `xml <process_query_plan_packet>true</process_query_plan_packet> `

prometheus.keeper_metrics_only [#prometheuskeeper_metrics_only]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Expose the keeper related metrics

query_cache.max_entries [#query_cachemax_entries]

**Type:** `UInt64`\
**Default:** `1024`\
**Changeable without restart:** `No`\
The maximum number of SELECT query results stored in the cache.

query_cache.max_entry_size_in_bytes [#query_cachemax_entry_size_in_bytes]

**Type:** `UInt64`\
**Default:** `1048576`\
**Changeable without restart:** `No`\
The maximum size in bytes SELECT query results may have to be saved in the cache.

query_cache.max_entry_size_in_rows [#query_cachemax_entry_size_in_rows]

**Type:** `UInt64`\
**Default:** `30000000`\
**Changeable without restart:** `No`\
The maximum number of rows SELECT query results may have to be saved in the cache.

query_cache.max_size_in_bytes [#query_cachemax_size_in_bytes]

**Type:** `UInt64`\
**Default:** `1073741824`\
**Changeable without restart:** `Yes`\
The maximum cache size in bytes. 0 means the query cache is disabled.

query_condition_cache_policy [#query_condition_cache_policy]

**Type:** `String`\
**Default:** `SLRU`\
**Changeable without restart:** `No`\
Query condition cache policy name.

query_condition_cache_size [#query_condition_cache_size]

**Type:** `UInt64`\
**Default:** `104857600`\
**Changeable without restart:** `Yes`\
Maximum size of the query condition cache. :::note This setting can be modified at runtime and will take effect immediately. :::

query_condition_cache_size_ratio [#query_condition_cache_size_ratio]

**Type:** `Double`\
**Default:** `0.5`\
**Changeable without restart:** `No`\
The size of the protected queue (in case of SLRU policy) in the query condition cache relative to the cache's total size.

remap_executable [#remap_executable]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Setting to reallocate memory for machine code ("text") using huge pages. :::note This feature is highly experimental. ::: **Example** `xml <remap_executable>false</remap_executable> `

replicated_fetches_http_connection_timeout [#replicated_fetches_http_connection_timeout]

**Type:** `Seconds`\
**Default:** `0`\
**Changeable without restart:** `No`\
HTTP connection timeout for part fetch requests. Inherited from default profile `http_connection_timeout` if not set explicitly.

replicated_fetches_http_receive_timeout [#replicated_fetches_http_receive_timeout]

**Type:** `Seconds`\
**Default:** `0`\
**Changeable without restart:** `No`\
HTTP receive timeout for fetch part requests. Inherited from default profile `http_receive_timeout` if not set explicitly.

replicated_fetches_http_send_timeout [#replicated_fetches_http_send_timeout]

**Type:** `Seconds`\
**Default:** `0`\
**Changeable without restart:** `No`\
HTTP send timeout for part fetch requests. Inherited from default profile `http_send_timeout` if not set explicitly.

restore_threads [#restore_threads]

**Type:** `NonZeroUInt64`\
**Default:** `16`\
**Changeable without restart:** `No`\
The maximum number of threads to execute RESTORE requests.

runtime_projections_cache_max_size_in_bytes [#runtime_projections_cache_max_size_in_bytes]

**Type:** `UInt64`\
**Default:** `5368709120`\
**Changeable without restart:** `No`\
The maximum size of the runtime projections cache in bytes, 5 GiB by default like the mark cache; it is lowered on machines with little RAM. 0 means the cache is disabled.

s3_allow_server_credentials_for_system_table_disks [#s3_allow_server_credentials_for_system_table_disks]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Allows a dynamic `disk(type = s3, ...)` of a table in the `system` database to use the server's own (ambient) S3 credentials, exempting it from the `s3_allow_server_credentials_in_user_queries` restriction. This is for server-internal infrastructure that ships system tables to S3 with the server's identity (attached by the cloud operator into the `system` database). Unlike the session setting, it is a server-level setting, so the exemption also applies when the table is reloaded from metadata on restart. It is scoped to the `system` database, which ordinary users cannot create tables in, so it does not relax the restriction for user queries.

s3_credentials_provider_max_cache_size [#s3_credentials_provider_max_cache_size]

**Type:** `UInt64`\
**Default:** `100`\
**Changeable without restart:** `No`\
The maximum number of S3 credentials providers that can be cached

s3_load_table_anonymously_if_credentials_restricted [#s3_load_table_anonymously_if_credentials_restricted]

**Type:** `Bool`\
**Default:** `1`\
**Changeable without restart:** `No`\
Controls what happens when a persistent `S3` or `S3Queue` table, a dynamic `disk(type = s3, ...)`, or a `DataLakeCatalog` (Glue, BigLake) database is loaded from existing metadata (server startup or `RESTORE`) and its definition would resolve the server's own (ambient) S3/cloud credentials that are blocked for user queries by `s3_allow_server_credentials_in_user_queries`. When enabled (the default), the object is loaded without those credentials instead of aborting startup: an `S3`/`S3Queue` table or a dynamic S3 disk is built with an anonymous S3 client, and a `DataLakeCatalog` database is left with an unavailable catalog. The server starts, but the object is inaccessible (its requests to a private bucket are denied, or the catalog reports a clear error) until its credentials resolve to a permitted source again. It never silently regains the server's identity. This keeps a single such object — for example one created in an older version before the restriction existed, or one whose named collection was later re-bound to `use_environment_credentials = 1` — from aborting server startup. When disabled, loading such an object instead fails, which can prevent the server from starting. Use this only if you prefer a hard failure over a silently inaccessible table, disk, or catalog database.

s3_max_redirects [#s3_max_redirects]

**Type:** `UInt64`\
**Default:** `10`\
**Changeable without restart:** `No`\
Max number of S3 redirects hops allowed.

s3_retry_attempts [#s3_retry_attempts]

**Type:** `UInt64`\
**Default:** `500`\
**Changeable without restart:** `No`\
Setting for Aws::Client::RetryStrategy, Aws::Client does retries itself, 0 means no retries

s3queue_disable_streaming [#s3queue_disable_streaming]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
Disable streaming in S3Queue even if the table is created and there are attached materiaized views

series_keeper_path [#series_keeper_path]

**Type:** `String`\
**Default:** `/rawtree/series`\
**Changeable without restart:** `No`\
Path in Keeper with auto-incremental numbers, generated by the `generateSerialID` function. Each series will be a node under this path.

show_addresses_in_stack_traces [#show_addresses_in_stack_traces]

**Type:** `Bool`\
**Default:** `1`\
**Changeable without restart:** `No`\
If it is set true will show addresses in stack traces

show_license_expiration_warnings [#show_license_expiration_warnings]

**Type:** `Bool`\
**Default:** `1`\
**Changeable without restart:** `Yes`\
Show the warning about the upcoming license expiration in system.warnings

shutdown_wait_backups_and_restores [#shutdown_wait_backups_and_restores]

**Type:** `Bool`\
**Default:** `1`\
**Changeable without restart:** `No`\
If set to true RawTree will wait for running backups and restores to finish before shutdown.

shutdown_wait_unfinished [#shutdown_wait_unfinished]

**Type:** `UInt64`\
**Default:** `120`\
**Changeable without restart:** `No`\
Delay in seconds to wait for unfinished queries

shutdown_wait_unfinished_queries [#shutdown_wait_unfinished_queries]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
If set true RawTree will wait for running queries finish before shutdown.

skip_binary_checksum_checks [#skip_binary_checksum_checks]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Skips RawTree binary checksum integrity checks

skip_check_for_incorrect_settings [#skip_check_for_incorrect_settings]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
If set to true, server settings will not be checked for correctness. **Example** `xml <skip_check_for_incorrect_settings>1</skip_check_for_incorrect_settings> `

snapshot_cleaner_period [#snapshot_cleaner_period]

**Type:** `UInt64`\
**Default:** `120`\
**Changeable without restart:** `No`\
Period to completely remove snapshot parts for SharedMergeTree. Only available in RawTree Cloud

snapshot_cleaner_pool_size [#snapshot_cleaner_pool_size]

**Type:** `UInt64`\
**Default:** `128`\
**Changeable without restart:** `No`\
Threads for cleanup of shared merge tree snapshot cleaner threads. Only available in RawTree Cloud

startup_mv_delay_ms [#startup_mv_delay_ms]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `No`\
Debug parameter to simulate materizlied view creation delay

startup_scripts.throw_on_error [#startup_scriptsthrow_on_error]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
If set to true, the server will not start if an error occurs during script execution.

storage_connections_hard_limit [#storage_connections_hard_limit]

**Type:** `UInt64`\
**Default:** `200000`\
**Changeable without restart:** `No`\
Exception is thrown at a creation attempt when this limit is reached. Set to 0 to turn off hard limitation. The limit applies to the storages connections.

storage_connections_rcvbuf [#storage_connections_rcvbuf]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
The size of the SO\_RCVBUF option for storage connections (replication, distributed queries). If set to a value greater than 0, overrides the kernel TCP autotuning for the receive buffer. 0 = kernel default (autotuning). Note: changing this setting back to 0 restores autotuning only for newly created connections; existing pooled connections retain fixed buffer sizes until they are recreated.

storage_connections_sndbuf [#storage_connections_sndbuf]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
The size of the SO\_SNDBUF option for storage connections (replication, distributed queries). If set to a value greater than 0, overrides the kernel TCP autotuning for the send buffer. 0 = kernel default (autotuning). Note: changing this setting back to 0 restores autotuning only for newly created connections; existing pooled connections retain fixed buffer sizes until they are recreated.

storage_connections_soft_limit [#storage_connections_soft_limit]

**Type:** `UInt64`\
**Default:** `100`\
**Changeable without restart:** `No`\
Connections above this limit have significantly shorter time to live. The limit applies to the storages connections.

storage_connections_store_limit [#storage_connections_store_limit]

**Type:** `UInt64`\
**Default:** `1000`\
**Changeable without restart:** `No`\
Connections above this limit reset after use. Set to 0 to turn connection cache off. The limit applies to the storages connections.

storage_connections_warn_limit [#storage_connections_warn_limit]

**Type:** `UInt64`\
**Default:** `500`\
**Changeable without restart:** `No`\
Warning massages are written to the logs if number of in-use connections are higher than this limit. The limit applies to the storages connections.

storage_shared_set_join_use_inner_uuid [#storage_shared_set_join_use_inner_uuid]

**Type:** `Bool`\
**Default:** `1`\
**Changeable without restart:** `No`\
If enabled, an inner UUID is generated during the creation of SharedSet and SharedJoin. RawTree Cloud only

tables_loader_background_pool_size [#tables_loader_background_pool_size]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `No`\
Sets the number of threads performing asynchronous load jobs in background pool. The background pool is used for loading tables asynchronously after server start in case there are no queries waiting for the table. It could be beneficial to keep low number of threads in background pool if there are a lot of tables. It will reserve CPU resources for concurrent query execution. :::note A value of `0` means all available CPUs will be used. :::

tables_loader_foreground_pool_size [#tables_loader_foreground_pool_size]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `No`\
Sets the number of threads performing load jobs in foreground pool. The foreground pool is used for loading table synchronously before server start listening on a port and for loading tables that are waited for. Foreground pool has higher priority than background pool. It means that no job starts in background pool while there are jobs running in foreground pool. :::note A value of `0` means all available CPUs will be used. :::

tcp_close_connection_after_queries_num [#tcp_close_connection_after_queries_num]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `No`\
Maximum number of queries allowed per TCP connection before the connection is closed. Set to 0 for unlimited queries.

tcp_close_connection_after_queries_seconds [#tcp_close_connection_after_queries_seconds]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `No`\
Maximum lifetime of a TCP connection in seconds before it is closed. Set to 0 for unlimited connection lifetime.

tcp_with_proxy_allow_interserver_mode [#tcp_with_proxy_allow_interserver_mode]

**Type:** `Bool`\
**Default:** `1`\
**Changeable without restart:** `No`\
Allows clients connected through `tcp_with_proxy_port` to use the native protocol's interserver mode. Disable this setting when `tcp_with_proxy_port` is exposed to untrusted clients through a proxy. Connections to `tcp_port` and `tcp_port_secure` are not affected.

temporary_data_in_cache [#temporary_data_in_cache]

**Type:** `String`\
**Default:** \`\`\
**Changeable without restart:** `No`\
With this option, temporary data will be stored in the cache for the particular disk. In this section, you should specify the disk name with the type `cache`. In that case, the cache and temporary data will share the same space, and the disk cache can be evicted to create temporary data. :::note Only one option can be used to configure temporary data storage: `tmp_path` ,`tmp_policy`, `temporary_data_in_cache`. ::: **Example** Both the cache for `local_disk`, and temporary data will be stored in `/tiny_local_cache` on the filesystem, managed by `tiny_local_cache`. `xml <clickhouse> <storage_configuration> <disks> <local_disk> <type>local</type> <path>/local_disk/</path> </local_disk> <!-- highlight-start --> <tiny_local_cache> <type>cache</type> <disk>local_disk</disk> <path>/tiny_local_cache/</path> <max_size_rows>10M</max_size_rows> <max_file_segment_size>1M</max_file_segment_size> <cache_on_write_operations>1</cache_on_write_operations> </tiny_local_cache> <!-- highlight-end --> </disks> </storage_configuration> <!-- highlight-start --> <temporary_data_in_cache>tiny_local_cache</temporary_data_in_cache> <!-- highlight-end --> </clickhouse> `

temporary_data_in_distributed_cache [#temporary_data_in_distributed_cache]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Store temporary data in the distributed cache.

text_index_header_cache_max_entries [#text_index_header_cache_max_entries]

**Type:** `UInt64`\
**Default:** `100000`\
**Changeable without restart:** `No`\
Size of cache for text index header in entries. Zero means disabled.

text_index_header_cache_policy [#text_index_header_cache_policy]

**Type:** `String`\
**Default:** `SLRU`\
**Changeable without restart:** `No`\
Text index header cache policy name.

text_index_header_cache_size [#text_index_header_cache_size]

**Type:** `UInt64`\
**Default:** `1073741824`\
**Changeable without restart:** `Yes`\
Size of cache for text index headers. Zero means disabled. :::note This setting can be modified at runtime and will take effect immediately. :::

text_index_header_cache_size_ratio [#text_index_header_cache_size_ratio]

**Type:** `Double`\
**Default:** `0.5`\
**Changeable without restart:** `No`\
The size of the protected queue (in case of SLRU policy) in the text index header cache relative to the cache's total size.

text_index_postings_cache_max_entries [#text_index_postings_cache_max_entries]

**Type:** `UInt64`\
**Default:** `1000000`\
**Changeable without restart:** `No`\
Size of cache for text index posting list in entries. Zero means disabled.

text_index_postings_cache_policy [#text_index_postings_cache_policy]

**Type:** `String`\
**Default:** `SLRU`\
**Changeable without restart:** `No`\
Text index posting list cache policy name.

text_index_postings_cache_size [#text_index_postings_cache_size]

**Type:** `UInt64`\
**Default:** `2147483648`\
**Changeable without restart:** `Yes`\
Size of cache for text index posting lists. Zero means disabled. :::note This setting can be modified at runtime and will take effect immediately. :::

text_index_postings_cache_size_ratio [#text_index_postings_cache_size_ratio]

**Type:** `Double`\
**Default:** `0.5`\
**Changeable without restart:** `No`\
The size of the protected queue (in case of SLRU policy) in the text index posting list cache relative to the cache's total size.

text_index_tokens_cache_max_entries [#text_index_tokens_cache_max_entries]

**Type:** `UInt64`\
**Default:** `1000000`\
**Changeable without restart:** `No`\
Size of cache for text index tokens in entries. Zero means disabled.

text_index_tokens_cache_policy [#text_index_tokens_cache_policy]

**Type:** `String`\
**Default:** `SLRU`\
**Changeable without restart:** `No`\
Text index tokens cache policy name.

text_index_tokens_cache_size [#text_index_tokens_cache_size]

**Type:** `UInt64`\
**Default:** `1073741824`\
**Changeable without restart:** `Yes`\
Size of cache for text index tokens. Zero means disabled. :::note This setting can be modified at runtime and will take effect immediately. :::

text_index_tokens_cache_size_ratio [#text_index_tokens_cache_size_ratio]

**Type:** `Double`\
**Default:** `0.5`\
**Changeable without restart:** `No`\
The size of the protected queue (in case of SLRU policy) in the text index tokens cache relative to the cache's total size.

thread_pool_queue_size [#thread_pool_queue_size]

**Type:** `UInt64`\
**Default:** `10000`\
**Changeable without restart:** `No`\
The maximum number of jobs that can be scheduled on the Global Thread pool. Increasing queue size leads to larger memory usage. It is recommended to keep this value equal to [`max_thread_pool_size`](/reference/settings/server-settings/settings/max-thread#max_thread_pool_size). :::note A value of `0` means unlimited. ::: **Example** `xml <thread_pool_queue_size>12000</thread_pool_queue_size> `

threadpool_local_fs_reader_pool_size [#threadpool_local_fs_reader_pool_size]

**Type:** `NonZeroUInt64`\
**Default:** `100`\
**Changeable without restart:** `No`\
The number of threads in the thread pool for reading from local filesystem when `local_filesystem_read_method = 'pread_threadpool'`.

threadpool_local_fs_reader_queue_size [#threadpool_local_fs_reader_queue_size]

**Type:** `UInt64`\
**Default:** `10000`\
**Changeable without restart:** `No`\
The maximum number of jobs that can be scheduled on the thread pool for reading from local filesystem.

threadpool_remote_fs_reader_pool_size [#threadpool_remote_fs_reader_pool_size]

**Type:** `NonZeroUInt64`\
**Default:** `250`\
**Changeable without restart:** `No`\
Number of threads in the Thread pool used for reading from remote filesystem when `remote_filesystem_read_method = 'threadpool'`.

threadpool_remote_fs_reader_queue_size [#threadpool_remote_fs_reader_queue_size]

**Type:** `UInt64`\
**Default:** `10000`\
**Changeable without restart:** `No`\
The maximum number of jobs that can be scheduled on the thread pool for reading from remote filesystem.

threadpool_writer_pool_size [#threadpool_writer_pool_size]

**Type:** `NonZeroUInt64`\
**Default:** `100`\
**Changeable without restart:** `No`\
Size of background pool for write requests to object storages

threadpool_writer_queue_size [#threadpool_writer_queue_size]

**Type:** `UInt64`\
**Default:** `10000`\
**Changeable without restart:** `No`\
Number of tasks which is possible to push into background pool for write requests to object storages

throw_on_unknown_workload [#throw_on_unknown_workload]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
Defines behaviour on access to unknown WORKLOAD with query setting 'workload'. - If `true`, RESOURCE\_ACCESS\_DENIED exception is thrown from a query that is trying to access unknown workload. Useful to enforce resource scheduling for all queries after WORKLOAD hierarchy is established and contains WORKLOAD default. - If `false` (default), unlimited access w/o resource scheduling is provided to a query with 'workload' setting pointing to unknown WORKLOAD. This is important during setting up hierarchy of WORKLOAD, before WORKLOAD default is added. **Example** `xml <throw_on_unknown_workload>true</throw_on_unknown_workload> ` **See Also** - [Workload Scheduling](/concepts/features/configuration/server-config/workload-scheduling)

tmp_path [#tmp_path]

**Type:** `String`\
**Default:** `/var/lib/rawtree/tmp/`\
**Changeable without restart:** `No`\
Path on the local filesystem to store temporary data for processing large queries. :::note - Only one option can be used to configure temporary data storage: tmp\_path, tmp\_policy, temporary\_data\_in\_cache. - The trailing slash is mandatory. ::: **Example** `xml <tmp_path>/var/lib/rawtree/tmp/</tmp_path> `

tmp_policy [#tmp_policy]

**Type:** `String`\
**Default:** \`\`\
**Changeable without restart:** `No`\
Policy for storage with temporary data. All files with `tmp` prefix will be removed at start. :::note Recommendations for using object storage as `tmp_policy`: - Use separate `bucket:path` on each server - Use `metadata_type=plain` - You may also want to set TTL for this bucket ::: :::note - Only one option can be used to configure temporary data storage: `tmp_path` ,`tmp_policy`, `temporary_data_in_cache`. - `move_factor`, `keep_free_space_bytes`,`max_data_part_size_bytes` and are ignored. - Policy should have exactly *one volume* For more information see the [MergeTree Table Engine](/reference/engines/table-engines/mergetree-family/mergetree) documentation. ::: **Example** When `/disk1` is full, temporary data will be stored on `/disk2`. `xml <clickhouse> <storage_configuration> <disks> <disk1> <path>/disk1/</path> </disk1> <disk2> <path>/disk2/</path> </disk2> </disks> <policies> <!-- highlight-start --> <tmp_two_disks> <volumes> <main> <disk>disk1</disk> <disk>disk2</disk> </main> </volumes> </tmp_two_disks> <!-- highlight-end --> </policies> </storage_configuration> <!-- highlight-start --> <tmp_policy>tmp_two_disks</tmp_policy> <!-- highlight-end --> </clickhouse> `

top_level_domains_path [#top_level_domains_path]

**Type:** `String`\
**Default:** `/var/lib/rawtree/top_level_domains/`\
**Changeable without restart:** `No`\
The directory with top level domains. **Example** `xml <top_level_domains_path>/var/lib/rawtree/top_level_domains/</top_level_domains_path> `

total_memory_profiler_sample_max_allocation_size [#total_memory_profiler_sample_max_allocation_size]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `No`\
Collect random allocations of size less or equal than specified value with probability equal to `total_memory_profiler_sample_probability`. 0 means disabled. You may want to set 'max\_untracked\_memory' to 0 to make this threshold to work as expected.

total_memory_profiler_sample_min_allocation_size [#total_memory_profiler_sample_min_allocation_size]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `No`\
Collect random allocations of size greater or equal than specified value with probability equal to `total_memory_profiler_sample_probability`. 0 means disabled. You may want to set 'max\_untracked\_memory' to 0 to make this threshold to work as expected.

total_memory_profiler_step [#total_memory_profiler_step]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `No`\
Whenever server memory usage becomes larger than every next step in number of bytes the memory profiler will collect the allocating stack trace. Zero means disabled memory profiler. Values lower than a few megabytes will slow down server.

total_memory_tracker_sample_probability [#total_memory_tracker_sample_probability]

**Type:** `Double`\
**Default:** `0`\
**Changeable without restart:** `No`\
Allows to collect random allocations and de-allocations and writes them in the [system.trace\_log](/reference/system-tables/trace_log) system table with `trace_type` equal to a `MemorySample` with the specified probability. The probability is for every allocation or deallocations, regardless of the size of the allocation. Note that sampling happens only when the amount of untracked memory exceeds the untracked memory limit (default value is `4` MiB). It can be lowered if [total\_memory\_profiler\_step](/reference/settings/server-settings/settings/total-memory#total_memory_profiler_step) is lowered. You can set `total_memory_profiler_step` equal to `1` for extra fine-grained sampling. Possible values: - Positive double. - `0` — Writing of random allocations and de-allocations in the `system.trace_log` system table is disabled.

uncompressed_cache_policy [#uncompressed_cache_policy]

**Type:** `String`\
**Default:** `SLRU`\
**Changeable without restart:** `No`\
Uncompressed cache policy name.

uncompressed_cache_size [#uncompressed_cache_size]

**Type:** `UInt64`\
**Default:** `0`\
**Changeable without restart:** `Yes`\
Maximum size (in bytes) for uncompressed data used by table engines from the MergeTree family. There is one shared cache for the server. Memory is allocated on demand. The cache is used if the option `use_uncompressed_cache` is enabled. The uncompressed cache is advantageous for very short queries in individual cases. :::note A value of `0` means disabled. This setting can be modified at runtime and will take effect immediately. :::

uncompressed_cache_size_ratio [#uncompressed_cache_size_ratio]

**Type:** `Double`\
**Default:** `0.5`\
**Changeable without restart:** `No`\
The size of the protected queue (in case of SLRU policy) in the uncompressed cache relative to the cache's total size.

unique_key_bitmap_cache_policy [#unique_key_bitmap_cache_policy]

**Type:** `String`\
**Default:** `SLRU`\
**Changeable without restart:** `No`\
UNIQUE KEY delete-bitmap cache policy name (SLRU or LRU).

unique_key_bitmap_cache_size_bytes [#unique_key_bitmap_cache_size_bytes]

**Type:** `UInt64`\
**Default:** `1073741824`\
**Changeable without restart:** `Yes`\
Maximum size in bytes of the in-process cache for UNIQUE KEY per-part delete bitmaps. Set to 0 to disable the cache.

unique_key_bitmap_cache_size_ratio [#unique_key_bitmap_cache_size_ratio]

**Type:** `Double`\
**Default:** `0.5`\
**Changeable without restart:** `No`\
The size of the protected queue (in case of SLRU policy) in the UNIQUE KEY delete-bitmap cache relative to the cache's total size.

unique_key_index_cache_policy [#unique_key_index_cache_policy]

**Type:** `String`\
**Default:** `SLRU`\
**Changeable without restart:** `No`\
UNIQUE KEY index cache policy name (SLRU or LRU).

unique_key_index_cache_size_bytes [#unique_key_index_cache_size_bytes]

**Type:** `UInt64`\
**Default:** `1073741824`\
**Changeable without restart:** `No`\
Maximum size (bytes) of the in-process cache for UNIQUE KEY index (SST) blocks. Set to 0 to disable the cache.

unique_key_index_cache_size_ratio [#unique_key_index_cache_size_ratio]

**Type:** `Double`\
**Default:** `0.5`\
**Changeable without restart:** `No`\
The size of the protected queue (in case of SLRU policy) in the UNIQUE KEY index cache relative to the cache's total size.

use_separate_cache_arena [#use_separate_cache_arena]

**Type:** `Bool`\
**Default:** `1`\
**Changeable without restart:** `No`\
Enable a dedicated jemalloc arena for cache allocations (mark cache, uncompressed cache, page cache). Isolates cache data from query-processing allocations, reducing memory fragmentation.

use_shared_merge_tree_log_pipeline [#use_shared_merge_tree_log_pipeline]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Only available on ClickHouse Cloud. When enabled, `system.*_log` tables are backed by `SharedMergeTree` via an S3-based pipeline. For each log `<log>`, the following objects are created automatically on startup: - `system.<log>_s3` — an `S3`-backed table that is the direct flush target; each `SYSTEM FLUSH LOGS` call writes a new partitioned file here. - `system.<log>_s3queue` — an `S3Queue` table (ordered mode) that picks up files from `<log>_s3` and streams rows downstream. Each node processes only its own files via `partition_regex`-based partitioning. - `system.<log>_mv` — a `MATERIALIZED VIEW` that routes rows from `<log>_s3queue` into the final `SharedMergeTree` table. - `system.<log>` — the final `SharedMergeTree` table where rows accumulate and are queried. On schema or settings change, the affected table is renamed to `<log>_0`, `<log>_1`, etc. and recreated, consistent with the existing `SystemLog` rotation behavior. Requires `<shared_log_pipeline><endpoint>` to be set in the server configuration. See also: `shared_log_pipeline.enable_sync_flush`, `shared_log_pipeline.flush_timeout_seconds`.

user_files_path [#user_files_path]

**Type:** `String`\
**Default:** `/var/lib/rawtree/user_files/`\
**Changeable without restart:** `No`\
The directory with user files. Used in the table function [file()](/reference/functions/table-functions/file), [fileCluster()](/reference/functions/table-functions/fileCluster). **Example** `xml <user_files_path>/var/lib/rawtree/user_files/</user_files_path> `

user_profile_events_per_cpu [#user_profile_events_per_cpu]

**Type:** `Bool`\
**Default:** `1`\
**Changeable without restart:** `No`\
Shard per-user `ProfileEvents` counters per CPU to avoid cross-CPU cache-line contention under high thread counts. Each user pays `getNumCPUs() * num_events * sizeof(atomic)` of memory (hundreds of KiB on machines with many cores). Disable to fall back to a single shared atomic per event per user, trading throughput for memory.

user_scripts_path [#user_scripts_path]

**Type:** `String`\
**Default:** `/var/lib/rawtree/user_scripts/`\
**Changeable without restart:** `No`\
The directory with user scripts files. Used for Executable user defined functions [Executable User Defined Functions](/reference/functions/regular-functions/udf#executable-user-defined-functions). **Example** `xml <user_scripts_path>/var/lib/rawtree/user_scripts/</user_scripts_path> `

users_to_ignore_early_memory_limit_check [#users_to_ignore_early_memory_limit_check]

**Type:** `String`\
**Default:** \`\`\
**Changeable without restart:** `No`\
Comma-separated list of users to ignore an early memory limit check. If user is not in this list, a query will be rejected if the total memory usage exceeds the limit.

validate_tcp_client_information [#validate_tcp_client_information]

**Type:** `Bool`\
**Default:** `0`\
**Changeable without restart:** `No`\
Determines whether validation of client information is enabled when a query packet is received. By default, it is `false`: `xml <validate_tcp_client_information>false</validate_tcp_client_information> `

vector_similarity_index_cache_max_entries [#vector_similarity_index_cache_max_entries]

**Type:** `UInt64`\
**Default:** `10000000`\
**Changeable without restart:** `No`\
Size of cache for vector similarity index in entries. Zero means disabled.

vector_similarity_index_cache_policy [#vector_similarity_index_cache_policy]

**Type:** `String`\
**Default:** `SLRU`\
**Changeable without restart:** `No`\
Vector similarity index cache policy name.

vector_similarity_index_cache_size [#vector_similarity_index_cache_size]

**Type:** `UInt64`\
**Default:** `5368709120`\
**Changeable without restart:** `Yes`\
Size of cache for vector similarity indexes. Zero means disabled. :::note This setting can be modified at runtime and will take effect immediately. :::

vector_similarity_index_cache_size_ratio [#vector_similarity_index_cache_size_ratio]

**Type:** `Double`\
**Default:** `0.5`\
**Changeable without restart:** `No`\
The size of the protected queue (in case of SLRU policy) in the vector similarity index cache relative to the cache's total size.

wait_dictionaries_load_at_startup [#wait_dictionaries_load_at_startup]

**Type:** `Bool`\
**Default:** `1`\
**Changeable without restart:** `No`\
This setting allows to specify behavior if `dictionaries_lazy_load` is `false`. (If `dictionaries_lazy_load` is `true` this setting doesn't affect anything.) If `wait_dictionaries_load_at_startup` is `false`, then the server will start loading all the dictionaries at startup and it will receive connections in parallel with that loading. When a dictionary is used in a query for the first time then the query will wait until the dictionary is loaded if it's not loaded yet. Setting `wait_dictionaries_load_at_startup` to `false` can make RawTree start faster, however some queries can be executed slower (because they will have to wait for some dictionaries to be loaded). If `wait_dictionaries_load_at_startup` is `true`, then the server will wait at startup until all the dictionaries finish their loading (successfully or not) before receiving any connections. **Example** `xml <wait_dictionaries_load_at_startup>true</wait_dictionaries_load_at_startup> `

webassembly_udf_engine [#webassembly_udf_engine]

**Type:** `String`\
**Default:** `wasmtime`\
**Changeable without restart:** `No`\
The engine used to execute WebAssembly UDFs. Supported values are 'wasmtime' and 'wasmedge'.

webterminal_allowed_origins [#webterminal_allowed_origins]

**Type:** `String`\
**Default:** \`\`\
**Changeable without restart:** `No`\
Comma-separated list of full origins (scheme + host + optional port) allowed to open `/webterminal` WebSocket sessions. When empty, the same-origin policy is enforced strictly (Origin must match the request scheme, host, and port). Set this for deployments behind a TLS-terminating reverse proxy where `request.isSecure()` is `false` even though the browser uses `https`. Example: `https://example.com,https://app.example.com:8443`.