:original_name: mrs_01_1970.html

.. _mrs_01_1970:

Configuring Spark SQL to Enable the Adaptive Execution Feature
==============================================================

Scenario
--------

The Spark SQL adaptive execution feature enables Spark SQL to optimize subsequent execution processes based on intermediate results to improve overall execution efficiency. The following features have been implemented:

#. Automatic configuration of the number of shuffle partitions

   Before the adaptive execution feature is enabled, Spark SQL specifies the number of partitions for a shuffle process by specifying the **spark.sql.shuffle.partitions** parameter. This method lacks flexibility when multiple SQL queries are performed on an application and cannot ensure optimal performance in all scenarios. After adaptive execution is enabled, Spark SQL automatically configures the number of partitions for each shuffle process, instead of using the general configuration. In this way, the proper number of partitions is automatically used during each shuffle process.

2. Dynamic adjusting of the join execution plan

   Before the adaptive execution feature is enabled, Spark SQL creates an execution plan based on the optimization results of rule-based optimization (RBO) and Cost-Based Optimization (CBO). This method ignores changes of result sets during data execution. For example, when a view created based on a large table is joined with other large tables, the execution plan cannot be adjusted to BroadcastJoin even if the result set of the view is small. After the adaptive execution feature is enabled, Spark SQL can dynamically adjust the execution plan based on the execution result of the previous stage to obtain better performance.

3. Automatic processing of data skew

   If data skew occurs during SQL statement execution, the memory overflow of an executor or slow task execution may occur. After the adaptive execution feature is enabled, Spark SQL can automatically process data skew scenarios. Multiple tasks are started for partitions where data skew occurs. Each task reads several output files obtained from the shuffle process and performs union operations on the join results of these tasks to eliminate data skew.

Parameters
----------

Log in to FusionInsight Manager, choose **Cluster** > **Services** > **Spark2x** > **Configurations**, click **All Configurations**, and search for the following parameter.

 
| Parameter                                                   | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | Default Value         |
 
| spark.sql.adaptive.enabled                                  | Specifies whether to enable the adaptive execution function.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | false                 |
|                                                             |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |                       |
|                                                             | Note: If AQE and Static Partition Pruning (DPP) are enabled at the same time, DPP takes precedence over AQE during SparkSQL task execution. As a result, AQE does not take effect.                                                                                                                                                                                                                                                                                                                                                                            |                       |
 
| spark.sql.optimizer.dynamicPartitionPruning.enabled         | The switch to enable DPP.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | true                  |
 
| spark.sql.adaptive.coalescePartitions.enabled               | If this parameter is set to **true** and **spark.sql.adaptive.enabled** is set to **true**, Spark combines partitions that are consecutively random played based on the target size (specified by **spark.sql.adaptive.advisoryPartitionSizeInBytes**) to prevent too many small tasks from being executed.                                                                                                                                                                                                                                                   | true                  |
 
| spark.sql.adaptive.coalescePartitions.initialPartitionNum   | Initial number of shuffle partitions before merge. The default value is the same as the value of **spark.sql.shuffle.partitions**. This parameter is valid only when **spark.sql.adaptive.enabled** and **spark.sql.adaptive.coalescePartitions.enabled** are set to **true**. This parameter is optional. The initial number of partitions must be a positive number.                                                                                                                                                                                        | 200                   |
 
| spark.sql.adaptive.coalescePartitions.minPartitionNum       | Minimum number of shuffle partitions after merge. If this parameter is not set, the default degree of parallelism (DOP) of the Spark cluster is used. This parameter is valid only when **spark.sql.adaptive.enabled** and **spark.sql.adaptive.coalescePartitions.enable** are set to **true**. This parameter is optional. The initial number of partitions must be a positive number.                                                                                                                                                                      | 1                     |
 
| spark.sql.adaptive.shuffle.targetPostShuffleInputSize       | Target size of a partition after shuffling. Spark 3.0 and later versions do not support this parameter.                                                                                                                                                                                                                                                                                                                                                                                                                                                       | 64MB                  |
 
| spark.sql.adaptive.advisoryPartitionSizeInBytes             | Size of a shuffle partition (unit: byte) during adaptive optimization (**spark.sql.adaptive.enabled** is set to **true**). This parameter takes effect when Spark aggregates small shuffle partitions or splits shuffle partitions where skew occurs.                                                                                                                                                                                                                                                                                                         | 64MB                  |
 
| spark.sql.adaptive.fetchShuffleBlocksInBatch                | Whether to obtain consecutive shuffle blocks in batches. For the same map job, reading consecutive shuffle blocks in batches can reduce I/Os and improve performance, instead of reading blocks one by one. Note that multiple consecutive blocks exist in a single read request only when **spark.sql.adaptive.enabled** and **spark.sql.adaptive.coalescePartitions.enabled** are set to **true**. This feature also relies on a relocatable serializer that uses cascading to support the codec and the latest version of the shuffle extraction protocol. | true                  |
 
| spark.sql.adaptive.localShuffleReader.enabled               | If the value of this parameter is **true** and the value of **spark.sql.adaptive.enabled** is **true**, Spark attempts to use the local shuffle reader to read shuffle data when shuffling of partitions is not required, for example, after sort-merge join is converted to broadcast-hash join.                                                                                                                                                                                                                                                             | true                  |
 
| spark.sql.adaptive.skewJoin.enabled                         | Specifies whether to enable the function of automatic processing of the data skew in join operations. The function is enabled when this parameter is set to **true** and **spark.sql.adaptive.enabled** is set to **true**.                                                                                                                                                                                                                                                                                                                                   | true                  |
 
| spark.sql.adaptive.skewJoin.skewedPartitionFactor           | This parameter is a multiplier used to determine whether a partition is a data skew partition. If the data size of a partition exceeds the value of this parameter multiplied by the median of the all partition sizes except this partition and exceeds the value of **spark.sql.adaptive.skewJoin.skewedPartitionThresholdInBytes**, this partition is considered as a data skew partition.                                                                                                                                                                 | 5                     |
 
| spark.sql.adaptive.skewJoin.skewedPartitionThresholdInBytes | If the partition size (unit: byte) is greater than the threshold as well as the product of the **spark.sql.adaptive.skewJoin.skewedPartitionFactor** value and the median partition size, skew occurs in the partition. Ideally, the value of this parameter should be greater than that of **spark.sql.adaptive.advisoryPartitionSizeInBytes.**.                                                                                                                                                                                                             | 256MB                 |
 
| spark.sql.adaptive.nonEmptyPartitionRatioForBroadcastJoin   | If the ratio of non-null partitions is less than the value of this parameter when two tables are joined, broadcast hash join cannot be properly performed regardless of the partition size. This parameter is valid only when **spark.sql.adaptive.enabled** is set to **true**.                                                                                                                                                                                                                                                                              | 0.2                   |
 
