ClickHouse/dbms/src/Interpreters/Settings.h

#pragma once

#include <Poco/Timespan.h>
#include <Poco/Util/AbstractConfiguration.h>
#include <Core/Defines.h>
#include <Core/Field.h>

#include <Interpreters/Limits.h>
#include <Interpreters/SettingsCommon.h>


namespace DB
{

/** Settings of query execution.
  */
struct Settings
{
    /// For initialization from empty initializer-list to be "value initialization", not "aggregate initialization" in С++14.
    /// http://en.cppreference.com/w/cpp/language/aggregate_initialization
    Settings() {}

    /** List of settings: type, name, default value.
      *
      * This looks rather unconvenient. It is done that way to avoid repeating settings in different places.
      * Note: as an alternative, we could implement settings to be completely dynamic in form of map: String -> Field,
      *  but we are not going to do it, because settings is used everywhere as static struct fields.
      */

#define APPLY_FOR_SETTINGS(M) \
    /** When writing data, a buffer of max_compress_block_size size is allocated for compression. When the buffer overflows or if into the buffer */ \
    /** written data is greater than or equal to min_compress_block_size, then with the next mark, the data will also be compressed */ \
    /** As a result, for small columns (around 1-8 bytes), with index_granularity = 8192, the block size will be 64 KB. */ \
    /** And for large columns (Title - string ~100 bytes), the block size will be ~819 KB. */ \
    /** Due to this, the compression ratio almost does not get worse. */ \
    M(SettingUInt64, min_compress_block_size, DEFAULT_MIN_COMPRESS_BLOCK_SIZE) \
    M(SettingUInt64, max_compress_block_size, DEFAULT_MAX_COMPRESS_BLOCK_SIZE) \
    /** Maximum block size for reading */ \
    M(SettingUInt64, max_block_size, DEFAULT_BLOCK_SIZE) \
    /** The maximum block size for insertion, if we control the creation of blocks for insertion. */ \
    M(SettingUInt64, max_insert_block_size, DEFAULT_INSERT_BLOCK_SIZE) \
    /** Squash blocks passed to INSERT query to specified size in rows, if blocks are not big enough. */ \
    M(SettingUInt64, min_insert_block_size_rows, DEFAULT_INSERT_BLOCK_SIZE) \
    /** Squash blocks passed to INSERT query to specified size in bytes, if blocks are not big enough. */ \
    M(SettingUInt64, min_insert_block_size_bytes, (DEFAULT_INSERT_BLOCK_SIZE * 256)) \
    /** The maximum number of threads to execute the request. By default, it is determined automatically. */ \
    M(SettingMaxThreads, max_threads, 0) \
    /** The maximum size of the buffer to read from the file system. */ \
    M(SettingUInt64, max_read_buffer_size, DBMS_DEFAULT_BUFFER_SIZE) \
    /** The maximum number of connections for distributed processing of one query (should be greater than max_threads). */ \
    M(SettingUInt64, max_distributed_connections, DEFAULT_MAX_DISTRIBUTED_CONNECTIONS) \
    /** Which part of the query can be read into RAM for parsing (the remaining data for INSERT, if any, is read later) */ \
    M(SettingUInt64, max_query_size, DEFAULT_MAX_QUERY_SIZE) \
    /** The interval in microseconds to check if the request is cancelled, and to send progress info. */ \
    M(SettingUInt64, interactive_delay, DEFAULT_INTERACTIVE_DELAY) \
    M(SettingSeconds, connect_timeout, DBMS_DEFAULT_CONNECT_TIMEOUT_SEC) \
    /** If you should select one of the working replicas. */ \
    M(SettingMilliseconds, connect_timeout_with_failover_ms, DBMS_DEFAULT_CONNECT_TIMEOUT_WITH_FAILOVER_MS) \
    M(SettingSeconds, receive_timeout, DBMS_DEFAULT_RECEIVE_TIMEOUT_SEC) \
    M(SettingSeconds, send_timeout, DBMS_DEFAULT_SEND_TIMEOUT_SEC) \
    /** The wait time in the request queue, if the number of concurrent requests exceeds the maximum. */ \
    M(SettingMilliseconds, queue_max_wait_ms, DEFAULT_QUERIES_QUEUE_WAIT_TIME_MS) \
    /** Block at the query wait cycle on the server for the specified number of seconds. */ \
    M(SettingUInt64, poll_interval, DBMS_DEFAULT_POLL_INTERVAL) \
    /** Maximum number of connections with one remote server in the pool. */ \
    M(SettingUInt64, distributed_connections_pool_size, DBMS_DEFAULT_DISTRIBUTED_CONNECTIONS_POOL_SIZE) \
    /** The maximum number of attempts to connect to replicas. */ \
    M(SettingUInt64, connections_with_failover_max_tries, DBMS_CONNECTION_POOL_WITH_FAILOVER_DEFAULT_MAX_TRIES) \
    /** Calculate minimums and maximums of the result columns. They can be output in JSON-formats. */ \
    M(SettingBool, extremes, false) \
    /** Whether to use the cache of uncompressed blocks. */ \
    M(SettingBool, use_uncompressed_cache, true) \
    /** Whether the running request should be canceled with the same id as the new one. */ \
    M(SettingBool, replace_running_query, false) \
    /** Number of threads performing background work for tables (for example, merging in merge tree). \
      * TODO: Now only applies when the server is started. You can make it dynamically variable. */ \
    M(SettingUInt64, background_pool_size, DBMS_DEFAULT_BACKGROUND_POOL_SIZE) \
    \
    /** Sleep time for StorageDistributed DirectoryMonitors in case there is no work or exception has been thrown */ \
    M(SettingMilliseconds, distributed_directory_monitor_sleep_time_ms, DBMS_DISTRIBUTED_DIRECTORY_MONITOR_SLEEP_TIME_MS) \
    \
    /** Allows disabling WHERE to PREWHERE optimization in SELECT queries from MergeTree */ \
    M(SettingBool, optimize_move_to_prewhere, true) \
    \
    /** Wait for actions to manipulate the partitions. 0 - do not wait, 1 - wait for execution only of itself, 2 - wait for everyone. */ \
    M(SettingUInt64, replication_alter_partitions_sync, 1) \
    /** Wait for actions to change the table structure within the specified number of seconds. 0 - wait unlimited time. */ \
    M(SettingUInt64, replication_alter_columns_timeout, 60) \
    \
    M(SettingLoadBalancing, load_balancing, LoadBalancing::RANDOM) \
    \
    M(SettingTotalsMode, totals_mode, TotalsMode::AFTER_HAVING_EXCLUSIVE) \
    M(SettingFloat, totals_auto_threshold, 0.5) \
    \
    /** Whether query compilation is enabled. */ \
    M(SettingBool, compile, false) \
    /** The number of structurally identical queries before they are compiled. */ \
    M(SettingUInt64, min_count_to_compile, 3) \
    /** From what number of keys, a two-level aggregation starts. 0 - the threshold is not set. */ \
    M(SettingUInt64, group_by_two_level_threshold, 100000) \
    /** From what size of the aggregation state in bytes, a two-level aggregation begins to be used. 0 - the threshold is not set. \
      * Two-level aggregation is used when at least one of the thresholds is triggered. */ \
    M(SettingUInt64, group_by_two_level_threshold_bytes, 100000000) \
    /** Is the memory-saving mode of distributed aggregation enabled. */ \
    M(SettingBool, distributed_aggregation_memory_efficient, false) \
    /** Number of threads to use for merge intermediate aggregation results in memory efficient mode. When bigger, then more memory is consumed. \
      * 0 means - same as 'max_threads'. */ \
    M(SettingUInt64, aggregation_memory_efficient_merge_threads, 0) \
    \
    /** The maximum number of replicas of each shard used when executing the query */ \
    M(SettingUInt64, max_parallel_replicas, 1) \
    M(SettingUInt64, parallel_replicas_count, 0) \
    M(SettingUInt64, parallel_replica_offset, 0) \
    \
    /** Silently skip unavailable shards. */ \
    M(SettingBool, skip_unavailable_shards, false) \
    \
    /** Do not merge aggregation states from different servers for distributed query processing \
      *  - in case it is for certain that there are different keys on different shards. \
      */ \
    M(SettingBool, distributed_group_by_no_merge, false) \
    \
    /** Advanced settings for reading from MergeTree */ \
    \
    /** If at least as many lines are read from one file, the reading can be parallelized. */ \
    M(SettingUInt64, merge_tree_min_rows_for_concurrent_read, (20 * 8192)) \
    /** You can skip reading more than that number of rows at the price of one seek per file. */ \
    M(SettingUInt64, merge_tree_min_rows_for_seek, 0) \
    /** If the index segment can contain the required keys, divide it into as many parts and recursively check them. */ \
    M(SettingUInt64, merge_tree_coarse_index_granularity, 8) \
    /** The maximum number of rows per request, to use the cache of uncompressed data. If the request is large, the cache is not used. \
      * (For large queries not to flush out the cache.) */ \
    M(SettingUInt64, merge_tree_max_rows_to_use_cache, (1024 * 1024)) \
    \
    /** Distribute read from MergeTree over threads evenly, ensuring stable average execution time of each thread within one read operation. */ \
    M(SettingBool, merge_tree_uniform_read_distribution, true) \
    \
    /** The minimum length of the expression `expr = x1 OR ... expr = xN` for optimization */ \
    M(SettingUInt64, optimize_min_equality_disjunction_chain_length, 3) \
    \
    /** The minimum number of bytes for input/output operations is bypassing the page cache. 0 - disabled. */ \
    M(SettingUInt64, min_bytes_to_use_direct_io, 0) \
    \
    /** Throw an exception if there is an index, and it is not used. */ \
    M(SettingBool, force_index_by_date, 0) \
    M(SettingBool, force_primary_key, 0) \
    \
    /** In the INSERT query with specified columns, fill in the default values ​​only for columns with explicit DEFAULTs. */ \
    M(SettingBool, strict_insert_defaults, 0) \
    \
    /** If the maximum size of mark_cache is exceeded, delete only records older than mark_cache_min_lifetime seconds. */ \
    M(SettingUInt64, mark_cache_min_lifetime, 10000) \
    \
    /** Allows you to use more sources than the number of threads - to more evenly distribute work across threads. \
      * It is assumed that this is a temporary solution, since it will be possible in the future to make the number of sources equal to the number of threads, \
      *  but for each source to dynamically select available work for itself. \
      */ \
    M(SettingFloat, max_streams_to_max_threads_ratio, 1) \
    \
    /** Allows you to select the method of data compression when writing */ \
    M(SettingCompressionMethod, network_compression_method, CompressionMethod::LZ4) \
    \
    /** Priority of the query. 1 - the highest, higher value - lower priority; 0 - do not use priorities. */ \
    M(SettingUInt64, priority, 0) \
    \
    /** Log requests and write the log to the system table. */ \
    M(SettingBool, log_queries, 0) \
    \
    /** If query length is greater than specified threshold (in bytes), then cut query when writing to query log. \
      * Also limit length of printed query in ordinary text log. \
      */ \
    M(SettingUInt64, log_queries_cut_to_length, 100000) \
    \
    /** How are distributed subqueries performed inside IN or JOIN sections? */ \
    M(SettingDistributedProductMode, distributed_product_mode, DistributedProductMode::DENY) \
    \
    /** The scheme for executing GLOBAL subqueries. */ \
    M(SettingGlobalSubqueriesMethod, global_subqueries_method, GlobalSubqueriesMethod::PUSH) \
    \
    /** The maximum number of concurrent requests per user. */ \
    M(SettingUInt64, max_concurrent_queries_for_user, 0) \
    \
    /** For INSERT queries in the replicated table, wait writing for the specified number of replicas and linearize the addition of the data. 0 - disabled. */ \
    M(SettingUInt64, insert_quorum, 0) \
    M(SettingMilliseconds, insert_quorum_timeout, 600000) \
    /** For SELECT queries from the replicated table, throw an exception if the replica does not have a chunk written with the quorum; \
      * do not read the parts that have not yet been written with the quorum. */ \
    M(SettingUInt64, select_sequential_consistency, 0) \
    /** The maximum number of different shards and the maximum number of replicas of one shard in the `remote` function. */ \
    M(SettingUInt64, table_function_remote_max_addresses, 1000) \
    /** Maximum number of threads for distributed processing of one query */ \
    M(SettingUInt64, max_distributed_processing_threads, 8) \
    \
    /** Settings to reduce the number of threads in case of slow reads. */ \
    /** Pay attention only to readings that took at least that much time. */ \
    M(SettingMilliseconds,     read_backoff_min_latency_ms, 1000) \
    /** Count events when the bandwidth is less than that many bytes per second. */ \
    M(SettingUInt64,         read_backoff_max_throughput, 1048576) \
    /** Do not pay attention to the event, if the previous one has passed less than a certain amount of time. */ \
    M(SettingMilliseconds,     read_backoff_min_interval_between_events_ms, 1000) \
    /** The number of events after which the number of threads will be reduced. */ \
    M(SettingUInt64,         read_backoff_min_events, 2) \
    \
    /** For testing of `exception safety` - throw an exception every time you allocate memory with the specified probability. */ \
    M(SettingFloat, memory_tracker_fault_probability, 0.) \
    \
    /** Compress the result if the client over HTTP said that it understands data compressed by gzip or deflate */ \
    M(SettingBool, enable_http_compression, 0) \
    /** Compression level - used if the client on HTTP said that it understands data compressed by gzip or deflate */ \
    M(SettingInt64, http_zlib_compression_level, 3) \
    \
    /** If you uncompress the POST data from the client compressed by the native format, do not check the checksum */ \
    M(SettingBool, http_native_compression_disable_checksumming_on_decompress, 0) \
    \
    /** Timeout in seconds */ \
    M(SettingUInt64, resharding_barrier_timeout, 300) \
    \
    /** What aggregate function to use for implementation of count(DISTINCT ...) */ \
    M(SettingString, count_distinct_implementation, "uniqExact") \
    \
    /** Write statistics about read rows, bytes, time elapsed in suitable output formats */ \
    M(SettingBool, output_format_write_statistics, true) \
    \
    /** Write add http CORS header */ \
    M(SettingBool, add_http_cors_header, false) \
    \
    /** Skip columns with unknown names from input data (it works for JSONEachRow and TSKV formats). */ \
    M(SettingBool, input_format_skip_unknown_fields, false) \
    \
    /** For Values format: if field could not be parsed by streaming parser, run SQL parser and try to interpret it as SQL expression. */ \
    M(SettingBool, input_format_values_interpret_expressions, true) \
    \
    /** Controls quoting of 64-bit integers in JSON output format. */ \
    M(SettingBool, output_format_json_quote_64bit_integers, true) \
    \
    /** Rows limit for Pretty formats. */ \
    M(SettingUInt64, output_format_pretty_max_rows, 10000) \
    \
    /** Use client timezone for interpreting DateTime string values, instead of adopting server timezone. */ \
    M(SettingBool, use_client_time_zone, false) \
    \
    /** Send progress notifications using X-ClickHouse-Progress headers. \
      * Some clients do not support high amount of HTTP headers (Python requests in particular), so it is disabled by default. \
      */ \
    M(SettingBool, send_progress_in_http_headers, false) \
    \
    /** Do not send HTTP headers X-ClickHouse-Progress more frequently than at each specified interval. */ \
    M(SettingUInt64, http_headers_progress_interval_ms, 100) \
    \
    /** Do fsync after changing metadata for tables and databases (.sql files). \
      * Could be disabled in case of poor latency on server with high load of DDL queries and high load of disk subsystem. \
      */ \
    M(SettingBool, fsync_metadata, 1) \
    \
    /** Maximum amount of errors while reading text formats (like CSV, TSV). \
      * In case of error, if both values are non-zero, \
      *  and at least absolute or relative amount of errors is lower than corresponding value, \
      *  will skip until next line and continue. \
      */ \
    M(SettingUInt64, input_format_allow_errors_num, 0) \
    M(SettingFloat, input_format_allow_errors_ratio, 0) \
    \
   /** Use NULLs for non-joined rows of outer JOINs. \
     * If false, use default value of corresponding columns data type. \
     */ \
    M(SettingBool, join_use_nulls, 0) \
    /* */ \
    M(SettingUInt64, preferred_block_size_bytes, 1000000) \
   /** If set, distributed queries of Replicated tables will choose servers \
     * with replication delay in seconds less than the specified value (not inclusive). \
     * Zero means do not take delay into account. \
     */ \
    \
    M(SettingUInt64, max_replica_delay_for_distributed_queries, 0) \
   /** Suppose max_replica_delay_for_distributed_queries is set and all replicas for the queried table are stale. \
     * If this setting is enabled, the query will be performed anyway, otherwise the error will be reported. \
     */ \
    M(SettingBool, fallback_to_stale_replicas_for_distributed_queries, 1)


    /// Possible limits for query execution.
    Limits limits;

#define DECLARE(TYPE, NAME, DEFAULT) \
    TYPE NAME {DEFAULT};

    APPLY_FOR_SETTINGS(DECLARE)

#undef DECLARE

    /// Set setting by name.
    void set(const String & name, const Field & value);

    /// Set setting by name. Read value, serialized in binary form from buffer (for inter-server communication).
    void set(const String & name, ReadBuffer & buf);

    /// Skip value, serialized in binary form in buffer.
    void ignore(const String & name, ReadBuffer & buf);

    /// Set setting by name. Read value in text form from string (for example, from configuration file or from URL parameter).
    void set(const String & name, const String & value);

    /** Set multiple settings from "profile" (in server configuration file (users.xml), profiles contain groups of multiple settings).
      * The profile can also be set using the `set` functions, like the profile setting.
      */
    void setProfile(const String & profile_name, Poco::Util::AbstractConfiguration & config);

    /// Load settings from configuration file, at "path" prefix in configuration.
    void loadSettingsFromConfig(const String & path, const Poco::Util::AbstractConfiguration & config);

    /// Read settings from buffer. They are serialized as list of contiguous name-value pairs, finished with empty name.
    /// If readonly=1 is set, ignore read settings.
    void deserialize(ReadBuffer & buf);

    /// Write changed settings to buffer. (For example, to be sent to remote server.)
    void serialize(WriteBuffer & buf) const;
};


}