// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***

using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Threading.Tasks;
using Pulumi.Serialization;

namespace Pulumi.Yandex.Outputs
{

    [OutputType]
    public sealed class GetMdbClickhouseClusterUserSettingsResult
    {
        /// <summary>
        /// Include CORS headers in HTTP responces.
        /// </summary>
        public readonly bool AddHttpCorsHeader;
        /// <summary>
        /// Allows or denies DDL queries.
        /// </summary>
        public readonly bool AllowDdl;
        /// <summary>
        /// Enable compilation of queries.
        /// </summary>
        public readonly bool Compile;
        /// <summary>
        /// Turn on expression compilation.
        /// </summary>
        public readonly bool CompileExpressions;
        /// <summary>
        /// Connect timeout in milliseconds on the socket used for communicating with the client.
        /// </summary>
        public readonly int ConnectTimeout;
        /// <summary>
        /// Specifies which of the uniq* functions should be used to perform the COUNT(DISTINCT …) construction.
        /// </summary>
        public readonly string CountDistinctImplementation;
        /// <summary>
        /// Sets behaviour on overflow when using DISTINCT. Possible values:
        /// </summary>
        public readonly string DistinctOverflowMode;
        /// <summary>
        /// Determine the behavior of distributed subqueries.
        /// </summary>
        public readonly bool DistributedAggregationMemoryEfficient;
        /// <summary>
        /// Timeout for DDL queries, in milliseconds.
        /// </summary>
        public readonly int DistributedDdlTaskTimeout;
        /// <summary>
        /// Changes the behaviour of distributed subqueries.
        /// </summary>
        public readonly string DistributedProductMode;
        /// <summary>
        /// Allows to retunr empty result.
        /// </summary>
        public readonly bool EmptyResultForAggregationByEmptySet;
        /// <summary>
        /// Enables or disables data compression in the response to an HTTP request.
        /// </summary>
        public readonly bool EnableHttpCompression;
        /// <summary>
        /// Forces a query to an out-of-date replica if updated data is not available.
        /// </summary>
        public readonly bool FallbackToStaleReplicasForDistributedQueries;
        /// <summary>
        /// Disables query execution if the index can’t be used by date.
        /// </summary>
        public readonly bool ForceIndexByDate;
        /// <summary>
        /// Disables query execution if indexing by the primary key is not possible.
        /// </summary>
        public readonly bool ForcePrimaryKey;
        /// <summary>
        /// Sets behaviour on overflow while GROUP BY operation. Possible values:
        /// </summary>
        public readonly string GroupByOverflowMode;
        /// <summary>
        /// Sets the threshold of the number of keys, after that the two-level aggregation should be used.
        /// </summary>
        public readonly int GroupByTwoLevelThreshold;
        /// <summary>
        /// Sets the threshold of the number of bytes, after that the two-level aggregation should be used.
        /// </summary>
        public readonly int GroupByTwoLevelThresholdBytes;
        /// <summary>
        /// Timeout for HTTP connection in milliseconds.
        /// </summary>
        public readonly int HttpConnectionTimeout;
        /// <summary>
        /// Sets minimal interval between notifications about request process in HTTP header X-ClickHouse-Progress.
        /// </summary>
        public readonly int HttpHeadersProgressInterval;
        /// <summary>
        /// Timeout for HTTP connection in milliseconds.
        /// </summary>
        public readonly int HttpReceiveTimeout;
        /// <summary>
        /// Timeout for HTTP connection in milliseconds.
        /// </summary>
        public readonly int HttpSendTimeout;
        /// <summary>
        /// When performing INSERT queries, replace omitted input column values with default values of the respective columns.
        /// </summary>
        public readonly bool InputFormatDefaultsForOmittedFields;
        /// <summary>
        /// Enables or disables the full SQL parser if the fast stream parser can’t parse the data.
        /// </summary>
        public readonly bool InputFormatValuesInterpretExpressions;
        /// <summary>
        /// Enables the quorum writes.
        /// </summary>
        public readonly int InsertQuorum;
        /// <summary>
        /// Write to a quorum timeout in milliseconds.
        /// </summary>
        public readonly int InsertQuorumTimeout;
        /// <summary>
        /// Sets behaviour on overflow in JOIN. Possible values:
        /// </summary>
        public readonly string JoinOverflowMode;
        /// <summary>
        /// Sets the type of JOIN behaviour. When merging tables, empty cells may appear. ClickHouse fills them differently based on this setting.
        /// </summary>
        public readonly bool JoinUseNulls;
        /// <summary>
        /// Require aliases for subselects and table functions in FROM that more than one table is present.
        /// </summary>
        public readonly bool JoinedSubqueryRequiresAlias;
        /// <summary>
        /// Allows or restricts using the LowCardinality data type with the Native format.
        /// </summary>
        public readonly bool LowCardinalityAllowInNativeFormat;
        /// <summary>
        /// Maximum abstract syntax tree depth.
        /// </summary>
        public readonly int MaxAstDepth;
        /// <summary>
        /// Maximum abstract syntax tree elements.
        /// </summary>
        public readonly int MaxAstElements;
        /// <summary>
        /// A recommendation for what size of the block (in a count of rows) to load from tables.
        /// </summary>
        public readonly int MaxBlockSize;
        /// <summary>
        /// Limit in bytes for using memoru for GROUP BY before using swap on disk.
        /// </summary>
        public readonly int MaxBytesBeforeExternalGroupBy;
        /// <summary>
        /// This setting is equivalent of the max_bytes_before_external_group_by setting, except for it is for sort operation (ORDER BY), not aggregation.
        /// </summary>
        public readonly int MaxBytesBeforeExternalSort;
        /// <summary>
        /// Limits the maximum size of a hash table in bytes (uncompressed data) when using DISTINCT.
        /// </summary>
        public readonly int MaxBytesInDistinct;
        /// <summary>
        /// Limit on maximum size of the hash table for JOIN, in bytes.
        /// </summary>
        public readonly int MaxBytesInJoin;
        /// <summary>
        /// Limit on the number of bytes in the set resulting from the execution of the IN section.
        /// </summary>
        public readonly int MaxBytesInSet;
        /// <summary>
        /// Limits the maximum number of bytes (uncompressed data) that can be read from a table when running a query.
        /// </summary>
        public readonly int MaxBytesToRead;
        /// <summary>
        /// Limits the maximum number of bytes (uncompressed data) that can be read from a table for sorting.
        /// </summary>
        public readonly int MaxBytesToSort;
        /// <summary>
        /// Limits the maximum number of bytes (uncompressed data) that can be passed to a remote server or saved in a temporary table when using GLOBAL IN.
        /// </summary>
        public readonly int MaxBytesToTransfer;
        /// <summary>
        /// Limits the maximum number of columns that can be read from a table in a single query.
        /// </summary>
        public readonly int MaxColumnsToRead;
        /// <summary>
        /// Limits the maximum query execution time in milliseconds.
        /// </summary>
        public readonly int MaxExecutionTime;
        /// <summary>
        /// Maximum abstract syntax tree depth after after expansion of aliases.
        /// </summary>
        public readonly int MaxExpandedAstElements;
        /// <summary>
        /// The size of blocks (in a count of rows) to form for insertion into a table.
        /// </summary>
        public readonly int MaxInsertBlockSize;
        /// <summary>
        /// Limits the maximum memory usage (in bytes) for processing queries on a single server.
        /// </summary>
        public readonly int MaxMemoryUsage;
        /// <summary>
        /// Limits the maximum memory usage (in bytes) for processing of user's queries on a single server.
        /// </summary>
        public readonly int MaxMemoryUsageForUser;
        /// <summary>
        /// Limits the speed of the data exchange over the network in bytes per second.
        /// </summary>
        public readonly int MaxNetworkBandwidth;
        /// <summary>
        /// Limits the speed of the data exchange over the network in bytes per second.
        /// </summary>
        public readonly int MaxNetworkBandwidthForUser;
        /// <summary>
        /// The maximum part of a query that can be taken to RAM for parsing with the SQL parser.
        /// </summary>
        public readonly int MaxQuerySize;
        /// <summary>
        /// Disables lagging replicas for distributed queries.
        /// </summary>
        public readonly int MaxReplicaDelayForDistributedQueries;
        /// <summary>
        /// Limits the number of bytes in the result.
        /// </summary>
        public readonly int MaxResultBytes;
        /// <summary>
        /// Limits the number of rows in the result.
        /// </summary>
        public readonly int MaxResultRows;
        /// <summary>
        /// Limits the maximum number of different rows when using DISTINCT.
        /// </summary>
        public readonly int MaxRowsInDistinct;
        /// <summary>
        /// Limit on maximum size of the hash table for JOIN, in rows.
        /// </summary>
        public readonly int MaxRowsInJoin;
        /// <summary>
        /// Limit on the number of rows in the set resulting from the execution of the IN section.
        /// </summary>
        public readonly int MaxRowsInSet;
        /// <summary>
        /// Limits the maximum number of unique keys received from aggregation function.
        /// </summary>
        public readonly int MaxRowsToGroupBy;
        /// <summary>
        /// Limits the maximum number of rows that can be read from a table when running a query.
        /// </summary>
        public readonly int MaxRowsToRead;
        /// <summary>
        /// Limits the maximum number of rows that can be read from a table for sorting.
        /// </summary>
        public readonly int MaxRowsToSort;
        /// <summary>
        /// Limits the maximum number of rows that can be passed to a remote server or saved in a temporary table when using GLOBAL IN.
        /// </summary>
        public readonly int MaxRowsToTransfer;
        /// <summary>
        /// Limits the maximum number of temporary columns that must be kept in RAM at the same time when running a query, including constant columns.
        /// </summary>
        public readonly int MaxTemporaryColumns;
        /// <summary>
        /// Limits the maximum number of temporary columns that must be kept in RAM at the same time when running a query, excluding constant columns.
        /// </summary>
        public readonly int MaxTemporaryNonConstColumns;
        /// <summary>
        /// The maximum number of query processing threads, excluding threads for retrieving data from remote servers.
        /// </summary>
        public readonly int MaxThreads;
        /// <summary>
        /// If ClickHouse should read more than merge_tree_max_bytes_to_use_cache bytes in one query, it doesn’t use the cache of uncompressed blocks.
        /// </summary>
        public readonly int MergeTreeMaxBytesToUseCache;
        /// <summary>
        /// If ClickHouse should read more than merge_tree_max_rows_to_use_cache rows in one query, it doesn’t use the cache of uncompressed blocks.
        /// </summary>
        public readonly int MergeTreeMaxRowsToUseCache;
        /// <summary>
        /// If the number of bytes to read from one file of a MergeTree-engine table exceeds merge_tree_min_bytes_for_concurrent_read, then ClickHouse tries to concurrently read from this file in several threads.
        /// </summary>
        public readonly int MergeTreeMinBytesForConcurrentRead;
        /// <summary>
        /// If the number of rows to be read from a file of a MergeTree table exceeds merge_tree_min_rows_for_concurrent_read then ClickHouse tries to perform a concurrent reading from this file on several threads.
        /// </summary>
        public readonly int MergeTreeMinRowsForConcurrentRead;
        /// <summary>
        /// The minimum data volume required for using direct I/O access to the storage disk.
        /// </summary>
        public readonly int MinBytesToUseDirectIo;
        /// <summary>
        /// How many times to potentially use a compiled chunk of code before running compilation.
        /// </summary>
        public readonly int MinCountToCompile;
        /// <summary>
        /// A query waits for expression compilation process to complete prior to continuing execution.
        /// </summary>
        public readonly int MinCountToCompileExpression;
        /// <summary>
        /// Minimal execution speed in rows per second.
        /// </summary>
        public readonly int MinExecutionSpeed;
        /// <summary>
        /// Minimal execution speed in bytes per second.
        /// </summary>
        public readonly int MinExecutionSpeedBytes;
        /// <summary>
        /// Sets the minimum number of bytes in the block which can be inserted into a table by an INSERT query.
        /// </summary>
        public readonly int MinInsertBlockSizeBytes;
        /// <summary>
        /// Sets the minimum number of rows in the block which can be inserted into a table by an INSERT query.
        /// </summary>
        public readonly int MinInsertBlockSizeRows;
        /// <summary>
        /// If the value is true, integers appear in quotes when using JSON* Int64 and UInt64 formats (for compatibility with most JavaScript implementations); otherwise, integers are output without the quotes.
        /// </summary>
        public readonly bool OutputFormatJsonQuote64bitIntegers;
        /// <summary>
        /// Enables +nan, -nan, +inf, -inf outputs in JSON output format.
        /// </summary>
        public readonly bool OutputFormatJsonQuoteDenormals;
        /// <summary>
        /// Query priority.
        /// </summary>
        public readonly int Priority;
        /// <summary>
        /// Quota accounting mode.
        /// </summary>
        public readonly string QuotaMode;
        /// <summary>
        /// Sets behaviour on overflow while read. Possible values:
        /// </summary>
        public readonly string ReadOverflowMode;
        /// <summary>
        /// Restricts permissions for reading data, write data and change settings queries.
        /// </summary>
        public readonly int Readonly;
        /// <summary>
        /// Receive timeout in milliseconds on the socket used for communicating with the client.
        /// </summary>
        public readonly int ReceiveTimeout;
        /// <summary>
        /// For ALTER ... ATTACH|DETACH|DROP queries, you can use the replication_alter_partitions_sync setting to set up waiting.
        /// </summary>
        public readonly int ReplicationAlterPartitionsSync;
        /// <summary>
        /// Sets behaviour on overflow in result. Possible values:
        /// </summary>
        public readonly string ResultOverflowMode;
        /// <summary>
        /// Enables or disables sequential consistency for SELECT queries.
        /// </summary>
        public readonly bool SelectSequentialConsistency;
        /// <summary>
        /// Enables or disables X-ClickHouse-Progress HTTP response headers in clickhouse-server responses.
        /// </summary>
        public readonly bool SendProgressInHttpHeaders;
        /// <summary>
        /// Send timeout in milliseconds on the socket used for communicating with the client.
        /// </summary>
        public readonly int SendTimeout;
        /// <summary>
        /// Sets behaviour on overflow in the set resulting. Possible values:
        /// </summary>
        public readonly string SetOverflowMode;
        /// <summary>
        /// Enables or disables silently skipping of unavailable shards.
        /// </summary>
        public readonly bool SkipUnavailableShards;
        /// <summary>
        /// Sets behaviour on overflow while sort. Possible values:
        /// </summary>
        public readonly string SortOverflowMode;
        /// <summary>
        /// Sets behaviour on overflow. Possible values:
        /// </summary>
        public readonly string TimeoutOverflowMode;
        /// <summary>
        /// Sets behaviour on overflow. Possible values:
        /// </summary>
        public readonly string TransferOverflowMode;
        /// <summary>
        /// Enables equality of NULL values for IN operator.
        /// </summary>
        public readonly bool TransformNullIn;
        /// <summary>
        /// Whether to use a cache of uncompressed blocks.
        /// </summary>
        public readonly bool UseUncompressedCache;

        [OutputConstructor]
        private GetMdbClickhouseClusterUserSettingsResult(
            bool addHttpCorsHeader,

            bool allowDdl,

            bool compile,

            bool compileExpressions,

            int connectTimeout,

            string countDistinctImplementation,

            string distinctOverflowMode,

            bool distributedAggregationMemoryEfficient,

            int distributedDdlTaskTimeout,

            string distributedProductMode,

            bool emptyResultForAggregationByEmptySet,

            bool enableHttpCompression,

            bool fallbackToStaleReplicasForDistributedQueries,

            bool forceIndexByDate,

            bool forcePrimaryKey,

            string groupByOverflowMode,

            int groupByTwoLevelThreshold,

            int groupByTwoLevelThresholdBytes,

            int httpConnectionTimeout,

            int httpHeadersProgressInterval,

            int httpReceiveTimeout,

            int httpSendTimeout,

            bool inputFormatDefaultsForOmittedFields,

            bool inputFormatValuesInterpretExpressions,

            int insertQuorum,

            int insertQuorumTimeout,

            string joinOverflowMode,

            bool joinUseNulls,

            bool joinedSubqueryRequiresAlias,

            bool lowCardinalityAllowInNativeFormat,

            int maxAstDepth,

            int maxAstElements,

            int maxBlockSize,

            int maxBytesBeforeExternalGroupBy,

            int maxBytesBeforeExternalSort,

            int maxBytesInDistinct,

            int maxBytesInJoin,

            int maxBytesInSet,

            int maxBytesToRead,

            int maxBytesToSort,

            int maxBytesToTransfer,

            int maxColumnsToRead,

            int maxExecutionTime,

            int maxExpandedAstElements,

            int maxInsertBlockSize,

            int maxMemoryUsage,

            int maxMemoryUsageForUser,

            int maxNetworkBandwidth,

            int maxNetworkBandwidthForUser,

            int maxQuerySize,

            int maxReplicaDelayForDistributedQueries,

            int maxResultBytes,

            int maxResultRows,

            int maxRowsInDistinct,

            int maxRowsInJoin,

            int maxRowsInSet,

            int maxRowsToGroupBy,

            int maxRowsToRead,

            int maxRowsToSort,

            int maxRowsToTransfer,

            int maxTemporaryColumns,

            int maxTemporaryNonConstColumns,

            int maxThreads,

            int mergeTreeMaxBytesToUseCache,

            int mergeTreeMaxRowsToUseCache,

            int mergeTreeMinBytesForConcurrentRead,

            int mergeTreeMinRowsForConcurrentRead,

            int minBytesToUseDirectIo,

            int minCountToCompile,

            int minCountToCompileExpression,

            int minExecutionSpeed,

            int minExecutionSpeedBytes,

            int minInsertBlockSizeBytes,

            int minInsertBlockSizeRows,

            bool outputFormatJsonQuote64bitIntegers,

            bool outputFormatJsonQuoteDenormals,

            int priority,

            string quotaMode,

            string readOverflowMode,

            int @readonly,

            int receiveTimeout,

            int replicationAlterPartitionsSync,

            string resultOverflowMode,

            bool selectSequentialConsistency,

            bool sendProgressInHttpHeaders,

            int sendTimeout,

            string setOverflowMode,

            bool skipUnavailableShards,

            string sortOverflowMode,

            string timeoutOverflowMode,

            string transferOverflowMode,

            bool transformNullIn,

            bool useUncompressedCache)
        {
            AddHttpCorsHeader = addHttpCorsHeader;
            AllowDdl = allowDdl;
            Compile = compile;
            CompileExpressions = compileExpressions;
            ConnectTimeout = connectTimeout;
            CountDistinctImplementation = countDistinctImplementation;
            DistinctOverflowMode = distinctOverflowMode;
            DistributedAggregationMemoryEfficient = distributedAggregationMemoryEfficient;
            DistributedDdlTaskTimeout = distributedDdlTaskTimeout;
            DistributedProductMode = distributedProductMode;
            EmptyResultForAggregationByEmptySet = emptyResultForAggregationByEmptySet;
            EnableHttpCompression = enableHttpCompression;
            FallbackToStaleReplicasForDistributedQueries = fallbackToStaleReplicasForDistributedQueries;
            ForceIndexByDate = forceIndexByDate;
            ForcePrimaryKey = forcePrimaryKey;
            GroupByOverflowMode = groupByOverflowMode;
            GroupByTwoLevelThreshold = groupByTwoLevelThreshold;
            GroupByTwoLevelThresholdBytes = groupByTwoLevelThresholdBytes;
            HttpConnectionTimeout = httpConnectionTimeout;
            HttpHeadersProgressInterval = httpHeadersProgressInterval;
            HttpReceiveTimeout = httpReceiveTimeout;
            HttpSendTimeout = httpSendTimeout;
            InputFormatDefaultsForOmittedFields = inputFormatDefaultsForOmittedFields;
            InputFormatValuesInterpretExpressions = inputFormatValuesInterpretExpressions;
            InsertQuorum = insertQuorum;
            InsertQuorumTimeout = insertQuorumTimeout;
            JoinOverflowMode = joinOverflowMode;
            JoinUseNulls = joinUseNulls;
            JoinedSubqueryRequiresAlias = joinedSubqueryRequiresAlias;
            LowCardinalityAllowInNativeFormat = lowCardinalityAllowInNativeFormat;
            MaxAstDepth = maxAstDepth;
            MaxAstElements = maxAstElements;
            MaxBlockSize = maxBlockSize;
            MaxBytesBeforeExternalGroupBy = maxBytesBeforeExternalGroupBy;
            MaxBytesBeforeExternalSort = maxBytesBeforeExternalSort;
            MaxBytesInDistinct = maxBytesInDistinct;
            MaxBytesInJoin = maxBytesInJoin;
            MaxBytesInSet = maxBytesInSet;
            MaxBytesToRead = maxBytesToRead;
            MaxBytesToSort = maxBytesToSort;
            MaxBytesToTransfer = maxBytesToTransfer;
            MaxColumnsToRead = maxColumnsToRead;
            MaxExecutionTime = maxExecutionTime;
            MaxExpandedAstElements = maxExpandedAstElements;
            MaxInsertBlockSize = maxInsertBlockSize;
            MaxMemoryUsage = maxMemoryUsage;
            MaxMemoryUsageForUser = maxMemoryUsageForUser;
            MaxNetworkBandwidth = maxNetworkBandwidth;
            MaxNetworkBandwidthForUser = maxNetworkBandwidthForUser;
            MaxQuerySize = maxQuerySize;
            MaxReplicaDelayForDistributedQueries = maxReplicaDelayForDistributedQueries;
            MaxResultBytes = maxResultBytes;
            MaxResultRows = maxResultRows;
            MaxRowsInDistinct = maxRowsInDistinct;
            MaxRowsInJoin = maxRowsInJoin;
            MaxRowsInSet = maxRowsInSet;
            MaxRowsToGroupBy = maxRowsToGroupBy;
            MaxRowsToRead = maxRowsToRead;
            MaxRowsToSort = maxRowsToSort;
            MaxRowsToTransfer = maxRowsToTransfer;
            MaxTemporaryColumns = maxTemporaryColumns;
            MaxTemporaryNonConstColumns = maxTemporaryNonConstColumns;
            MaxThreads = maxThreads;
            MergeTreeMaxBytesToUseCache = mergeTreeMaxBytesToUseCache;
            MergeTreeMaxRowsToUseCache = mergeTreeMaxRowsToUseCache;
            MergeTreeMinBytesForConcurrentRead = mergeTreeMinBytesForConcurrentRead;
            MergeTreeMinRowsForConcurrentRead = mergeTreeMinRowsForConcurrentRead;
            MinBytesToUseDirectIo = minBytesToUseDirectIo;
            MinCountToCompile = minCountToCompile;
            MinCountToCompileExpression = minCountToCompileExpression;
            MinExecutionSpeed = minExecutionSpeed;
            MinExecutionSpeedBytes = minExecutionSpeedBytes;
            MinInsertBlockSizeBytes = minInsertBlockSizeBytes;
            MinInsertBlockSizeRows = minInsertBlockSizeRows;
            OutputFormatJsonQuote64bitIntegers = outputFormatJsonQuote64bitIntegers;
            OutputFormatJsonQuoteDenormals = outputFormatJsonQuoteDenormals;
            Priority = priority;
            QuotaMode = quotaMode;
            ReadOverflowMode = readOverflowMode;
            Readonly = @readonly;
            ReceiveTimeout = receiveTimeout;
            ReplicationAlterPartitionsSync = replicationAlterPartitionsSync;
            ResultOverflowMode = resultOverflowMode;
            SelectSequentialConsistency = selectSequentialConsistency;
            SendProgressInHttpHeaders = sendProgressInHttpHeaders;
            SendTimeout = sendTimeout;
            SetOverflowMode = setOverflowMode;
            SkipUnavailableShards = skipUnavailableShards;
            SortOverflowMode = sortOverflowMode;
            TimeoutOverflowMode = timeoutOverflowMode;
            TransferOverflowMode = transferOverflowMode;
            TransformNullIn = transformNullIn;
            UseUncompressedCache = useUncompressedCache;
        }
    }
}
