# Spark SQL常用配置项说明
本章节为您介绍DLI 批作业SQL语法的常用配置项。
表1常用配置项 
| 名称                                               | 默认值       | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
|:---|:---|:---|
| spark.sql.files.maxRecordsPerFile                | 0         | 要写入单个文件的最大记录数。如果该值为零或为负，则没有限制。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| spark.sql.shuffle.partitions                     | 200       | 为连接或聚合过滤数据时使用的默认分区数。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| spark.sql.dynamicPartitionOverwrite.enabled      | false     | 当前配置设置为"false"时，DLI在覆盖写之前，会删除所有符合条件的分区。例如，分区表中有一个"2021-01"的分区，当使用INSERT OVERWRITE语句向表中写入"2021-02"这个分区的数据时，会把"2021-01"的分区数据也覆盖掉。 当前配置设置为"true"时，DLI不会提前删除分区，而是在运行时覆盖那些有数据写入的分区。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| spark.sql.files.maxPartitionBytes                | 134217728 | 读取文件时要打包到单个分区中的最大字节数。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| spark.sql.badRecordsPath                         | -         | Bad Records的路径。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| spark.sql.legacy.correlated.scalar.query.enabled | false     | - **该参数设置为true：** - 当子查询中数据不重复的情况下，执行关联子查询，不需要对子查询的结果去重。  - 当子查询中数据重复的情况下，执行关联子查询，会提示异常，必须对子查询的结果做去重处理，比如max(),min()。    - **该参数设置为false：** 不管子查询中数据重复与否，执行关联子查询时，都需要对子查询的结果去重，比如max(),min()，否则提示异常。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| spark.sql.keep.distinct.expandThreshold          | -         | - **参数说明：** 对于包含count(distinct)的多维分析（with cube）的查询场景，spark典型的执行计划是将cube使用expand算子来实现，但该操作会导致查询膨胀，为了避免出现查询膨胀，建议执行如下配置： - spark.sql.keep.distinct.expandThreshold： 默认值：-1，即使用Spark默认的expand算子。 设置具体数值：即代表定义了查询膨胀的阈值（例如512），超过该阈值count(distinct) 使用distinct聚合算子来执行，不再使用expand算子。   - spark.sql.distinct.aggregator.enabled：强制使用distinct聚合算子的开关。配置为true时不再根据spark.sql.keep.distinct.expandThreshold来判断。    - **适用场景：**包含count(distinct)的多维分析（with cube）的查询场景，可能包含多个count(distinct)，且包含cube/roll up  - **典型场景示例：** ``` SELECT a1, a2, count(distinct b), count(distinct c) FROM test_distinct group by a1, a2 with cube ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| spark.sql.distinct.aggregator.enabled            | false     | - **参数说明：** 对于包含count(distinct)的多维分析（with cube）的查询场景，spark典型的执行计划是将cube使用expand算子来实现，但该操作会导致查询膨胀，为了避免出现查询膨胀，建议执行如下配置： - spark.sql.keep.distinct.expandThreshold： 默认值：-1，即使用Spark默认的expand算子。 设置具体数值：即代表定义了查询膨胀的阈值（例如512），超过该阈值count(distinct) 使用distinct聚合算子来执行，不再使用expand算子。   - spark.sql.distinct.aggregator.enabled：强制使用distinct聚合算子的开关。配置为true时不再根据spark.sql.keep.distinct.expandThreshold来判断。    - **适用场景：**包含count(distinct)的多维分析（with cube）的查询场景，可能包含多个count(distinct)，且包含cube/roll up  - **典型场景示例：** ``` SELECT a1, a2, count(distinct b), count(distinct c) FROM test_distinct group by a1, a2 with cube ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| dli.jobs.sql.resubmit.enable                     | null      | 通过设置该参数可以控制在driver故障、队列重启时Spark SQL作业是否重新提交。 - false：禁用作业重试，所有类型的命令都不重新提交，一旦driver故障，作业将标记为失败（FAILED）。  - true：启用作业重试，即在driver故障时，所有类型的作业都将重新提交。 注意： 如果配置为true，在执行INSERT等幂等类型的操作时（例如insert into，load data、update），可能会导致数据一致性问题。即driver故障后作业重试，导致driver故障前已插入的数据被重复写入。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| spark.sql.dli.job.shareLevel                     | Queue     | 该配置项用于设置SQL语句的隔离级别，不同的隔离级别（job, user, project, queue）将决定SQL作业是由独立的Spark Driver和Executor执行，还是共享已经存在的Spark Driver和Executor。 - **job** : - 每个SQL作业都会独立启动一个Spark Driver和一组Executor来执行。  - 适用于需要完全隔离的作业，确保每个作业的执行环境完全独立。    - **user:** - 如果已经有该用户启动的Spark Driver并且该Driver还能继续提交任务，那么新的SQL作业会提交到这个已存在的Driver上执行。  - 如果没有已存在的Driver或者现有Driver无法继续提交任务，则会为该用户新启动一个Spark Driver。  - 适用于同一用户的多个作业需要共享资源的场景。    - **project:** - 如果已经有该项目启动的Spark Driver并且该Driver还能继续提交任务，那么新的SQL作业会提交到这个已存在的Driver上执行。  - 如果没有已存在的Driver或者现有Driver无法继续提交任务，则会为该项目新启动一个Spark Driver。  - 适用于同一项目内的多个作业需要共享资源的场景。    - **queue:** - 如果已经有该队列启动的Spark Driver并且该Driver还能继续提交任务，那么新的SQL作业会提交到这个已存在的Driver上执行。  - 如果没有已存在的Driver或者现有Driver无法继续提交任务，则会为该队列新启动一个Spark Driver。  - 适用于按队列管理资源的场景，可以更细粒度地控制资源分配。     说明： 上述所有隔离级别所能启动的最多spark driver数量(最大spark driver实例数)以及每个spark driver最多并发执行的SQL数量(单spark driver实例最大并发数)，可以在队列属性中进行设置。 [设置队列属性](https://support.huaweicloud.com/usermanual-dli/dli_01_0563.html) |