ContextQMD
Back to Flink

Execution Config Configuration

docs/layouts/shortcodes/generated/execution_config_configuration.html

0.4-rc123.4 KB
Original Source
KeyDefaultTypeDescription
table.exec.async-lookup.buffer-capacity

Batch Streaming | 100 | Integer | The max number of async i/o operation that the async lookup join can trigger. | |

table.exec.async-lookup.key-ordered-enabled

Batch Streaming | false | Boolean | When true, async lookup joins would follow the upsert key order in cdc streams. If there is no defined upsert key, then the total record is considered as the upsert key. Setting this for insert-only streams has no effect because record in insert-only streams is independent and does not affect the state of previous records. Besides, since records in insert-only streams typically do not involve a primary key then no upsertKey can be derived. This makes them be unordered processed even if key ordered enabled. | |

table.exec.async-lookup.output-mode

Batch Streaming | ORDERED |

Enum

| Output mode for asynchronous operations which will convert to {@see AsyncDataStream.OutputMode}, ORDERED by default. If set to ALLOW_UNORDERED, will attempt to use {@see AsyncDataStream.OutputMode.UNORDERED} when it does not affect the correctness of the result, otherwise ORDERED will be still used.

Possible values:

  • "ORDERED"
  • "ALLOW_UNORDERED"

| |

table.exec.async-lookup.timeout

Batch Streaming | 3 min | Duration | The async timeout for the asynchronous operation to complete. | |

table.exec.async-ml-predict.max-concurrent-operations

Batch Streaming | 10 | Integer | The max number of async i/o operation that the async ml predict can trigger. | |

table.exec.async-ml-predict.output-mode

Batch Streaming | ORDERED |

Enum

| Output mode for async ML predict, which describes whether or not the the output should attempt to be ordered or not. The supported options are: ALLOW_UNORDERED means the operator emit the result when execution finishes. The planner will attempt use ALLOW_UNORDERED whn it doesn't affect the correctness of the results. ORDERED ensures that the operator emits the result in the same order as the data enters it. This is the default.

Possible values:

  • "ORDERED"
  • "ALLOW_UNORDERED"

| |

table.exec.async-ml-predict.timeout

Batch Streaming | 3 min | Duration | The async timeout for the asynchronous operation to complete. If the deadline fails, a timeout exception will be thrown to indicate the error. | |

table.exec.async-scalar.max-attempts

Streaming | 3 | Integer | The max number of async retry attempts to make before task execution is failed. | |

table.exec.async-scalar.max-concurrent-operations

Streaming | 10 | Integer | The max number of async i/o operation that the async scalar function can trigger. | |

table.exec.async-scalar.retry-delay

Streaming | 100 ms | Duration | The delay to wait before trying again. | |

table.exec.async-scalar.retry-strategy

Streaming | FIXED_DELAY |

Enum

| Restart strategy which will be used, FIXED_DELAY by default.

Possible values:

  • "NO_RETRY"
  • "FIXED_DELAY"

| |

table.exec.async-scalar.timeout

Streaming | 3 min | Duration | The async timeout for the asynchronous operation to complete. | |

table.exec.async-state.enabled

Streaming | false | Boolean | Set whether to use the SQL/Table operators based on the asynchronous state api. Default value is false. | |

table.exec.async-table.max-concurrent-operations

Streaming | 10 | Integer | The max number of concurrent async i/o operations that the async table function can trigger. | |

table.exec.async-table.max-retries

Streaming | 3 | Integer | The max number of async retry attempts to make before task execution is failed. | |

table.exec.async-table.retry-delay

Streaming | 100 ms | Duration | The delay to wait before trying again. | |

table.exec.async-table.retry-strategy

Streaming | FIXED_DELAY |

Enum

| Restart strategy which will be used, FIXED_DELAY by default.

Possible values:

  • "NO_RETRY"
  • "FIXED_DELAY"

| |

table.exec.async-table.timeout

Streaming | 3 min | Duration | The async timeout for the asynchronous operation to complete, including any retries which may occur. | |

table.exec.async-vector-search.max-concurrent-operations

Batch Streaming | 10 | Integer | The max number of async i/o operation that the async vector search can trigger. | |

table.exec.async-vector-search.output-mode

Batch Streaming | ORDERED |

Enum

| Output mode for async vector search, which describes whether or not the output should attempt to be ordered or not. The supported options are: ALLOW_UNORDERED means the operator emits the result when execution finishes. The planner will attempt to use ALLOW_UNORDERED when it doesn't affect the correctness of the results. ORDERED means that the operator emits the result in the same order as the data enters it. This is the default.

Possible values:

  • "ORDERED"
  • "ALLOW_UNORDERED"

| |

table.exec.async-vector-search.timeout

Batch Streaming | 3 min | Duration | The total time which can pass before the invocation (including retries) is considered timed out and task execution is failed. | |

table.exec.deduplicate.insert-update-after-sensitive-enabled

Streaming | true | Boolean | Set whether the job (especially the sinks) is sensitive to INSERT messages and UPDATE_AFTER messages. If false, Flink may, sometimes (e.g. deduplication for last row), send UPDATE_AFTER instead of INSERT for the first row. If true, Flink will guarantee to send INSERT for the first row, in that case there will be additional overhead. Default is true. | |

table.exec.deduplicate.mini-batch.compact-changes-enabled

Streaming | false | Boolean | Set whether to compact the changes sent downstream in row-time mini-batch. If true, Flink will compact changes and send only the latest change downstream. Note that if the downstream needs the details of versioned data, this optimization cannot be applied. If false, Flink will send all changes to downstream just like when the mini-batch is not enabled. | |

table.exec.delta-join.cache-enabled

Streaming | true | Boolean | Whether to enable the cache of delta join. If enabled, the delta join caches the records from remote dim table. Default is true. | |

table.exec.delta-join.left.cache-size

Streaming | 10000 | Long | The cache size used to cache the lookup results of the left table in delta join. This value must be positive when enabling cache. Default is 10000. | |

table.exec.delta-join.right.cache-size

Streaming | 10000 | Long | The cache size used to cache the lookup results of the right table in delta join. This value must be positive when enabling cache. Default is 10000. | |

table.exec.disabled-operators

Batch | (none) | String | Mainly for testing. A comma-separated list of operator names, each name represents a kind of disabled operator. Operators that can be disabled include "NestedLoopJoin", "ShuffleHashJoin", "BroadcastHashJoin", "SortMergeJoin", "HashAgg", "SortAgg". By default no operator is disabled. | |

table.exec.interval-join.min-cleanup-interval

Streaming | 0 ms | Duration | Specifies a minimum time interval for how long cleanup unmatched records in the interval join operator. Before Flink 1.18, the default value of this param was the half of interval duration. Note: Set this option greater than 0 will cause unmatched records in outer joins to be output later than watermark, leading to possible discarding of these records by downstream watermark-dependent operators, such as window operators. The default value is 0, which means it will clean up unmatched records immediately. | |

table.exec.legacy-cast-behaviour

Batch Streaming | DISABLED |

Enum

| Determines whether CAST will operate following the legacy behaviour or the new one that introduces various fixes and improvements.

Possible values:

  • "ENABLED": CAST will operate following the legacy behaviour.
  • "DISABLED": CAST will operate following the new correct behaviour.

| |

table.exec.local-hash-agg.adaptive.distinct-value-rate-threshold

Batch | 0.5 | Double | The distinct value rate can be defined as the number of local aggregation results for the sampled data divided by the sampling threshold (see table.exec.local-hash-agg.adaptive.sampling-threshold). If the computed result is lower than the given configuration value, the remaining input records proceed to do local aggregation, otherwise the remaining input records are subjected to simple projection which calculation cost is less than local aggregation. The default value is 0.5. | |

table.exec.local-hash-agg.adaptive.enabled

Batch | true | Boolean | Whether to enable adaptive local hash aggregation. Adaptive local hash aggregation is an optimization of local hash aggregation, which can adaptively determine whether to continue to do local hash aggregation according to the distinct value rate of sampling data. If distinct value rate bigger than defined threshold (see parameter: table.exec.local-hash-agg.adaptive.distinct-value-rate-threshold), we will stop aggregating and just send the input data to the downstream after a simple projection. Otherwise, we will continue to do aggregation. Adaptive local hash aggregation only works in batch mode. Default value of this parameter is true. | |

table.exec.local-hash-agg.adaptive.sampling-threshold

Batch | 500000 | Long | If adaptive local hash aggregation is enabled, this value defines how many records will be used as sampled data to calculate distinct value rate (see parameter: table.exec.local-hash-agg.adaptive.distinct-value-rate-threshold) for the local aggregate. The higher the sampling threshold, the more accurate the distinct value rate is. But as the sampling threshold increases, local aggregation is meaningless when the distinct values rate is low. The default value is 500000. | |

table.exec.mini-batch.allow-latency

Streaming | 0 ms | Duration | The maximum latency can be used for MiniBatch to buffer input records. MiniBatch is an optimization to buffer input records to reduce state access. MiniBatch is triggered with the allowed latency interval and when the maximum number of buffered records reached. NOTE: If table.exec.mini-batch.enabled is set true, its value must be greater than zero. | |

table.exec.mini-batch.enabled

Streaming | false | Boolean | Specifies whether to enable MiniBatch optimization. MiniBatch is an optimization to buffer input records to reduce state access. This is disabled by default. To enable this, users should set this config to true. NOTE: If mini-batch is enabled, 'table.exec.mini-batch.allow-latency' and 'table.exec.mini-batch.size' must be set. | |

table.exec.mini-batch.size

Streaming | -1 | Long | The maximum number of input records can be buffered for MiniBatch. MiniBatch is an optimization to buffer input records to reduce state access. MiniBatch is triggered with the allowed latency interval and when the maximum number of buffered records reached. NOTE: MiniBatch only works for non-windowed aggregations currently. If table.exec.mini-batch.enabled is set true, its value must be positive. | |

table.exec.operator-fusion-codegen.enabled

Batch Streaming | false | Boolean | If true, multiple physical operators will be compiled into a single operator by planner which can improve the performance. | |

table.exec.rank.topn-cache-size

Streaming | 10000 | Long | Rank operators have a cache which caches partial state contents to reduce state access. Cache size is the number of records in each ranking task. | |

table.exec.resource.default-parallelism

Batch Streaming | -1 | Integer | Sets default parallelism for all operators (such as aggregate, join, filter) to run with parallel instances. This config has a higher priority than parallelism of StreamExecutionEnvironment (actually, this config overrides the parallelism of StreamExecutionEnvironment). A value of -1 indicates that no default parallelism is set, then it will fallback to use the parallelism of StreamExecutionEnvironment. | |

table.exec.simplify-operator-name-enabled

Batch Streaming | true | Boolean | When it is true, the optimizer will simplify the operator name with id and type of ExecNode and keep detail in description. Default value is true. | |

table.exec.sink.keyed-shuffle

Streaming | AUTO |

Enum

| In order to minimize the distributed disorder problem when writing data into table with primary keys that many users suffers. FLINK will auto add a keyed shuffle by default when the sink parallelism differs from upstream operator and sink parallelism is not 1. This works only when the upstream ensures the multi-records' order on the primary key, if not, the added shuffle can not solve the problem (In this situation, a more proper way is to consider the deduplicate operation for the source firstly or use an upsert source with primary key definition which truly reflect the records evolution).
By default, the keyed shuffle will be added when the sink's parallelism differs from upstream operator. You can set to no shuffle(NONE) or force shuffle(FORCE).

Possible values:

  • "NONE"
  • "AUTO"
  • "FORCE"

| |

table.exec.sink.nested-constraint-enforcer

Batch Streaming | IGNORE |

Enum

| Determines if constraints should be enforced for nested fields. Beware that enforcing constraints for nested fields adds computational overhead especially when iterating through collections

Possible values:

  • "IGNORE": Don't perform check on nested types in ROWS/ARRAYS/MAPS
  • "ROWS": Perform checks on nested types in ROWS.
  • "ROWS_AND_COLLECTIONS": Perform checks on nested types in ROWS/ARRAYS/MAPS. Be aware that the more checks the more performance impact. Especially checking types in ARRAYS/MAPS can be expensive.

| |

table.exec.sink.not-null-enforcer

Batch Streaming | ERROR |

Enum

| Determines how Flink enforces NOT NULL column constraints when inserting null values.

Possible values:

  • "ERROR": Throw a runtime exception when writing null values into NOT NULL column.
  • "DROP": Drop records silently if a null value would have to be inserted into a NOT NULL column.

| |

table.exec.sink.require-on-conflict

Streaming | true | Boolean | When enabled, an error is thrown if the query's upsert key differs from the sink table's primary key and no ON CONFLICT clause is specified. This can lead to non-deterministic results when multiple records with different upsert keys map to the same primary key.

Set this to false to restore the old behavior where no ON CONFLICT clause was required. Note that disabling this check may lead to non-deterministic results in certain streaming scenarios. | |

table.exec.sink.rowtime-inserter

Streaming | ENABLED |

Enum

| Some sink implementations require a single rowtime attribute in the input that can be inserted into the underlying stream record. This option allows disabling the timestamp insertion and avoids errors around multiple time attributes being present in the query schema.

Possible values:

  • "ENABLED": Insert a rowtime attribute (if available) into the underlying stream record. This requires at most one time attribute in the input for the sink.
  • "DISABLED": Do not insert the rowtime attribute into the underlying stream record.

| |

table.exec.sink.type-length-enforcer

Batch Streaming | IGNORE |

Enum

| Determines whether values for columns with CHAR(<length>)/VARCHAR(<length>)/BINARY(<length>)/VARBINARY(<length>) types will be trimmed or padded (only for CHAR(<length>)/BINARY(<length>)), so that their length will match the one defined by the length of their respective CHAR/VARCHAR/BINARY/VARBINARY column type.

Possible values:

  • "IGNORE": Don't apply any trimming and padding, and instead ignore the CHAR/VARCHAR/BINARY/VARBINARY length directive.
  • "TRIM_PAD": Trim and pad string and binary values to match the length defined by the CHAR/VARCHAR/BINARY/VARBINARY length.
  • "ERROR": Throw a runtime exception when writing data into a CHAR/VARCHAR/BINARY/VARBINARY column which does not match the length constraint

| |

table.exec.sink.upsert-materialize

Streaming | AUTO |

Enum

| Because of the disorder of ChangeLog data caused by Shuffle in distributed system, the data received by Sink may not be the order of global upsert. So add upsert materialize operator before upsert sink. It receives the upstream changelog records and generate an upsert view for the downstream.
By default, the materialize operator will be added when a distributed disorder occurs on unique keys. You can also choose no materialization(NONE) or force materialization(FORCE).

Possible values:

  • "NONE"
  • "AUTO"
  • "FORCE"

| |

table.exec.sink.upsert-materialize-strategy.adaptive.threshold.high

Streaming | (none) | Long | When using strategy=ADAPTIVE, defines the number of entries per key when the implementation is changed from VALUE to MAP. If not specified, Flink uses state-backend specific defaults (400 for hashmap state backend and 50 for RocksDB and the rest).
| |

table.exec.sink.upsert-materialize-strategy.adaptive.threshold.low

Streaming | (none) | Long | When using strategy=ADAPTIVE, defines the number of entries per key when the implementation is changed from MAP to VALUE. If not specified, Flink uses state-backend specific defaults (300 for hashmap state backend and 40 for RocksDB and the rest).
| |

table.exec.sink.upsert-materialize-strategy.type

Streaming | LEGACY |

Enum

| Which strategy of SinkUpsertMaterializer to use. Supported strategies:
LEGACY: Simple implementation based on ValueState<List> (the original implementation).
MAP: SequencedMultiSetState implementation based on a combination of several MapState maintaining ordering and fast lookup properties.
VALUE: Similar to LEGACY, but compatible with MAP and therefore allows to switch to ADAPTIVE.
ADAPTIVE: Alternate between MAP and VALUE depending on the number of entries for the given key starting with VALUE and switching to MAP upon reaching threshold.high value (and back to VALUE, when reaching low).

Possible values:

  • "LEGACY"
  • "MAP"
  • "VALUE"
  • "ADAPTIVE"

| |

table.exec.sort.async-merge-enabled

Batch | true | Boolean | Whether to asynchronously merge sorted spill files. | |

table.exec.sort.default-limit

Batch | -1 | Integer | Default limit when user don't set a limit after order by. -1 indicates that this configuration is ignored. | |

table.exec.sort.max-num-file-handles

Batch | 128 | Integer | The maximal fan-in for external merge sort. It limits the number of file handles per operator. If it is too small, may cause intermediate merging. But if it is too large, it will cause too many files opened at the same time, consume memory and lead to random reading. | |

table.exec.source.cdc-events-duplicate

Streaming | false | Boolean | Indicates whether the CDC (Change Data Capture) sources in the job will produce duplicate change events that requires the framework to deduplicate and get consistent result. CDC source refers to the source that produces full change events, including INSERT/UPDATE_BEFORE/UPDATE_AFTER/DELETE, for example Kafka source with Debezium format. The value of this configuration is false by default.

However, it's a common case that there are duplicate change events. Because usually the CDC tools (e.g. Debezium) work in at-least-once delivery when failover happens. Thus, in the abnormal situations Debezium may deliver duplicate change events to Kafka and Flink will get the duplicate events. This may cause Flink query to get wrong results or unexpected exceptions.

Therefore, it is recommended to turn on this configuration if your CDC tool is at-least-once delivery. Enabling this configuration requires to define PRIMARY KEY on the CDC sources. The primary key will be used to deduplicate change events and generate normalized changelog stream at the cost of an additional stateful operator. | |

table.exec.source.idle-timeout

Streaming | 0 ms | Duration | When a source do not receive any elements for the timeout time, it will be marked as temporarily idle. This allows downstream tasks to advance their watermarks without the need to wait for watermarks from this source while it is idle. Default value is 0, which means detecting source idleness is not enabled. | |

table.exec.spill-compression.block-size

Batch | 64 kb | MemorySize | The memory size used to do compress when spilling data. The larger the memory, the higher the compression ratio, but more memory resource will be consumed by the job. | |

table.exec.spill-compression.enabled

Batch | true | Boolean | Whether to compress spilled data. Currently we only support compress spilled data for sort and hash-agg and hash-join operators. | |

table.exec.state.ttl

Streaming | 0 ms | Duration | Specifies a minimum time interval for how long idle state (i.e. state which was not updated), will be retained. State will never be cleared until it was idle for less than the minimum time, and will be cleared at some time after it was idle. Default is never clean-up the state. NOTE: Cleaning up state requires additional overhead for bookkeeping. Default value is 0, which means that it will never clean up state. | |

table.exec.uid.format

Streaming | "<id>_<transformation>" | String | Defines the format pattern for generating the UID of an ExecNode streaming transformation. The pattern can be defined globally or per-ExecNode in the compiled plan. Supported arguments are: <id> (from static counter), <type> (e.g. 'stream-exec-sink'), <version>, and <transformation> (e.g. 'constraint-validator' for a sink). In Flink 1.15.x the pattern was wrongly defined as '<id>_<type>_<version>_<transformation>' which would prevent migrations in the future. | |

table.exec.uid.generation

Streaming | PLAN_ONLY |

Enum

| In order to remap state to operators during a restore, it is required that the pipeline's streaming transformations get a UID assigned.
The planner can generate and assign explicit UIDs. If no UIDs have been set by the planner, the UIDs will be auto-generated by lower layers that can take the complete topology into account for uniqueness of the IDs. See the DataStream API for more information.
This configuration option is for experts only and the default should be sufficient for most use cases. By default, only pipelines created from a persisted compiled plan will get UIDs assigned explicitly. Thus, these pipelines can be arbitrarily moved around within the same topology without affecting the stable UIDs.

Possible values:

  • "PLAN_ONLY": Sets UIDs on streaming transformations if and only if the pipeline definition comes from a compiled plan. Pipelines that have been constructed in the API without a compilation step will not set an explicit UID as it might not be stable across multiple translations.
  • "ALWAYS": Always sets UIDs on streaming transformations. This strategy is for experts only! Pipelines that have been constructed in the API without a compilation step might not be able to be restored properly. The UID generation depends on previously declared pipelines (potentially across jobs if the same JVM is used). Thus, a stable environment must be ensured. Pipeline definitions that come from a compiled plan are safe to use.
  • "DISABLED": No explicit UIDs will be set.

| |

table.exec.unbounded-over.version

Streaming | 2 | Integer | Which version of the unbounded over aggregation to use: 1 - legacy version 2 - version with improved performance | |

table.exec.window-agg.buffer-size-limit

Batch | 100000 | Integer | Sets the window elements buffer size limit used in group window agg operator. |