The name of the cluster. This setting prevents nodes in one logical cluster from joining another. All nodes in a cluster must have the same value.

The IP address or hostname that the database binds to for connecting this node to other nodes.

The interface that the database binds to for connecting to other nodes. Interfaces must correspond to a single address. IP aliasing is not supported.

Use IPv4 or IPv6 when interface is specified by name.

When only a single address is used, that address is selected without regard to this setting.

The directory where table data is stored on disk. The database distributes data evenly across the location, subject to the granularity of the configured compaction strategy.

The directory where the commit log is stored.

The directory where the change data capture (CDC) commit log segments are stored on flush. DataStax recommends a physical device that is separate from the data directories. See Change Data Capture (CDC) logging.

The directory in which hints are stored.

The metadata directory that holds information about the cluster, the local node and its peers.

The directory location where table key and row caches are stored.

Policy for commit disk failures:

The strategy for optimizing disk reads.

How the database responds to disk failure. Recommend settings: stop or best_effort.

A class that implements the IEndpointSnitch interface. The database uses the snitch to locate nodes and route requests.

The addresses of hosts that are designated as contact points in the cluster. A joining node contacts one of the nodes in the -seeds list to learn the topology of the ring.

The MB per second to throttle compaction for the entire system. The faster the database inserts data, the faster the system must compact in order to keep the SSTable count down.

Total permitted memory to use for memtables. When this threshold is exceeded, writes are not accepted until a flush completes. A flush is triggered based on memtable_cleanup_threshold. When not set:

Ratio used for automatic memtable flush.

The method the database uses to allocate and manage memtable memory.

The number of memtable flush writer threads per disk and the total number of memtables that can be flushed concurrently, generally a combination of computer and I/O bound. Memtable flushing is more CPU efficient than memtable ingest. A single thread can keep up with the ingest rate of a server on a single fast disk, until the server temporarily becomes IO bound under contention, typically with compaction. Generally, the default value is appropriate and does not need adjusting. However, you may need to increase the number of memtable_flush_writers if you observe slow performance with write operations.

Enables incremental backups.

Enables a snapshot before each compaction. A snapshot is useful to back up data when there is a data format change.

When enabled, every time the user drops a column/columns from a table, a snapshot is created on each node in the cluster before the change in schema is applied. Those snapshots have the same name on each node. For example: auto-snapshot_drop-column-<columnname>_20200515143511000. The name includes the name of the dropped column and the timestamp (UTC) when the column was dropped.

Use with commitlog_sync: periodic. Time interval between syncing the commit log to disk. Periodic syncs are acknowledged immediately.

Use with commitlog_sync: group. The time that the database waits between flushing the commit log to disk. DataStax recommends using group instead of batch.

Deprecated. Use with commitlog_sync: batch. The maximum time that queries may be batched together.

The size of an individual commitlog file segment. A commitlog segment may be archived, deleted, or recycled after all its data has been flushed to SSTables. This data can potentially include commitlog segments from every table in the system. The default size is usually suitable, but for commitlog archiving you might want a finer granularity; 8 or 16 MB is reasonable.

2 * max_mutation_size_in_kb / 1024

The maximum size of a mutation before the mutation is rejected. Before increasing the commitlog segment size of the commitlog segments, investigate why the mutations are larger than expected. Look for underlying issues with access patterns and data model, because increasing the commitlog segment size is a limited fix.

Disk usage threshold for commit logs before triggering the database flushing memtables to disk. If the total space used by all commit logs exceeds this threshold, the database flushes memtables to disk for the oldest commitlog segments to reclaim disk space by removing those log segments from the commit log. This flushing reduces the amount of data to replay on start-up, and prevents infrequently updated tables from keeping commitlog segments indefinitely. If the commitlog_total_space_in_mb is small, the result is more flush activity on less-active tables.

The compressor to use if commit log is compressed. To make changes, uncomment the commitlog_compression section and make changes to these options:

# commitlog_compression:
#   - class_name: LZ4Compressor
#     parameters:
#         -

Maximum number of permitted concurrent lightweight transactions (LWT).

Maximum number of lightweight transactions (LWT) in the queue before node reports OverloadedException for LWTs.

Enables change data capture (CDC) functionality on a per-node basis. This modifies the logic used for write path allocation rejection.

Total space to use for change-data-capture (CDC) logs on disk. If space allocated for CDC exceeds this value, the database throws WriteTimeoutException on mutations, including CDC-enabled tables. A CDCCompactor (a consumer) is responsible for parsing the raw CDC logs and deleting them when parsing is completed.

Interval between checks for new available space for CDC-tracked tables when the cdc_total_space_in_mb threshold is reached and the CDCCompactor is running behind or experiencing back pressure.

The number of concurrent compaction processes allowed to run simultaneously on a node, not including validation compactions for anti-entropy repair. Simultaneous compactions help preserve read performance in a mixed read-write workload by limiting the number of small SSTables that accumulate during a single long-running compaction. If your data directories are backed by SSDs, increase this value to the number of cores. If compaction running too slowly or too fast, adjust compaction_throughput_mb_per_sec first.

Configures simultaneous repair validations.

Number of simultaneous materialized view builder tasks allowed to run concurrently. When a view is created, the node ranges are split into (num_processors x 4) builder tasks and submitted to this executor.

The size of the SSTables to trigger preemptive opens. The compaction process opens SSTables before they are completely written and uses them in place of the prior SSTables for any range previously written. This process helps to smoothly transfer reads between the SSTables by reducing cache churn and keeps hot rows hot.

The compaction level for streamed-in SSTables.

Granularity of the index of rows within a partition. For huge rows, decrease this setting to improve seek time. Lower density nodes might benefit from decreasing this value to 4, 2, or 1.

Buffer pool is split into two pools, this setting defines the maximum memory to use file buffers that are stored in the file cache, also known as chunk cache. Memory is allocated only when needed but is not released. The other buffer pool is direct_reads_size_in_mb.

Buffer pool is split into two pools; this setting defines the buffer pool for transient read operations. A buffer is typically used by a read operation and then returned to this pool when the operation is finished so that it can be reused by other operations. The other buffer pool is file_cache_size_in_mb.

Max amount of time to wait before the inbound channel times out. Set this value to Long.MAX_VALUE when streaming large data, which effectively disables this timeout. Configure this value to a lower value when factors such as SSTable size and network latency change.

Throttle for all streaming file transfers between datacenters, and for network stream traffic as configured with stream_throughput_outbound_megabits_per_sec. When not set, the value is 200 Mbps.

Interval to send keep-alive messages to prevent reset connections during streaming. The stream session fails when a keep-alive message is not received for two keep-alive cycles. A stalled stream times out in ten minutes.

Maximum amount of pending data written before pausing outbound streaming. This value is shared among all outbound streaming session to cap the overall memory used by all streaming processes, such as bootstrap and repair.

Buffer size for stream writes. Each outbound streaming session buffers writes according to this size.

Maximum size for the outbound streaming buffer when sending data to another node. For large data, set this value to 8 MB to reduce the probability of a timeout. A reduced value allows data to stream faster than waiting for a 128 MB buffer to be reached.

Throttle for the throughput of all outbound streaming file transfers on a node. When streaming data during bootstrap or repair, the database does mostly sequential I/O, which can saturate the network connection and degrade client (RPC) performance.

Enable zero-copy streaming of SSTables and their components. For each SSTable to stream, only the required ranges are actually streamed as separate SSTables, while the SSTable metadata is streamed in its entirety and linked to every SSTable produced on the destination node, avoiding the costly rebuilding of such metadata at the expense of additional disk usage (see zerocopy_max_unused_metadata_in_mb). All SSTables and their components are also copied via zero-copy operations, greatly reducing GC pressure and improving overall speed.

Number of megabytes per SSTable of excess metadata allowed in order to use zero-copy rather than legacy streaming.

Maximum number of SSTables a single SStable can be split into when using zero-copy rather than legacy streaming.

Buffer size for stream writes. Each outbound streaming session will buffer writes according to this size.

Max amount of pending data written before pausing outbound streaming. This value is shared among all outbound streaming session, in order to cap the overall memory used by all streaming processes (bootstrap, repair, etc.).

When set to true, causes fsync to force the operating system to flush the dirty buffers at the set interval trickle_fsync_interval_in_kb. Enable this parameter to prevent sudden dirty buffer flushing from impacting read latencies. Recommended for use with SSDs, but not with HDDs.

The size of the fsync in kilobytes.

The maximum size of any value in SSTables. SSTables are marked as corrupted when the threshold is exceeded.

The number of concurrent CoreThreads. The CoreThreads are the main workers in a DSE 6.x node, and process various asynchronous tasks from their queue. If not set, the default is the number of cores (processors on the machine) minus one. Note that configuring tpc_cores affects the default value for tpc_io_cores.

The subset of tpc_cores that process asynchronous IO tasks. (That is, disk reads.) Must be smaller or equal to tpc_cores. Lower this value to decrease parallel disk IO requests.

Global IO queue depth used for reads when AIO is enabled, which is the default for SSDs. The optimal queue depth as found with the fio tool for a given disk setup.

The maximum bytes per second for data validation on the local node. The optimum validation rate for each node may vary.

How long the coordinator waits for read operations to complete before timing it out.

How long the coordinator waits for sequential or index scans to complete before timing it out.

How long the coordinator waits for sequential or index scans to complete. Lowest acceptable value is 10 ms. This timeout does not apply to aggregated queries such as SELECT, COUNT(*), MIN(x), and so on.

How long the coordinator waits for write requests to complete with at least one node in the local datacenter. Lowest acceptable value is 10 ms.

How long the coordinator waits for counter writes to complete before timing it out.

How long the coordinator continues to retry a CAS (compare and set) operation that contends with other proposals for the same row. If the coordinator cannot complete the operation within this timespan, it aborts the operation.

How long the coordinator waits for a truncate (the removal of all data from a table) to complete before timing it out. The long default value allows the database to take a snapshot before removing the data. If auto_snapshot is disabled (not recommended), you can reduce this time.

The default timeout value for other miscellaneous operations. Lowest acceptable value is 10 ms.

How much to increase the cross-datacenter timeout (write_request_timeout_in_ms + cross_dc_rtt_in_ms) for requests that involve only nodes in a remote datacenter. This setting is intended to reduce hint pressure.

The time of a slow query. Queries that exceed this value generate an aggregated log message to identify slow queries.

The port for internode communication. Follow security best practices, do not expose this port to the internet. Apply firewall rules.

Enables operation timeout information exchange between nodes to accurately measure request timeouts.

The sending socket buffer size, in bytes, for internode calls.

The receiving socket buffer size in bytes for internode calls.

Enables compressing traffic between nodes

Enables tcp_nodelay for inter-datacenter communication.

Enables or disables the native transport server.

The port where the CQL native transport listens for clients. For security reasons, do not expose this port to the internet. Firewall it if needed.

The maximum allowed size of a frame. Frame (requests) larger than this are rejected as invalid.

The maximum number of concurrent client connections.

The maximum number of concurrent client connections per source IP address.

Honor older protocol versions.

When left blank, uses the configured hostname of the node. Unlike the listen_address, this value can be set to 0.0.0.0, but you must set the native_transport_broadcast_address to a value other than 0.0.0.0.

IP aliasing is not supported.

Use IPv4 or IPv6 when interface is specified by name.

When only a single address is used, that address is selected without regard to this setting.

Native transport address to broadcast to drivers and other DSE nodes. This cannot be set to 0.0.0.0.

Enables keepalive on native connections.

The threshold for log messages at the INFO level. Adjust to minimize logging.

Threshold for GC pause. Any GC pause longer than this interval is logged at the WARN level. By default, the database logs any GC pause greater than 200 ms at the INFO level.

Strategy to combine multiple network messages into a single packet for outbound TCP connections to nodes in the same data center. See the DataStax Developer Blog post Performance doubling with message coalescing.

How many microseconds to wait for coalescing messages to nodes in the same datacenter.

The threshold for the number of messages to nodes in the same data center. Do not coalesce messages when this value is exceeded. Should be more than 2 and less than 128.

Size in KB of the direct buffer used to write messages to large outbound internode connections (one for every node in the cluster per connection type). Messages larger than this buffer will require the allocation of a new buffer, so it should be large enough to accommodate the average message size (and possibly more, to allow for batch flushing), but not too large, to avoid running out of memory.

Size in KB of the direct buffer used to write messages to small outbound internode connections (one for every node in the cluster per connection type).

The percentage of time that gossip messages are sent to a seed node during each round of gossip. Decreases the time to propagate gossip changes across the cluster.

Enables for the coordinator to apply the specified back pressure strategy to each mutation that is sent to replicas.

To add new strategies, implement org.apache.cassandra.net.BackpressureStrategy and provide a public constructor that accepts a Map<String, Object>.

The default class_name uses the ratio between incoming mutation responses and outgoing mutation requests.

When outgoing mutations are below this value, they are rate limited according to the incoming rate decreased by the factor (described below). When above this value, the rate limiting is increased by the factor.

A number between 1 and 10. When backpressure is below high ratio, outgoing mutations are rate limited according to the incoming rate decreased by the given factor; if above high ratio, the rate limiting is increased by the given factor.

The flow speed to apply rate limiting:

The performance threshold for dynamically routing client requests away from a poorly performing node. Specifically, it controls how much worse a poorly performing node has to be before the dynamic snitch prefers other replicas. A value of 0.2 means the database continues to prefer the static snitch values until the node response time is 20% worse than the best performing node. Until the threshold is reached, incoming requests are statically routed to the closest replica as determined by the snitch.

Time interval after which the database resets all node scores to allow a bad node to recover.

The time interval, in milliseconds, between the calculation of node scores. Because score calculation is CPU intensive, be careful when reducing this interval.

Enables hinted handoff. A hint indicates that the write needs to be replayed to an unavailable node. The database writes the hint to a hints file on the coordinator node.

A blacklist of datacenters that will not perform hinted handoffs. To disable hinted handoff on a certain datacenter, add its name to this list.

Maximum amount of time during which the database generates hints for an unresponsive node. After this interval, the database does not generate any new hints for the node until it is back up and responsive. If the node goes down again, the database starts a new interval. This setting can prevent a sudden demand for resources when a node is brought back online and the rest of the cluster attempts to replay a large volume of hinted writes.

Maximum amount of traffic per delivery thread in kilobytes per second. This rate reduces proportionally to the number of nodes in the cluster. For example, if there are two nodes in the cluster, each delivery thread uses. the maximum rate. If there are three, each node throttles to half of the maximum, since the two nodes are expected to deliver hints simultaneously.

The time, in milliseconds, to wait before flushing hints from internal buffers to disk.

Number of threads the database uses to deliver hints. In multiple datacenter deployments, consider increasing this number because cross datacenter handoff is generally slower.

The maximum size for a single hints file, in megabytes.

The compressor for hint files. Supported compressors: LZ, Snappy, and Deflate. When not set, the database does not compress hints files.

Total maximum throttle, in KB per second, for replaying hints. Throttling is reduced proportionally to the number of nodes in the cluster

Strategy to choose the batchlog storage endpoints.

The authentication backend. The only supported authenticator is DseAuthenticator for external authentication with multiple authentication schemes such as Kerberos, LDAP, and internal authentication. Authenticators other than DseAuthenticator are deprecated and not supported. Some security features might not work correctly if other authenticators are used. See authentication_options in dse.yaml.

Internode authentication backend to enable secure connections from peer nodes.

The authorization backend. Authorizers other than DseAuthorizer are not supported. DseAuthorizer supports enhanced permission management of DSE-specific resources. Authorizers other than DseAuthorizer are deprecated and not supported. Some security features might not work correctly if other authorizers are used. See dse-yaml.adoc#authorizationOptions in dse.yaml.

Enables system keyspace filtering so that users can access and view only schema information for rows in the system and system_schema keyspaces to which they have access.

Attention: Security requirements and user permissions apply. Enable this feature only after appropriate user permissions are granted. You must grant the DESCRIBE permission to the role on any keyspaces stored in the system keyspaces. If you do not grant the permission, you will see an error that states the keyspace is not found.

GRANT DESCRIBE ON KEYSPACE <keyspace_name> TO ROLE <role_name>;

The DSE Role Manager supports LDAP roles and internal roles supported by the CassandraRoleManager. Role options are stored in the dse_security keyspace. When using the DSE Role Manager, increase the replication factor of the dse_security keyspace. Role managers other than DseRoleManager are deprecated and not supported. Some security features might not work correctly if other role managers are used.

Validity period for roles cache in milliseconds. Determines how long to cache the list of roles assigned to the user; users may have several roles, either through direct assignment or inheritance (a role that has been granted to another role). Adjust this setting based on the complexity of your role hierarchy, tolerance for role changes, the number of nodes in your environment, and activity level of the cluster.

Refresh interval for roles cache. After this interval, cache entries become eligible for refresh. On next access, the database schedules an async reload, and returns the old value until the reload completes. If roles_validity_in_ms is non-zero, then this value must also be non-zero. When not set, the default is the same value as roles_validity_in_ms.

How long permissions in cache remain valid to manage performance impact of permissions queries. Fetching permissions can be resource intensive. Set the cache validity period to your security tolerances. The cache is used for the standard authentication and the row-level access control (RLAC) cache. The cache is quite effective at small durations.

Refresh interval for the standard authentication cache and the row-level access control (RLAC) cache. After this interval, cache entries become eligible for refresh. On next access, the database schedules an async reload and returns the old value until the reload completes. If permissions_validity_in_ms is non-zero, the value for roles_update_interval_in_ms must also be non-zero. When not set, the default is the same value as permissions_validity_in_ms.

The maximum number of entries that are held by the standard authentication cache and row-level access control (RLAC) cache. With the default value of 1000, the RLAC permissions cache can have up to 1000 entries in it, and the standard authentication cache can have up to 1000 entries. This single option applies to both caches. To size the permissions cache for use with Setting up Row Level Access Control (RLAC), use this formula:

<numRlacUsers> * <numRlacTables> + 100

Internode encryption options. If enabled, you must also generate keys and provide the appropriate key and truststore locations and passwords. No custom encryption options are supported.

Encryption options for of internode communication using the TLS_RSA_WITH_AES_128_CBC_SHA cipher suite for authentication, key exchange, and encryption of data transfers. Use the DHE/ECDHE ciphers, such as TLS_DHE_RSA_WITH_AES_128_CBC_SHA if running in Federal Information Processing Standard (FIPS) 140 compliant mode.

Relative path from DSE installation directory or absolute path to the Java keystore (JKS) suitable for use with Java Secure Socket Extension (JSSE), which is the Java version of the Secure Sockets Layer (SSL), and Transport Layer Security (TLS) protocols. The keystore contains the private key used to encrypt outgoing messages.

Password for the keystore. This must match the password used when generating the keystore and truststore.

Relative path from DSE installation directory or absolute path to truststore containing the trusted certificate for authenticating remote servers.

Password for the truststore.

Default: TLS

Default: SunX509

Valid types are JKS, JCEKS, PKCS11, or PKCS12. For file-based keystores, use PKCS12.

Valid types are JKS, JCEKS, PKCS12. For file-based truststores, use PKCS12.

openssl pkcs12 -export -nokeys -out truststore.pfx -in <intermediate.chain.pem>

keytool -importcert -alias <rootca> -file <rootca.pem> -keystore <truststore.jks>

keytool -importcert -alias <intermediate> -file <intermediate.pem> -keystore <truststore.jks>

keytool -importkeystore -srckeystore <truststore.jks> -destkeystore <truststore.pfx> -deststoretype pkcs12

Supported ciphers:

Enables certificate authentication for node-to-node (internode) encryption.

Whether to verify the connected host and the host IP address in the certificate match. If set to true, the endpoint that you specify when generating the certificate key must be an IP address. Do not specify a DNS hostname. Example with a correctly specified IP address:

keytool -genkeypair -keyalg RSA \
    -alias node0 \
    -keystore my_keystore.jks \
    -storepass cassandra \
    -keypass cassandra \
    -validity 730 \
    -keysize 2048 \
    -dname "CN=node0, OU=lacerda-ssl, O=Datastax, C=CC" \
    -ext "san=ip:10.101.35.236"

Enables client-to-node encryption. You must also generate keys and provide the appropriate key and truststore locations and passwords. There are no custom encryption options enabled for DataStax Enterprise.

Enables client-to-node encryption.

When optional is selected, both encrypted and unencrypted connections over native transport are allowed. That is a necessary transition state to facilitate enabling client to node encryption on live clusters without inducing an outage for existing unencrypted clients. Typically, once existing clients are migrated to encrypted connections, optional is unselected in order to enforce native transport encryption.

Relative path from DSE installation directory or absolute path to the Java keystore (JKS) suitable for use with Java Secure Socket Extension (JSSE), which is the Java version of the Secure Sockets Layer (SSL), and Transport Layer Security (TLS) protocols. The keystore contains the private key used to encrypt outgoing messages.

Password for the keystore.

Enables certificate authentication for client-to-node encryption.

Relative path from DSE installation directory or absolute path to truststore containing the trusted certificate for authenticating remote servers.

Password for the truststore. This must match the password used when generating the keystore and truststore.

Default: TLS

Default: SunX509

Valid types are JKS, JCEKS, PKCS11, or PKCS12. For file-based keystores, use PKCS12.

Valid types are JKS, JCEKS, or PKCS12. For file-based truststores, use PKCS12.

Supported ciphers:

DataStax Enterprise supports this option only for backward compatibility. When using DSE, configure data encryption options in the dse.yaml; see Transparent data encryption.

The SSL port for encrypted communication. Unused unless enabled in encryption_options. Follow security best practices, do not expose this port to the internet. Apply firewall rules.

Dedicated SSL port where the CQL native transport listens for clients with encrypted communication. For security reasons, do not expose this port to the internet. Firewall it if needed.

Enables user defined functions (UDFs), code that is executed inside Cassandra daemons. UDFs can present a security risk, since they are executed on the server side. UDFs are executed in a sandbox to control what code can be executed. See the DataStax blog post User Defined Functions.

Enables the use of JavaScript language in UDFs. Scripted UDFs are less performant than UDFs and produce more garbage on the heap.

Enables sandbox for asynchronous JavaScript UDF execution. Does not apply to Java UDFs.

Threshold in microseconds (CPU time). When a UDF runs too long and this threshold is exceeded, a warning is logged and sent to the client. Java UDFs always issue a warning. Scripted UDFs log a warning only if enable_user_defined_functions_threads is set to true.

Threshold in microseconds (CPU time). When a fatal UDF run-time situation is detected and this threshold is exceeded, the UDF is stopped. Java UDFs always throw an exception and stop. Scripted UDFs throw an exception and stop only if enable_user_defined_functions_threads is set to true.

Threshold in MB for heap allocations. When this threshold is exceeded, a warning is logged and sent to the client. Java UDFs always issue a warning. Scripted UDFs log a warning only if enable_user_defined_functions_threads is set to true.

Threshold in MB for heap allocations. When this threshold is exceeded, the UDF is stopped.

Defines action when a scripted UDF exceeds user_defined_function_fail_micros threshold. Applies only when enable_user_defined_functions_threads is set to true.

Tunes continuous paging that pushes pages, when requested, continuously to the client:

The maximum number of concurrent sessions. Additional sessions are rejected with an unavailable error.

The maximum number of pages that can be buffered for each session. If the client is not reading from the socket, the producer thread is blocked after it has prepared max_session_pages.

The maximum size of a page, in MB. If an individual CQL row is larger than this value, the page can be larger than this value.

The maximum time for a local continuous query to run. When this threshold is exceeded, the session is swapped out and rescheduled. Swapping and rescheduling ensures the release of resources that prevent the memtables from flushing and ensures fairness when max_threads < max_concurrent_sessions. Adjust when high write workloads exist on tables that have continuous paging requests.

How long the server will wait, in seconds, for clients to request more pages if the client is not reading and the server queue is full.

How long to wait before checking if a paused session can be resumed. Continuous paging sessions are paused because of backpressure or when the client has not request more pages with backpressure updates.

How long to wait, in milliseconds, before checking if a continuous paging sessions can be resumed, when that session is paused because of backpressure.

The sensitivity of the failure detector on an exponential scale. Generally, this setting does not need adjusting.

The sampling probability to track for the specified resource. For resources tracked, see nodetool leaksdetection.

The size of the cache for call stack traces. Stack traces are used to debug leaked resources, and use heap memory. Set the amount of heap memory dedicated to each resource by setting the max stacks cache size in MB.

The average number of stack traces kept when a resource is accessed. Supported only for chunks in the cache.

Defaults for both server side and DataStax drivers are modified to match those used by the DataStax Astra cloud platform. Includes but is not limited to stricter guardrails defaults, or the use of LOCAL_QUORUM as the default consistency level.

Enables the DSE Backup and Restore Service.

Directory that holds the backup staging files. The default staging directory for package installations is /var/lib/cassandra/backups_staging. If the property is not set, the default staging directory is <$CASSANDRA_HOME>`/data/backups_staging`.

Sets the number of times the backup process should retry after each failed attempt.

Various settings that can automatically prevent common DSE performance issues. Default values may differ when emulate_dbaas_defaults is enabled.

Logs a warning when the number of tombstones in memory exceeds the specified value. See Cassandra Anti-Patterns: Queues and Queue-like Datasets for details.

Fails when the number of tombstones in memory exceeds the specified value. See Cassandra Anti-Patterns: Queues and Queue-like Datasets for details.

Logs a warning when compacting partitions larger than the specified value.

Logs a warning on any multiple-partition batch size that exceeds the specified value. 64kb per batch by default.

Fails any multiple-partition batch that exceeds the specified value.

Logs a warning for any batches not of type LOGGED that span across more partitions than the specified limit.

Prevents the writing of columns larger than the specified value.

Prevents creating more columns per table than the specified value.

Logs a warning when more fields are created in a UDT than the specified value.

Logs a warning when the size of a collection exceeds the specified value.

Logs a warning when the number of elements in a collection exceeds the specified value.

Enables read-before-write operations such as setting or removing a list element by index.

Fails when attempting to create more SAI indexes in the cluster than the specified value.

Fails when attempting to create more secondary indexes per table than the specified value. Not applicable to SAI indexes; instead, see sai_indexes_per_table_failure_threshold.

Fails when attempting to create more materialized views per table than the specified value.

Logs a warning when the number of tables created exceeds the specified value.

Fails when the number of tables created exceeds the specified value.

Prevent creating tables with the specified properties.

Allows user-provided timestamps in write requests.

Prevents queries with the listed consistency settings.

Fails when paging exceeds the specified threshold. Serves as a hard paging limit.

Fails when an IN query creates a cartesian product size exceeding the specified value. For example, a value of 50 would cause the following IN query, which results in a cartesian product of 100, a IN (1,2,...10) AND b IN (1,2...10), to fail.

Fails when an IN query tries to queries more partition keys than the specified value.

Logs a warning when disk usage exceeds the specified percentage.

Fails when a write request would exceed the specified disk usage percentage.

Limits a DSE cluster to a set amount of gigabytes when calculating thresholds for disk_usage_percentage_warn_threshold and disk_usage_percentage_failure_threshold. Disabled by default, in which case DSE uses the physically available disk size of data directories during disk-usage calculations.