Presto (Java) singlenode
Properties that can be customized for Presto (Java) singlenode are listed here.
| Property | Description | Type | Default value / Default setting | System property | Restart containers required |
|---|---|---|---|---|---|
presto_singlenode_resources_limits_cpu |
Resource CPU limit for Presto (Java) singlenode container is allowed to use only this much CPU. | Kubernetes CPU Unit | small: 3; small_mincpureq: 3; medium: 6;
large: 9; xlarge: 12; xxlarge: 12 |
resources.limits.cpu |
N |
presto_singlenode_resources_limits_memory |
Resource Memory limit for Presto (Java) singlenode container is allowed to use only this much memory. | Units of Bytes Note: For more information about the memory unit, see Memory resource units.
|
small: 24G; small_mincpureq: 24G; medium:
48G; large: 72G; xlarge: 96G; xxlarge:
96G |
resources.limits.memory |
N |
presto_singlenode_resources_limits_ephemeral_storage |
This parameter sets the maximum amount of local ephemeral storage that a container in a Presto (Java) singlenode Pod can consume. | Units of Bytes | small: 10G; small_mincpureq: 10G; medium:
10G; large: 10G; xlarge: 10G; xxlarge:
10G |
resources.limits.ephemeral-storage |
N |
presto_singlenode_resources_requests_cpu |
Resource CPU request for Presto (Java) single node. | Kubernetes CPU Unit | small: 3; small_mincpureq: 0.005; medium:
6; large: 9; xlarge: 12; xxlarge: 12 |
resources.requests.cpu |
N |
presto_singlenode_resources_requests_memory |
Resource memory request for Presto (Java) singlenode. | Units of Bytes Note: For more information about the memory unit, see Memory resource units.
|
small: 24G; small_mincpureq: 24G; medium:
48G; large: 72G; xlarge: 96G; xxlarge:
96G |
resources.requests.memory |
N |
presto_singlenode_resources_requests_ephemeral_storage |
This parameter sets the minimum/guaranteed amount of local ephemeral storage for a container in a Presto (Java) singlenode Pod. | Units of Bytes | small: 500Mi; small_mincpureq: 500Mi;
medium: 1G; large: 1G; xlarge: 1G;
xxlarge: 1G |
resources.request.ephemeral-storage |
N |
presto_singlenode_jvm_Xmx |
Xmx specifies the maximum memory allocation pool for a Java virtual machine (JVM). | - | jvm.config.Xmx |
Y | |
presto_singlenode_task_concurrency |
Default local concurrency for parallel operators such as joins and aggregations. | Number(must be the power of two) | config.properties.task.concurrency |
Y | |
presto_singlenode_query_max_memory |
The maximum amount of user memory that a query can use across the entire cluster. | Data size | 1TB | config.properties.query.max-memory |
Y |
presto_singlenode_query_max_memory_per_node |
The maximum amount of user memory that a query can use on a worker. | Data size | presto_singlenode_jvm_Xmx*0.795 | config.properties.query.max-memory-per-node |
Y |
presto_singlenode_query_max_total_memory_per_node |
The maximum amount of user and system memory that a query can use on a worker. | Data size | presto_singlenode_jvm_Xmx*0.795 | config.properties.query.max-total-memory-per-node |
Y |
presto_singlenode_query_max_concurrent_queries |
Describes how many queries can be processed simultaneously in a single cluster node. | Integer | config.properties.query.max-concurrent-queries |
Y | |
presto_singlenode_memory_heap_headroom_per_node |
This is the amount of memory set aside as headroom/buffer in the JVM heap for allocations that are not tracked by Presto (Java). | Data size | presto_singlenode_jvm_Xmx*0.2 | config.properties.query.memory.heap-headeroom-per-node |
Y |
presto_singlenode_query_max_total_memory |
The maximum amount of user and system memory that a query can use across the entire cluster. | Data size | 2TB | config.properties.query.max-total-memory |
Y |
presto_singlenode_experimental_optimized_repartitioning |
Improve performance of repartitioning data between stages. | Boolean | true |
experimental.optimized-repartitioning |
Y |
presto_singlenode_experimental_pushdown_dereference_enabled |
Add support for pushdown of dereference expressions for querying nested data. | Boolean | experimental.pushdown-dereference-enabled |
Y | |
presto_singlenode_experimental_pushdown_subfields_enabled |
Add support for pushdown of subfields expressions for querying nested data. | Boolean | experimental.pushdown-subfields-enabled |
Y | |
presto_singlenode_join_max_broadcast_table_size |
Add join-max-broadcast-table-size configuration property and
join_max_broadcast_table_size session property to control the maximum estimated
size of a table that can be broadcast when using AUTOMATIC join distribution type. |
Integer | join-max-broadcast-table-size |
Y | |
presto_singlenode_node_scheduler_max_pending_splits_per_task |
The number of outstanding splits with the standard split weight that can be queued for each
singlenode node for a single stage of a query, even when the node is already at the limit for total
number of splits. Allowing a minimum number of splits per stage is required to prevent starvation
and deadlocks. This value must be smaller than node-scheduler.max-splits-per-node,
will usually be increased for the same reasons, and has similar drawbacks if set too high. |
Integer | node-scheduler.max-pending-splits-per-task |
Y | |
presto_singlenode_optimizer_prefer_partial_aggregation |
This property allows users to disable partial aggregations for queries that do not benefit. | Boolean | optimizer.prefer-partial-aggregation |
Y | |
presto_singlenode_query_execution_policy |
Configures the algorithm to organize the processing of all of the stages of a query. | String | phased |
query.execution-policy |
Y |
presto_singlenode_query_low_memory_killer_policy |
The policy that is used for selecting the query to kill when the cluster is out of memory
(OOM). This property can have one of the following values: none,
total-reservation, or total-reservation-on-blocked-nodes. none
disables the cluster OOM killer. The value of total-reservation configures a policy that kills the
query with the largest memory reservation across the cluster. The value of
total-reservation-on-blocked-nodes configures a policy that kills the query by
using the most memory on the workers that are out of memory (blocked). |
String | total-reservation-on-blocked-nodes |
query.low-memory-killer.policy |
Y |
presto_singlenode_query_max_stage_count |
Add a limit on the number of stages in a query. The default is 100 and can be changed with
the query.max-stage-count configuration property and the
query_max_stage_count session property. |
Integer | 200 | query.max-stage-count |
Y |
presto_singlenode_query_min_schedule_split_batch_size |
Add query.min-schedule-split-batch-size config flag to set the minimum
number of splits to consider for scheduling per batch. |
Boolean | query.min-schedule-split-batch-size |
Y | |
presto_singlenode_query_stage_count_warning_threshold |
Add a config ox`ption (query.stage-count-warning-threshold) to specify a
per-query threshold for the number of stages. When this threshold is exceeded, a
TOO_MANY_STAGES warning is raised. |
Integer | 150 | query.stage-count-warning-threshold |
Y |
presto_singlenode_scale_writers |
Enable writer scaling by dynamically increasing the number of writer tasks on the cluster. | Boolean | scale-writers |
Y | |
presto_singlenode_sink_max_buffer_size |
Buffer size for IO writes while collecting pipeline results. Higher value may increase the speed of IO operations with the cost of additional memory. Also higher value may increase the number of data lost when presto node fails effectively slowing down IO in an unstable environment. | Integer | sink.max-buffer-size |
Y | |
presto_singlenode_experimental_max_revocable_memory_per_node |
The amount of revocable memory a query can use on each node. | Units of Bytes | experimental.max-revocable-memory-per-node |
Y | |
presto_singlenode_experimental_reserved_pool_enabled |
This property allows users to enable or disable Reserved Pool in Presto (Java). When the General Pool is full, this property uses OOM killer in Presto (Java) to increase the General Pool concurrency and prevent the deadlock. | Boolean | False | experimental.reserved-pool-enabled |
Y |
presto_singlenode_ query_min_expire_age
|
This property describes the minimum time after which you can remove the query metadata from the server. | String | 120 minutes | query.min-expire-age |
Y |
presto_singlenode_enable_dynamic_filtering
|
This property improves performance for queries with broadcast or collocated joins by adding dynamic filtering and storage pruning support. | Boolean | experimental.enable-dynamic-filtering |
Y | |
presto_singlenode_exchange_client_threads |
This property helps to control the number of threads that are used by exchange clients in Presto (Java) to fetch data from other Presto (Java) nodes during query execution | Integer | exchange.client-threads |
||
presto_singlenode_exchange_http_client_max_connections |
Integer | exchange.http-client.max-connections |
|||
presto_singlenode_exchange_http_client_max_requests_queued_per_destination |
This property determines the maximum number of HTTP requests that can be
queued for each destination server by the exchange client. |
Integer | exchange.http-client.max-requests-queued-per-destination |
||
presto_singlenode_http_server_log_max_size |
This property specifies the maximum file size for the log file that is generated by the
HTTP server component. |
Units of Bytes | http-server.log.max-size |
||
presto_singlenode_http_server_log_max_history |
The property specifies the maximum number of log files that the HTTP server
component retains before rotating old log content |
Integer | http-server.log.max-history |
||
presto_singlenode_http_server_threads_max |
Integer | http-server.threads.max |
|||
presto_singlenode_log_max_history |
This property represents the maximum number of general application log files that are retained by a logging system before older logs are rotated out. | Integer | log.max-history |
||
presto_singlenode_log_max_size |
The property log.max-size defines the maximum file size that is allowed for
the general application log file. |
Units of Bytes | log.max-size |
||
presto_singlenode_node_scheduler_max_splits_per_node |
This property specifies the target maximum number of splits that can concurrently run on each
worker node. Splits represent units of work within queries. Adjusting this property allows
administrators to optimize resource utilization, especially in scenarios involving large query
batches or connectors generating numerous splits. CAUTION: Setting
Ideally, it should be set such that
there is always at least one split waiting to be processed, but not higher.presto_singlenode_node_scheduler_max_splits_per_node at too high value might lead
to inefficient memory usage and performance degradation. |
Integer | node-scheduler.max-splits-per-node |
||
presto_singlenode_optimize_nulls_in_join |
This property when enabled reduces the overhead of processing NULL values during JOIN operations, particularly beneficial when dealing with columns containing a significant number of NULLs. | Boolean | optimize-nulls-in-join |
||
presto_singlenode_optimizer_default_filter_factor_enabled |
This property enables the use of a default value for estimating the cost of filters in query optimization. | Boolean | optimizer.default-filter-factor-enabled |
||
presto_singlenode_optimizer_exploit_constraints |
This property enables constraint optimizations for querying catalogs that support table constraints. | Boolean | optimizer.exploit-constraints |
||
presto_singlenode_query_client_timeout |
This property specifies the duration for which the cluster waits without any communication from the client application, such as the CLI, before abandoning and canceling the ongoing query or work. | String (Duration) | query.client.timeout |
||
presto_singlenode_query_max_execution_time |
This property specifies the maximum allowed time for a query to be actively executing on the cluster before it is terminated. | String (Duration) | query.max-execution-time |
||
presto_singlenode_query_max_history |
This property refers to the maximum number of queries to keep in the query history to provide statistics and other information. If this amount is reached, queries are removed based on age | Integer | query.max-history |
||
presto_singlenode_query_max_length |
The maximum number of characters allowed for the SQL query text. Longer queries are not processed, and are terminated with error. | Integer | query.max-length |
||
presto_singlenode_shutdown_grace_period |
This property specifies the duration of time that the system waits after receiving a shutdown request before initiating the shutdown process. During this grace period, the system continues to operate normally, allowing ongoing active tasks to be complete. | String (Duration) | shutdown.grace-period |
||
presto_singlenode_experimental_max_spill_per_node |
This property refers to the maximum spill space to be used by all queries on a single node. (when the memory that is allocated for query processing is exceeded.) | Units of Bytes | experimental.max-spill-per-node |
||
presto_singlenode_experimental_query_max_spill_per_node |
This property refers to the maximum spill space to be used by a single query on a single node. | Units of Bytes | experimental.query-max-spill-per-node |
||
presto_singlenode_experimental_spiller_max_used_space_threshold |
This property sets a threshold disk space usage ratio, if the usage exceeds beyond this value, this spill path will not be eligible for spilling. | Double | experimental.spiller-max-used-space-threshold |
||
presto_singlenode_experimental_spiller_spill_path |
This property specifies a directory where spilled content is written. It can be a comma-separated list to spill simultaneously to multiple directories, which helps to utilize multiple drives installed in the system. (It is recommended to avoid spilling to system drives and to ensure that spill operations do not interfere with the JVM operation or disk performance.) | String | experimental.spiller-spill-path |
||
presto_singlenode_httpserver_max_request_header_size |
This property is used to set the maximum size of the request header that
http supports. |
Data size | 16kB | httpserver.max_request_header_size |
Y |
presto_singlenode_httpserver_max_response_header_size |
This property is used to set the maximum size of the response header that
http supports. |
Data size | 16kB | httpserver.max_response_header_size |
Y |
For more information about how to customize the Presto properties, see Customization.