ill.exec.drill-java-exec.1.21.2.source-code.drill-module.conf Maven / Gradle / Ivy
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# This file tells Drill to consider this module when class path scanning.
# This file can also include any supplementary configuration information.
# This file is in HOCON format, see https://github.com/typesafehub/config/blob/master/HOCON.md for more information.
# Please keep the lists that follow sorted (while respecting existing
# groupings and comment lines).
drill {
classpath.scanning {
base.classes: ${?drill.classpath.scanning.base.classes} [
org.apache.drill.exec.expr.DrillFunc,
org.apache.drill.exec.expr.fn.PluggableFunctionRegistry,
org.apache.drill.exec.physical.base.PhysicalOperator,
org.apache.drill.exec.physical.impl.BatchCreator,
org.apache.drill.exec.physical.impl.RootCreator,
org.apache.drill.exec.rpc.user.security.UserAuthenticator,
org.apache.drill.exec.rpc.security.AuthenticatorFactory,
org.apache.drill.exec.server.rest.auth.DrillHttpConstraintSecurityHandler,
org.apache.drill.exec.store.dfs.FormatPlugin,
org.apache.drill.exec.store.StoragePlugin,
org.apache.drill.exec.coord.zk.ZKACLProvider
],
annotations: ${?drill.classpath.scanning.annotations} [
org.apache.drill.exec.expr.annotations.FunctionTemplate,
org.apache.drill.exec.store.SystemPlugin
],
packages: ${?drill.classpath.scanning.packages} [
org.apache.drill.exec.coord.zk,
org.apache.drill.exec.expr,
org.apache.drill.exec.physical,
org.apache.drill.exec.rpc.security,
org.apache.drill.exec.rpc.user.security,
org.apache.drill.exec.server.rest.auth,
org.apache.drill.exec.store,
org.apache.drill.exec.store.security
],
# caches scanned result during build time
# set to false to avoid the need for a full Drill build during development
cache.enabled: true
}
}
drill.client: {
supports-complex-types: true
}
# Location Drill uses for temporary files, such as downloaded dynamic UDFs jars.
# By default ${DRILL_TMP_DIR} is used if set or ${drill.tmp-dir} if it's been overridden.
drill.tmp-dir: "/tmp"
drill.tmp-dir: ${?DRILL_TMP_DIR}
drill.exec: {
cluster-id: "drillbits1",
rpc: {
user: {
timeout: 30,
server: {
port: 31010
threads: 1,
memory: {
reservation: 0,
maximum: 9223372036854775807
}
}
client: {
threads: 1
}
},
bit: {
timeout: 300,
server: {
port: 31011,
retry:{
count: 7200,
delay: 500
},
threads: 8
memory: {
control: {
reservation: 0,
maximum: 9223372036854775807
},
data: {
reservation: 0,
maximum: 9223372036854775807
}
}
}
},
use.ip: false,
bind_addr: "0.0.0.0"
},
optimizer: {
implementation: "org.apache.drill.exec.opt.IdentityOptimizer"
},
storage: {
registry: "org.apache.drill.exec.store.StoragePluginRegistryImpl",
file: {
text: {
buffer.size: 262144,
batch.size: 4000
},
enable_mount_commands: false
},
# The name of the file to scan for "classic" storage plugins
# Configured here for ease of testing. Users should NEVER change
# this setting.
bootstrap: {
storage: "bootstrap-storage-plugins.json",
# Not actually supported
format: "bootstrap-format-plugins.json"
},
# The name of the upgrade (override) file for changes to an
# existing system
upgrade: {
storage: "storage-plugins-override.conf"
},
# The action on the storage-plugins-override.conf after it's use.
# Possible values are "none" (default), "rename", "remove"
action_on_plugins_override_file: "none"
},
zk: {
connect: "localhost:2181",
root: "drill",
refresh: 500,
timeout: 5000,
retry: {
count: 15,
delay: 500
},
apply_secure_acl: false,
acl_provider: "creator-all"
},
http: {
enabled: true,
client: {
timeout: 5000
},
ssl_enabled: false,
porthunt: false,
bind_addr: "0.0.0.0",
port: 8047,
jetty : {
server : {
acceptors : 1,
selectors : 1,
handlers : 5,
dumpAfterStart: false
}
}
max_profiles: 100,
profiles_per_page: [10, 25, 50, 100],
profile.statistics.estimated_rows.show : false,
profile.warning: {
progress.threshold: 300,
time.skew: {
min: 2,
ratio: {
process: 2
wait: 2
}
},
scan.wait.min: 60
},
session_max_idle_secs: 3600, # Default value 1hr
cors: {
enabled: false,
allowedOrigins: ["null"],
allowedMethods: ["GET", "POST", "HEAD", "OPTIONS"],
allowedHeaders: ["X-Requested-With", "Content-Type", "Accept", "Origin"],
credentials: true
},
session: {
memory: {
reservation: 0,
maximum: 9223372036854775807
}
},
# Default to failing queries only at 100% heap usage, i.e. the heap usage
# limiting logic in the REST API is disabled by default.
memory.heap.failure.threshold: 1.0,
web.client.resultset: {
autolimit {
checked: false,
rows: 1000
},
rowsPerPageValues: [10, 25, 50, 75, 100]
},
web.options.filters: ["planner", "store", "parquet", "hashagg", "hashjoin"]
},
# setting javax variables for ssl configurations is being deprecated.
ssl: {
keyStoreType = ${?javax.net.ssl.keyStoreType},
keyStorePath = ${?javax.net.ssl.keyStore},
keyStorePassword = ${?javax.net.ssl.keyStorePassword},
trustStoreType = ${?javax.net.ssl.trustStoreType},
trustStorePath = ${?javax.net.ssl.trustStore},
trustStorePassword = ${?javax.net.ssl.trustStorePassword}
# default key password to keystore password
keyPassword = ${?javax.net.ssl.keyStorePassword},
protocol: "TLSv1.3",
# if true, then Drill will read SSL parameters from the
# Hadoop configuration files.
useHadoopConfig : true,
# Use keyStore and trustStore credentials provided by MapR platform.
useMapRSSLConfig : false,
#Drill can use either the JDK implementation or the OpenSSL implementation.
provider: "JDK"
},
network: {
start: 35000
},
work: {
affinity.factor: 1.2
},
sys.store.provider: {
class: "org.apache.drill.exec.store.sys.store.provider.ZookeeperPersistentStoreProvider",
local: {
path: "/tmp/drill",
write: true
}
},
profiles.store: {
inmemory: false,
capacity: 1000
},
impersonation: {
enabled: false,
max_chained_user_hops: 3
},
security.user.auth: {
enabled: false
},
security.bit.auth: {
enabled: false
use_login_principal: false
}
security.user.encryption.sasl: {
enabled: false,
max_wrapped_size: 65536
}
security.bit.encryption.sasl: {
enabled: false,
max_wrapped_size: 65536
}
security.user.encryption.ssl: {
enabled: false
}
trace: {
directory: "/tmp/drill-trace",
filesystem: "file:///"
},
tmp: {
directories: ["/tmp/drill"],
filesystem: "drill-local:///"
},
buffer:{
size: "6",
spooling: {
delete: true,
size: 100000000
},
unlimited_receiver: {
max_size: 500000000
}
},
compile: {
codegen.debug.topn: false,
compiler: "DEFAULT",
debug: true,
janino_maxsize: 262144,
cache_max_size: 1000,
# Where to save the generated source. See ClassBuilder
code_dir: "/tmp/drill/codegen"
# Disable code cache. Only for testing.
disable_cache: false,
# Use plain Java compilation where available
prefer_plain_java: false
},
debug: {
# If true, inserts the iterator validator atop each operator.
# Primarily used for testing.
validate_iterators: false,
# If iterator validation is enabled, also validates the vectors
# in each batch. Primarily used for testing. To enable from
# the command line:
# java ... -ea -Ddrill.exec.debug.validate_vectors=true ...
validate_vectors: false
# If true, dumps several record batches when an operator fails.
# Generally disabled in testing, especially when we expect
# a failure
dump_batches: true
},
spill: {
# *** Options common to all the operators that may spill
# File system to use. Local file system by default.
fs: "file:///",
# List of directories to use. Directories are created
# if they do not exist.
directories: [ "/tmp/drill/spill" ]
},
hashjoin: {
spill: {
# -- The 2 options below can be used to override the common ones
# -- (common to all spilling operators)
# File system to use. Local file system by default.
fs: ${drill.exec.spill.fs},
# List of directories to use. Directories are created
# if they do not exist.
directories: ${drill.exec.spill.directories},
}
},
hashagg: {
spill: {
# -- The 2 options below can be used to override the common ones
# -- (common to all spilling operators)
# File system to use. Local file system by default.
fs: ${drill.exec.spill.fs},
# List of directories to use. Directories are created
# if they do not exist.
directories: ${drill.exec.spill.directories},
}
},
sort: {
purge.threshold : 10,
external: {
# Limit on the number of batches buffered in memory.
# Primarily for testing.
# 0 = unlimited
batch_limit: 0,
# Limit on the amount of memory used for xsort. Overrides the
# value provided by Foreman. Primarily for testing.
# 0 = unlimited, Supports HOCON memory suffixes.
mem_limit: 0,
# Limit on the number of batches that can be merged in
# a single pass. Limits the number of open file handles.
# 0 = unlimited
merge_limit: 128,
spill: {
# Deprecated for managed xsort; used only by legacy xsort
group.size: 40000,
# Deprecated for managed xsort; used only by legacy xsort
threshold: 40000,
# -- The two options below can be used to override the options common
# -- for all spilling operators (see "spill" above).
# -- This is done for backward compatibility; in the future they
# -- would be deprecated (you should be using only the common ones)
# File system to use. Local file system by default.
fs: ${drill.exec.spill.fs},
# List of directories to use. Directories are created
# if they do not exist.
directories: ${drill.exec.spill.directories},
# Size of the batches written to, and read from, the spill files.
# Determines the ratio of memory to input data size for a single-
# generation sort. Smaller values are better, but too small
# incurs per-batch overhead.
spill_batch_size = 1M,
# Preferred file size for "first-generation" spill files.
# Set large enough to get long, continuous writes, but not so
# large as to overwhelm a temp directory.
# Supports HOCON memory suffixes.
file_size: 256M
}
}
},
queue : {
# Settings for the local query queue available for embedded drillbits.
embedded : {
# Enable the local query queue
enable: false,
# Maximum number of queries that can run simultaneously.
# All others queue.
size: 2,
# Maximum wait time in the queue before the query times out and
# fails.
timeout_ms: 5000 # 5 seconds
}
}
memory: {
operator: {
max: 20000000000,
initial: 10000000
},
fragment: {
max: 20000000000,
initial: 20000000
}
},
debug: {
return_error_for_failure_in_cancelled_fragments: false
},
scan: {
threadpool_size: 8,
decode_threadpool_size: 1
},
udf: {
retry-attempts: 5,
# Disables (parts of) the dynamic UDF functionality.
# Primarily for testing.
disable_dynamic: false,
directory: {
# Base directory for remote and local udf directories, unique among clusters.
base: ${drill.exec.zk.root}"/udf",
# Path to local udf directory, always created on local file system.
# Root for these directory is generated at runtime unless Drill temporary directory is set.
local: ${drill.exec.udf.directory.base}"/local",
# Set this property if custom file system should be used to create remote directories, ex: fs: "file:///".
# fs: "",
# Set this property if custom absolute root should be used for remote directories, ex: root: "/app/drill".
# root: "",
# Relative path to all remote udf directories.
# Directories are created under default file system taken from Hadoop configuration
# unless ${drill.exec.udf.directory.fs} is set.
# User home directory is used as root unless ${drill.exec.udf.directory.root} is set.
staging: ${drill.exec.udf.directory.base}"/staging",
registry: ${drill.exec.udf.directory.base}"/registry",
tmp: ${drill.exec.udf.directory.base}"/tmp"
}
},
# Temporary table can be created ONLY in default temporary workspace.
# Full workspace name should be indicated (including schema and workspace separated by dot).
# Workspace MUST be file-based and writable. Workspace name is case-sensitive.
default_temporary_workspace: "dfs.tmp"
# Resource management
rm : {
# Enables Drill RM feature by default. To disable it set the below parameter to false
enabled: false
# Memory per node normally comes from the direct memory alloated on the JVM
# command line. This parameter, if other than 0, further limits the amount.
# Primarily for testing.
memory_per_node: 0,
# The number of available CPUs normally comes directly from the system itself.
# This parameter, if other than 0, further limits the number of CPUs will
# will consider when planning. Note that, sadly, this parameter does not
# limit *actual* CPU usage; only the amount of CPU assumed to exist when
# planning and managing queries. Primarily for testing.
cpus_per_node: 0,
}
# Grace period is the amount of time where the drillbit accepts work after
# the shutdown request is triggered. The primary use of grace period is to
# avoid the race conditions caused by zookeeper delay in updating the state
# information of the drillbit that is shutting down. So, it is advisable
# to have a grace period that is atleast twice the amount of zookeeper
# refresh time.
grace_period_ms : 0,
# port hunting for drillbits. Enabled only for testing purposes.
port_hunt : false,
# Allow drillbit to bind to loopback address in distributed mode. Enabled only for testing purposes.
allow_loopback_address_binding : false
# HTTP client proxy configuration
net_proxy: {
# HTTP URL, usually from a Linux env var
# See https://www.shellhacks.com/linux-proxy-server-settings-set-proxy-command-line/
http_url: "",
http_url: ${?HTTP_PROXY},
http_url: ${?http_proxy},
http_url: ${?all_proxy},
http_url: ${?ALL_PROXY},
# Explicit HTTP setup, used if URL is not set
http: {
type: "none", # none, http, socks. Blank same as none.
host: "",
port: 80,
user_name: "",
password: ""
},
# HTTPS URL, usually from a Linux env var
https_url: "",
https_url: ${?HTTPS_PROXY},
https_url: ${?https_proxy},
https_url: ${?all_proxy},
https_url: ${?ALL_PROXY},
# Explicit HTTPS setup, used if URL is not set
https: {
type: "none", # none, http, socks. Blank same as none.
host: "",
port: 80,
user_name: "",
password: ""
}
}
}
drill.jdbc: {
batch_queue_throttling_threshold: 100,
query_timeout: 600000
}
# The following are defaults for system and session options.
# Provided here for easy customization in Drill distributions
# like the drill-distrib.conf file.
# An addition of new system option should go through following procedure.
# Before adding a system option a validator should be added for that
# option and then the option should be configured below under the name
# space drill.exec.options. When the system options are being loaded
# options config options are read to find the default value for a give option
# if the option is not set using ALTER SYSTEM or ALTER SESSION.But
# if the option is not configured in the conf file under the name space
# "drill.exec.options", option missing exception will be thrown.
# Users are not supposed to set these options in the drill-override.conf file.
# Users should use ALTER SYSTEM and ALTER SESSION to set the options.
drill.exec.options: {
debug.validate_iterators: false,
debug.validate_vectors: false,
drill.exec.functions.cast_empty_string_to_null: false,
drill.exec.rpc.fragrunner.timeout: 10000,
drill.exec.hashjoin.mem_limit: 0,
# Setting to control if HashJoin should fallback to older behavior of consuming
# unbounded memory. By default it's set to false such that the
# query will fail if there is not enough memory
drill.exec.hashjoin.fallback.enabled: false
# Setting to control if HashAgg should fallback to older behavior of consuming
# unbounded memory. In case of 2 phase Agg when available memory is not enough
# to start at least 2 partitions then HashAgg fallbacks to this case. It can be
# enabled by setting this flag to true. By default it's set to false such that
# query will fail if there is not enough memory
drill.exec.hashagg.fallback.enabled: false,
drill.exec.http.rest.errors.verbose: false,
drill.exec.implicit_casts.joins.enabled: false,
drill.exec.memory.operator.output_batch_size : 16777216, # 16 MB
drill.exec.memory.operator.output_batch_size_avail_mem_factor : 0.1,
drill.exec.stats.logging.batch_size: false,
drill.exec.stats.logging.fine_grained.batch_size: false,
drill.exec.stats.logging.enabled_operators: all,
drill.exec.storage.file.partition.column.label: "dir",
drill.exec.storage.implicit.filename.column.label: "filename",
drill.exec.storage.implicit.filepath.column.label: "filepath",
drill.exec.storage.implicit.fqn.column.label: "fqn",
drill.exec.storage.implicit.last_modified_time.column.label: "lmt",
drill.exec.storage.implicit.project_metadata.column.label: "$project_metadata$",
drill.exec.storage.implicit.row_group_index.column.label: "rgi",
drill.exec.storage.implicit.row_group_length.column.label: "rgl",
drill.exec.storage.implicit.row_group_start.column.label: "rgs",
drill.exec.storage.implicit.suffix.column.label: "suffix",
drill.exec.testing.controls: "{}",
exec.bulk_load_table_list.bulk_size: 1000,
exec.enable_aliases: true,
exec.enable_bulk_load_table_list: false,
exec.enable_dynamic_fc: false,
exec.enable_union_type: false,
exec.errors.verbose: false,
exec.except_add_agg_below: false,
exec.hashagg.max_batches_in_memory: 65536,
exec.hashagg.mem_limit: 0,
exec.hashagg.min_batches_per_partition: 2,
exec.hashagg.num_partitions: 32,
exec.hashagg.num_rows_in_batch: 128,
exec.hashagg.use_memory_prediction: true,
exec.hashjoin.bloom_filter.fpp: 0.75,
exec.hashjoin.bloom_filter.max.size: 33554432, #32 MB
exec.hashjoin.enable.runtime_filter: false,
exec.hashjoin.fragmentation_factor: 1.33,
exec.hashjoin.hash_double_factor: 2.0,
exec.hashjoin.hash_table_calc_type: "LEAN",
exec.hashjoin.max_batches_in_memory: 0,
exec.hashjoin.mem_limit: 0,
exec.hashjoin.num_partitions: 32,
exec.hashjoin.num_rows_in_batch: 1024,
exec.hashjoin.runtime_filter.max.waiting.time: 300, #400 ms
exec.hashjoin.runtime_filter.waiting.enable: true,
exec.hashjoin.safety_factor: 1.0,
exec.impersonation.inbound_policies: "[]",
exec.java_compiler_debug: true,
exec.java_compiler: "DEFAULT",
exec.java.compiler.exp_in_method_size: 50,
exec.java_compiler_janino_maxsize: 262144,
exec.max_hash_table_size: 1073741824,
exec.min_hash_table_size: 65536,
exec.partition.mem_throttle: 0,
exec.persistent_table.umask: "002",
exec.query_profile.alter_session.skip: true,
exec.query_profile.debug_mode: false,
exec.query_profile.save: true,
exec.query.progress.update: true,
# Default queue values for an 8 GB direct memory default
# Drill install. Users are expected to adjust these based
# on load and available resources.
exec.queue.enable: false,
exec.queue.large: 2,
exec.queue.memory_ratio: 10.0,
exec.queue.memory_reserve_ratio: 0.2,
exec.queue.small: 4,
exec.queue.threshold: 30000000,
exec.queue.timeout_millis: 300000,
# Deprecated
exec.sort.disable_managed : false,
# Deprecated
exec.storage.enable_new_text_reader: true,
# Deprecated
exec.storage.enable_v3_text_reader: false,
exec.storage.min_width: 1,
exec.storage.skip_runtime_rowgroup_pruning: false,
exec.udf.enable_dynamic_support: true,
exec.udf.use_dynamic: true,
new_view_default_permissions: 700,
org.apache.drill.exec.compile.ClassTransformer.scalar_replacement: "try",
planner.add_producer_consumer: false,
planner.affinity_factor: 1.2,
planner.broadcast_factor: 1.0,
planner.broadcast_threshold: 10000000,
planner.cpu_load_average: 0.70,
planner.disable_exchanges: false,
planner.enable_broadcast_join: true,
planner.enable_constant_folding: true,
planner.enable_decimal_data_type: true,
planner.enable_demux_exchange: false,
planner.enable_file_listing_limit0_optimization: false,
planner.enable_hashagg: true,
planner.enable_hashjoin_swap: true,
planner.enable_hashjoin: true,
planner.enable_hash_single_key: true,
planner.enable_hep_opt: true,
planner.enable_hep_partition_pruning: true,
planner.enable_join_optimization: true,
planner.enable_limit0_on_scan: true,
planner.enable_limit0_optimization: true,
planner.enable_mergejoin: true,
planner.enable_multiphase_agg: true,
planner.enable_mux_exchange: true,
planner.enable_nestedloopjoin: true,
planner.enable_nljoin_for_scalar_only: true,
planner.enable_ordered_mux_exchange: true,
planner.enable_rowkeyjoin_conversion: true,
planner.enable_semijoin: true,
planner.enable_streamagg: true,
planner.enable_topn: true,
planner.enable_type_inference: true,
planner.enable_unionall_distribute: false,
planner.enable_unnest_lateral: true,
planner.filter.max_selectivity_estimate_factor: 1.0,
planner.filter.min_selectivity_estimate_factor: 0.0,
planner.force_2phase_aggr: false,
planner.identifier_max_length: 1024,
planner.in_subquery_threshold: 20,
planner.join.hash_join_swap_margin_factor: 10,
planner.join.row_count_estimate_factor: 1.0,
planner.memory.average_field_width: 8,
planner.memory.enable_memory_estimation: false,
planner.memory.hash_agg_table_factor: 1.1d,
planner.memory.hash_join_table_factor: 1.1d,
planner.memory_limit: 268435456,
planner.memory.max_query_memory_per_node: 2147483648, # 2 GB
planner.memory.min_memory_per_buffered_op: 41943040, # 40 MB
planner.memory.non_blocking_operators_memory: 64,
planner.memory.percent_per_query: 0.05, # 5%
planner.nestedloopjoin_factor: 100.0,
planner.parser.quoting_identifiers: "`",
planner.partitioner_sender_max_threads: 8,
planner.partitioner_sender_set_threads: -1,
planner.partitioner_sender_threads_factor: 2,
planner.producer_consumer_queue_size: 10,
planner.rowkeyjoin_conversion_selectivity_threshold: 0.01,
planner.rowkeyjoin_conversion_using_hashjoin: false,
planner.slice_target: 100000,
planner.statistics.multicol_ndv_adjustment_factor: 1.0,
planner.statistics.use: false,
planner.store.parquet.rowgroup.filter.pushdown.enabled: true,
planner.store.parquet.rowgroup.filter.pushdown.threshold: 10000,
# Max per node should always be configured as zero and
# it is dynamically computed based on cpu_load_average
planner.width.max_per_node: 0,
planner.width.max_per_query: 1000,
prepare.statement.create_timeout_ms: 30000,
security.admin.user_groups: "%drill_process_user_groups%",
security.admin.users: "%drill_process_user%",
storage.list_files_recursively: false,
storage.plugin_auto_disable: false,
storage.plugin_retry_attempt_delay: 2000,
storage.plugin_retry_attempts: 1,
store.format: "parquet",
# Properties values should NOT be set in double-quotes or any other quotes.
# Property name and value should be separated by =.
# Properties should be separated by new line (\n).
store.hive.conf.properties: "",
store.hive.maprdb_json.optimize_scan_with_native_reader: false,
store.hive.maprdb_json.read_timestamp_with_timezone_offset: false,
store.hive.maprdb_json.all_text_mode: false,
store.hive.optimize_scan_with_native_readers: false,
store.hive.parquet.optimize_scan_with_native_reader: false,
store.json.all_text_mode: false,
store.json.enable_v2_reader: true,
store.json.extended_types: false,
store.json.reader.allow_escape_any_char: false,
store.json.reader.allow_nan_inf: true,
store.json.reader.print_skipped_invalid_record_number: false,
store.json.reader.skip_invalid_records: false,
store.json.read_numbers_as_double: false,
store.json.writer.allow_nan_inf: true,
store.json.writer.skip_null_fields: true,
store.json.writer.uglify: false,
store.kafka.all_text_mode: false,
store.kafka.poll.timeout: 200,
store.kafka.reader.allow_escape_any_char: false,
store.kafka.reader.allow_nan_inf: true,
store.kafka.reader.skip_invalid_records: false,
store.kafka.read_numbers_as_double: false,
store.kafka.record.reader: "org.apache.drill.exec.store.kafka.decoders.JsonMessageReader",
store.mongo.all_text_mode: false,
store.mongo.bson.record.reader: true,
store.mongo.read_numbers_as_double: false,
store.parquet.block-size: 536870912,
store.parquet.complex.batch.num_records: 4000,
store.parquet.compression: "none",
store.parquet.dictionary.page-size: 1048576,
store.parquet.enable_dictionary_encoding: false,
# Using common operators batch configuration unless the Parquet specific
# configuration is used
store.parquet.flat.batch.memory_size: 0,
store.parquet.flat.batch.num_records: 32767,
store.parquet.flat.reader.bulk: true,
store.parquet.page-size: 1048576,
store.parquet.reader.columnreader.async: false,
store.parquet.reader.enable_map_support: true,
store.parquet.reader.int96_as_timestamp: false,
store.parquet.reader.pagereader.async: true,
store.parquet.reader.pagereader.bufferedread: true,
store.parquet.reader.pagereader.buffersize: 1048576,
store.parquet.reader.pagereader.enforceTotalSize: false,
store.parquet.reader.pagereader.queuesize: 2,
store.parquet.reader.pagereader.usefadvise: false,
store.parquet.reader.strings_signed_min_max: "",
store.parquet.use_new_reader: false,
store.parquet.vector_fill_check_threshold: 10,
store.parquet.vector_fill_threshold: 85,
store.parquet.writer.format_version: "v1",
store.parquet.writer.logical_type_for_decimals: "fixed_len_byte_array",
store.parquet.writer.use_primitive_types_for_decimals: true,
store.parquet.writer.use_single_fs_block: false,
store.partition.hash_distribute: false,
store.table.use_schema_file: false,
store.text.estimated_row_size_bytes: 100.0,
store.text.writer.add_header: true,
store.text.writer.force_quotes: false,
web.display_format.date: "",
web.display_format.time: "",
web.display_format.timestamp: "",
web.logs.max_lines: 10000,
window.enable: true,
# ============ index plan related options ==============
planner.disable_full_table_scan: false,
planner.enable_index_planning: true,
planner.enable_statistics: true,
planner.index.covering_selectivity_threshold: 1.0,
planner.index.force_sort_noncovering: false,
planner.index.max_chosen_indexes_per_table: 5,
planner.index.max_indexes_to_intersect: 5,
planner.index.noncovering_selectivity_threshold: 0.025,
planner.index.prefer_intersect_plans: false,
planner.index.rowkeyjoin_cost_factor: 0.1,
planner.index.statistics_rowcount_scaling_factor: 0.1,
planner.index.use_hashjoin_noncovering: false,
planner.use_simple_optimizer: false,
exec.query.max_rows: 0,
exec.query.return_result_set_for_ddl: true,
exec.query.return_result_set_for_ddl: true,
exec.query.rowkeyjoin_batchsize: 128,
exec.return_result_set_for_ddl: true,
# ========= rm related options ===========
exec.rm.queryTags: "",
exec.rm.queues.wait_for_preferred_nodes: true,
exec.statistics.deterministic_sampling: false,
exec.statistics.ndv_accuracy: 20,
exec.statistics.ndv_extrapolation_bf_elements: 1000000,
exec.statistics.ndv_extrapolation_bf_fpprobability: 10,
exec.statistics.tdigest_compression: 100,
# ========= Metastore related options ===========
metastore.enabled: false,
metastore.metadata.ctas.auto-collect: "NONE",
metastore.metadata.fallback_to_file_metadata: true
metastore.metadata.store.depth_level: "ALL",
metastore.metadata.use_schema: true,
metastore.metadata.use_statistics: true,
metastore.retrieval.retry_attempts: 5
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy