
# Hudi常见参数配置
Hudi作为Apache开源的数据湖表格式，支持ACID事务、增量查询和时间旅行等能力，广泛应用于大数据场景下的近实时数据入湖与分析。在MRS（MapReduce Service）大数据平台中，Hudi的写入性能、存储效率和查询速度受多个关键参数影响。当默认配置无法满足特定业务场景的需求时，开发人员和运维工程师需要根据数据量规模、写入频率、查询模式以及集群资源情况，对Hudi参数进行针对性调优。
本章节介绍Hudi重要配置的详细信息，适用于使用MRS集群进行Hudi数据湖开发和运维的大数据工程师。典型调优场景包括：流式写入性能优化、小文件合并与存储空间管理、COW/MOR表Compaction策略调整、Clustering查询加速、Bloom Filter索引效率优化等。更多配置请参考Hudi官网<https://hudi.apache.org/docs/overview>。
#### 参数配置方法
Hudi参数可通过以下方式配置：
1. **Spark SQL中通过SET命令配置**：在执行Hudi写入或查询SQL前，使用SET hoodie.xxx=yyy;命令设置参数，仅对当前会话生效。
2. **在Spark客户端配置文件中设置**：在spark-defaults.conf或hoodie-defaults.conf中添加参数配置，对所有会话生效。
3. **在代码中通过DataFrame选项配置**：在使用DataFrame API写入Hudi表时，通过.option("hoodie.xxx", "yyy")方式设置参数。
 
#### 写入操作配置
 表1写入操作重要配置项 
| 参数                                              | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | 默认值                                                     |
|:---|:---|:---|
| hoodie.datasource.write.table.name              | 指定写入数据的Hudi表名。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | 无                                                       |
| hoodie.datasource.write.operation               | 写Hudi表数据时指定的操作类型，当前支持upsert、delete、insert、bulk_insert等方式。 - upsert：更新插入混合操作。  - delete：删除操作。  - insert：插入操作。  - bulk_insert：用于初始建表导入数据， 注意初始建表禁止使用upsert、insert方式。  - insert_overwrite：对静态分区执行insert overwrite。  - insert_overwrite_table：动态分区执行insert overwrite，该操作并不会立刻删除全表做overwrite，会逻辑上重写Hudi表的元数据，无用数据后续由hudi的clean机制清理。效率比bulk_insert加overwrite高。   | upsert                                                  |
| hoodie.datasource.write.table.type              | 指定Hudi表类型，一旦这个表类型被指定，后续禁止修改该参数。表类型分为COPY_ON_WRITE和MERGE_ON_READ。 - COPY_ON_WRITE：写时复制表也简称cow表，使用parquet文件存储数据，内部的更新操作需要通过重写原始parquet文件完成。  - MERGE_ON_READ：读时合并表也简称mor表，使用列格式parquet和行格式Avro两种方式混合存储数据。其中parquet格式文件用于存储基础数据，Avro格式文件（也可叫做log文件）用于存储增量数据。                                                                                                                                                                                                                                                                                                                                                                     | COPY_ON_WRITE                                           |
| hoodie.datasource.write.precombine.field        | 该值用于在写之前对具有相同的key行进行合并去重。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 指定为具体的表字段                                               |
| hoodie.datasource.write.payload.class           | 在更新过程中，该类用于提供方法将要更新的记录和更新的记录做合并，该实现可插拔，如要实现自己的合并逻辑，可自行编写。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | org.apache.hudi.common.model.DefaultHoodieRecordPayload |
| hoodie.datasource.write.recordkey.field         | 用于指定Hudi的主键，Hudi表要求有唯一主键。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 指定为具体的表字段                                               |
| hoodie.datasource.write.partitionpath.field     | 用于指定分区键，该值配合hoodie.datasource.write.keygenerator.class使用可以满足不同的分区场景。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | 无                                                       |
| hoodie.datasource.write.hive_style_partitioning | 用于指定分区方式是否和Hive保持一致。Hive分区将数据按分区字段的值存储在不同的目录中，使得数据更容易管理和查询。建议该值设置为true。 - true：表示指定分区方式和Hive保持一致。  - false：表示指定分区方式和Hive不保持一致。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | true                                                    |
| hoodie.datasource.write.keygenerator.class      | 配合hoodie.datasource.write.partitionpath.field，hoodie.datasource.write.recordkey.field产生主键和分区方式。 说明： 写入设置KeyGenerator与表保存的参数值不一致时将提示需要保持一致。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | org.apache.hudi.keygen.ComplexKeyGenerator              |
   
#### 同步Hive表配置
表2同步Hive表参数配置 
| 参数                                                    | 描述                                                                                                                                                                                                                                                                                                                                                                                     | 默认值                                                         |
|:---|:---|:---|
| hoodie.datasource.hive_sync.enable                    | Hudi写入数据时，是否启用Hive元数据同步。启用此配置后，Hudi会在写入数据时自动同步表的元数据到Hive Metastore，使得 Hive可以直接查询Hudi表。建议该值设置为true，统一使用Hive管理Hudi表。 - true：表示启用Hive元数据同步。  - false：表示不启用Hive元数据同步。                             | false                                                       |
| hoodie.datasource.hive_sync.database                  | 启用Hive元数据同步后，指定同步给Hive的数据库名。                                                                                                                                                                                                                                                                                                                                                           | default                                                     |
| hoodie.datasource.hive_sync.table                     | 启用Hive元数据同步后，指定同步给Hive的表名。建议这个值和hoodie.datasource.write.table.name保证一致。                                                                                                                                                                                                                                                                                                                | unknown                                                     |
| hoodie.datasource.hive_sync.username                  | 启用Hive元数据同步后，用于指定连接Hive Metastore的用户名。                                                                                                                                                                                                                                                                                                                                                 | hive                                                        |
| hoodie.datasource.hive_sync.password                  | 启用Hive元数据同步后，用于指定连接Hive Metastore的密码。                                                                                                                                                                                                                                                                                                                                                  | hive                                                        |
| hoodie.datasource.hive_sync.jdbcurl                   | 启用Hive元数据同步后，连接Hive Metastore的JDBC URL。                                                                                                                                                                                                                                                                                                                                                | ""                                                          |
| hoodie.datasource.hive_sync.use_jdbc                  | 是否使用Hive JDBC方式连接Hive同步Hudi表信息。 建议该值设置为false，设置为false后JDBC连接相关配置无效。 - true：表示使用Hive JDBC方式连接Hive同步Hudi表信息。  - false：表示不使用Hive JDBC方式连接Hive同步Hudi表信息。   | true                                                        |
| hoodie.datasource.hive_sync.partition_fields          | 用于决定Hive分区列。通过分区，可以显著提高查询性能，特别是对于大数据集，因为查询时可以只扫描相关的分区目录。                                                                                                                                                                                                                                                                                                                               | ""                                                          |
| hoodie.datasource.hive_sync.partition_extractor_class | 用于提取Hudi分区列值，将其转换成Hive分区列。                                                                                                                                                                                                                                                                                                                                                             | org.apache.hudi.hive.SlashEncodedDayPartitionValueExtractor |
| hoodie.datasource.hive_sync.support_timestamp         | 当Hudi表存在timestamp类型字段时，需指定此参数为true，以实现同步timestamp类型到Hive元数据中。 该值默认为false，默认将timestamp类型同步为bigInt，默认情况可能导致使用SQL查询包含timestamp类型字段的Hudi表出现错误。                                                                                                                                                                                                             | true                                                        |
   
#### index相关配置
表3index相关参数配置 
| 参数                                       | 描述                                                                                                                                                                                                                                                                                                                                 | 默认值         |
|:---|:---|:---|
| hoodie.index.class                       | 用户自定义索引的全路径名，索引类必须为HoodieIndex的子类，当指定该配置时，其会优先于hoodie.index.type配置。                                                                                                                                                                                                                                                                | ""          |
| hoodie.index.type                        | 使用的索引类型，默认为布隆过滤器。可能的选项是\[BLOOM \| HBASE \| GLOBAL_BLOOM \| SIMPLE \| GLOBAL_SIMPLE\] 。 布隆过滤器消除了对外部系统的依赖，并存储在Parquet数据文件的页脚中。                                                                                                                                                                                                       | BLOOM       |
| hoodie.index.bloom.num_entries           | 存储在布隆过滤器中的条目数。 假设maxParquetFileSize为128MB，averageRecordSize为1024B，因此，一个文件中的记录总数约为130K。 默认值（60000）大约是此近似值的一半。 注意： 将此值设置的太低，将产生很多误报，并且索引查找将必须扫描比其所需的更多的文件；如果将其设置的非常高，将线性增加每个数据文件的大小（每50000个条目大约4KB）。                                                                     | 60000       |
| hoodie.index.bloom.fpp                   | 根据条目数允许的错误率。 用于计算应为布隆过滤器分配多少位以及哈希函数的数量。通常将此值设置的很低（默认值0.000000001），在磁盘空间上进行权衡以降低误报率。                                                                                                                                                                                                                                                | 0.000000001 |
| hoodie.bloom.index.parallelism           | 指定布隆过滤器索引查找的并行度，其中涉及Spark Shuffle。 增加并行度可以提高索引构建的性能，但也会增加资源消耗。默认情况下，根据输入的工作负载特征自动计算的。                                                                                                                                                                                                              | 0           |
| hoodie.bloom.index.prune.by.ranges       | 是否在构建布隆过滤器索引时通过范围修剪来优化索引。从文件框定信息，可以加快索引查找的速度。 如果键具有单调递增的前缀，例如时间戳，则更加有用。 - true：启用范围修剪。  - false：禁用范围修剪。                                    | true        |
| hoodie.bloom.index.use.caching           | 用于指定是否在构建和使用布隆过滤器索引时启用缓存。启用缓存，将通过减少用于计算并行度或受影响分区的IO来缓存输入的RDD以加快索引查找，从而提高查询性能，特别是在频繁查询相同数据的情况下。 - true：启用缓存。  - false：禁用缓存。                 | true        |
| hoodie.bloom.index.use.treebased.filter  | 用于指定是否在布隆过滤器索引中启用基于间隔树（Tree-based Filter）的文件过滤优化。与暴力模式相比，此模式可根据键范围加快文件过滤速度。 - true：启用基于间隔树的文件过滤优化。  - false：禁用基于间隔树的文件过滤优化。                | true        |
| hoodie.bloom.index.bucketized.checking   | 用于指定是否在布隆过滤器索引中启用桶式布隆过滤。启用桶式布隆过滤可以减少了在基于排序的布隆索引查找中看到的偏差。 - true：启用桶式布隆过滤。  - false：禁用桶式布隆过滤。                                          | true        |
| hoodie.bloom.index.keys.per.bucket       | 仅在启用bloomIndexBucketizedChecking并且索引类型为bloom的情况下适用。 此配置控制"存储桶"的大小，该大小可跟踪对单个文件进行的记录键检查的次数，并且是分配给执行布隆过滤器查找的每个分区的工作单位。 较高的值将分摊将布隆过滤器读取到内存的固定成本。                                                                                                                                                           | 10000000    |
| hoodie.bloom.index.update.partition.path | 用于指定在使用索引类型为GLOBAL_BLOOM时，是否在更新记录时更新分区路径。 - true：当对一个已有记录执行包含分区路径的更新操作时，将会导致把新记录插入到新分区，而把原有记录从旧分区里删除。  - false：只对旧分区的原有记录进行更新。   | true        |
| hoodie.index.hbase.zkquorum              | 仅在索引类型为HBase时适用，必填选项。要连接的HBase ZooKeeper Quorum URL。                                                                                                                                                                                                                                                                               | 无           |
| hoodie.index.hbase.zkport                | 仅在索引类型为HBase时适用，必填选项。要连接的HBase ZooKeeper Quorum端口。                                                                                                                                                                                                                                                                                 | 无           |
| hoodie.index.hbase.zknode.path           | 仅在索引类型为HBase时适用，必填选项。这是根znode，它将包含HBase创建及使用的所有znode。                                                                                                                                                                                                                                                                              | 无           |
| hoodie.index.hbase.table                 | 仅在索引类型为HBase时适用，必填选项。HBase表名称，用作索引。Hudi将row_key和\[partition_path, fileID, commitTime\]映射存储在表中。                                                                                                                                                                                                                                     | 无           |
   
#### 存储配置
表4存储参数配置 
| 参数                                          | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 默认值                      |
|:---|:---|:---|
| hoodie.parquet.max.file.size                | Hudi写阶段生成的parquet文件的目标大小。对于DFS，这需要与基础文件系统块大小保持一致，以实现最佳性能。                                                                                                                                                                                                                                                                                                                                                                                                                                             | 120 \* 1024 \* 1024 byte |
| hoodie.parquet.block.size                   | parquet页面大小，页面是parquet文件中的读取单位，在一个块内，页面被分别压缩。                                                                                                                                                                                                                                                                                                                                                                                                                                                         | 120 \* 1024 \* 1024 byte |
| hoodie.parquet.compression.ratio            | 当Hudi尝试调整新parquet文件的大小时，预期对parquet数据进行压缩的比例。 如果bulk_insert生成的文件小于预期大小，请增加此值。                                                                                                                                                                                                                                                                                                                                                                                                                          | 0.1                      |
| hoodie.parquet.compression.codec            | parquet压缩编解码方式名称，默认值为snappy。可能的选项是gzip、snappy、uncompressed、lzo。 - snappy：一种快速的压缩算法，适用于大多数场景。  - gzip：提供较高的压缩比，但压缩和解压速度较慢。  - uncompressed：不进行压缩。  - lzo：提供较高的压缩比，但需要额外的库支持。   | snappy                   |
| hoodie.logfile.max.size                     | 用于指定Hudi日志文件的最大值。这是在将日志文件移到下一个版本之前允许的最大值。                                                                                                                                                                                                                                                                                                                                                                                                                                                             | 1GB                      |
| hoodie.logfile.data.block.max.size          | LogFile数据块的最大值。这是允许将单个数据块附加到日志文件的最大值。 这有助于确保附加到日志文件的数据被分解为可调整大小的块，以防止发生OOM错误。此大小应大于JVM内存。                                                                                                                                                                                                                                                                                                                                                                                                             | 256MB                    |
| hoodie.logfile.to.parquet.compression.ratio | 随着记录从日志文件移动到parquet，预期会进行额外压缩的比例。 用于merge_on_read存储，以将插入内容发送到日志文件中并控制压缩parquet文件的大小。                                                                                                                                                                                                                                                                                                                                                                                                                  | 0.35                     |
   
 #### compaction\&cleaning配置
表5compaction\&cleaning参数配置 
| 参数                                           | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | 默认值                                                                                                               |
|:---|:---|:---|
| hoodie.clean.automatic                       | 用于控制是否自动执行数据清理操作。数据清理是 Hudi 中的一个重要功能，用于删除过期的或不再需要的数据文件，以优化存储空间和查询性能。 - true：Hudi会在每次写入操作后自动执行数据清理操作。  - false：需要手动执行数据清理操作。                                                                                                                                                                                                                                                                                                                                                                                                  | true                                                                                                              |
| hoodie.cleaner.policy                        | Hudi使用的清理策略。Hudi将删除旧版本的parquet文件以回收空间。 任何引用此版本文件的查询和计算都将失败。建议确保数据保留的时间超过最大查询执行时间。 清理策略如下： - KEEP_LATEST_FILE_VERSIONS：保留最新的文件版本，删除旧的文件版本。  - KEEP_LATEST_COMMITS：保留最新的提交，删除旧的提交。  - KEEP_LATEST_FILE_VERSIONS_BY_FILE_SIZE：保留最新的文件版本，但根据文件大小进行优化。  - KEEP_LATEST_COMMITS_AND_FILE_VERSIONS：结合 KEEP_LATEST_COMMITS 和 KEEP_LATEST_FILE_VERSIONS 策略，保留最新的提交和文件版本。   | KEEP_LATEST_COMMITS                                                                                               |
| hoodie.cleaner.commits.retained              | 在Hudi中，每次写入操作（如插入、更新或删除）都会生成一个新的提交（commit）。每个提交都有一个唯一的提交时间戳（commit time），用于标识该次写入操作。 该参数用于Hudi清理操作中保留的commit数。当commit数超过这个值时，Hudi会删除最早的commit及其相关数据文件，以释放存储空间。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 10                                                                                                                |
| hoodie.keep.max.commits                      | 在Hudi中，每次写入操作都会生成一个新的提交。每个提交都有一个唯一的提交时间戳（commit time），用于标识该次写入操作。 Hudi支持时间旅行查询（time travel queries），允许用户查询数据在特定时间点的状态。为了支持这一功能，Hudi会保留多个历史版本的数据。 该参数用于指定Hudi保留的最大提交数。当提交数超过这个值时，Hudi会删除最早的提交及其相关数据文件，以释放存储空间。                                                                                                                                                                                                                                                                                                                                                                                                                                              | 30                                                                                                                |
| hoodie.keep.min.commits                      | 归档操作至少保留的commit数。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 20                                                                                                                |
| hoodie.commits.archival.batch                | 控制着批量读取并一起归档的提交即时的数量。通过调整这个参数，可以控制归档操作的频率和每次归档的记录数量。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | 10                                                                                                                |
| hoodie.parquet.small.file.limit              | 该值应小于maxFileSize，如果将其设置为0，会关闭此功能。由于批处理中分区中插入记录的数量众多，总会出现小文件。Hudi提供了一个选项，可以通过将对该分区中的插入作为对现有小文件的更新来解决小文件的问题。此处的大小是被视为"小文件大小"的最小文件大小。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | 104857600 B                                                                                                       |
| hoodie.copyonwrite.insert.split.size         | 插入写入并行度。为单个分区的总共插入次数。写出100MB的文件，至少1KB大小的记录，意味着每个文件有100K记录。默认值是超额配置为500K。 为了改善插入延迟，请对其进行调整以匹配单个文件中的记录数。将此值设置为较小的值将导致文件变小（尤其是当compactionSmallFileSize为0时）。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | 500000                                                                                                            |
| hoodie.copyonwrite.insert.auto.split         | Hudi是否应该基于最后24个提交的元数据动态计算insertSplitSize，默认关闭。 - true：Hudi会在插入数据时，基于最后24个提交的元数据动态计算insertSplitSize，自动拆分大文件，以避免生成过大的文件。  - false：插入数据时保持文件的完整性，不进行自动拆分。                                                                                                                                                                                                                                                                                                                                                                        | true                                                                                                              |
| hoodie.copyonwrite.record.size.estimate      | 平均记录大小。如果指定，Hudi将使用它，并且不会基于最后24个提交的元数据动态地计算。 没有默认值设置。这对于计算插入并行度以及将插入打包到小文件中至关重要。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | 1024                                                                                                              |
| hoodie.compact.inline                        | 用于控制是否在写操作中启用内联（inline）压缩。压缩是Hudi中用于优化存储和性能的重要机制，通过合并小文件和删除冗余数据来减少文件数量和提高读取性能。 内联压缩（Inline Compaction）: 在写操作（如插入、更新、删除）过程中自动进行的压缩操作。这种方式可以减少单独的压缩任务，提高整体的写入性能。 异步压缩（Async Compaction）: 通过单独的压缩任务在后台进行的压缩操作。这种方式可以更灵活地控制压缩的频率和时间，但可能会增加系统的复杂性。 - true：在写操作中摄取本身触发压缩。  - false：在写操作中不进行压缩。                                                                                                                                                                | true                                                                                                              |
| hoodie.compact.inline.max.delta.commits      | 用于控制在内联压缩过程中最多包含的增量提交数。这个参数在启用内联压缩时非常重要，因为它决定了在一次写操作中可以合并多少个增量提交。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 5                                                                                                                 |
| hoodie.compaction.lazy.block.read            | 当CompactedLogScanner合并所有日志文件时，此配置有助于选择是否应延迟读取日志块。 - true：使用I/O密集型延迟块读取（低内存使用）。  - false：使用内存密集型立即块读取（高内存使用）。                                                                                                                                                                                                                                                                                                                                                                                                           | true                                                                                                              |
| hoodie.compaction.reverse.log.read           | HoodieLogFormatReader会从pos=0到pos=file_length向前读取日志文件。如果此配置设置为true，则Reader会从pos=file_length到pos=0反向读取日志文件。如果设置为false，则按顺序读取日志文件。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | false                                                                                                             |
| hoodie.cleaner.parallelism                   | 在Hudi中，清理操作用于删除不再需要的数据文件，例如过期的增量文件或冗余的基线文件。通过调整该参数值，可以控制清理操作的并行度，从而影响清理操作的性能和资源使用。 如果清理变慢，请增加此值。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 200                                                                                                               |
| hoodie.compaction.strategy                   | 用来决定在每次压缩运行期间选择要压缩的文件组的压缩策略。默认情况下，Hudi选择具有累积最多未合并数据的日志文件。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | org.apache.hudi.table.action.compact.strategy. LogFileSizeBasedCompactionStrategy |
| hoodie.compaction.target.io                  | LogFileSizeBasedCompactionStrategy的压缩运行期间要花费的MB量。当压缩以内联模式运行时，此值有助于限制摄取延迟。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 500 \* 1024 MB                                                                                                    |
| hoodie.compaction.daybased.target.partitions | 由org.apache.hudi.io.compact.strategy.DayBasedCompactionStrategy使用，表示在压缩运行期间要压缩的最新分区数。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 10                                                                                                                |
| hoodie.compaction.payload.class              | 这需要与插入/插入更新过程中使用的类相同。就像写入一样，压缩也使用记录有效负载类将日志中的记录彼此合并，再次与基本文件合并，并生成压缩后要写入的最终记录。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | org.apache.hudi.common.model.DefaultHoodieRecordPayload                                                           |
| hoodie.schedule.compact.only.inline          | 用于控制在内联压缩时，是否只生成压缩计划。在hoodie.compact.inline=true时有效。 - true：只在内联压缩中生成压缩任务。  - false：在写操作中和单独的压缩任务中都生成压缩任务。                                                                                                                                                                                                                                                                                                                                                                                                                   | false                                                                                                             |
| hoodie.run.compact.only.inline               | 通过Sql执行run compaction命令时，是否只执行压缩操作，压缩计划不存在时直接退出。 - true：只会在写操作中执行压缩任务，而不会启动单独的异步压缩任务。  - false：在写操作中和单独的压缩任务中都进行压缩任务。                                                                                                                                                                                                                                                                                                                                                                                                   | false                                                                                                             |
   
#### 聚类（Clustering）配置
Clustering配置适用于MRS 3.2.0-LTS及之后版本。
表6Clustering参数配置 
| 参数                                                    | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 默认值                                                                                  |
|:---|:---|:---|
| hoodie.clustering.inline                              | 聚类即数据布局，该服务可重新组织数据以提高查询性能，也不会影响摄取速度。Hudi 聚类分为同步执行聚类和异步执行聚类。 建议低吞吐、小数据量、延迟敏感场景可开启，高吞吐流写场景关闭。 - true：启用同步执行聚类。  - false：不启用同步执行聚类。                                                                                                                                                                                                                                                                                                                                                                                                           | false                                                                                |
| hoodie.clustering.inline.max.commits                  | 同步执行聚类中，触发聚类的commit数，即每间隔多少个写入Commit触发一次聚类。 这个参数可以限制同步执行聚类的范围，避免在单次写入操作中处理过多的commit，从而影响写入性能。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | 4                                                                                    |
| hoodie.clustering.async.enabled                       | 是否启用异步执行聚类，通过异步执行聚类操作，可以减少写入延迟，提高写入性能。 建议高吞吐流处理、大批量写入优先开启。 **此参数仅适用于MRS 3.3.0-LTS及之后版本。** - true：启用异步执行聚类。  - false：不启用异步执行聚类。                                                                                                                                                                                                                                                                                                                                                                                   | false                                                                                |
| hoodie.clustering.async.max.commits                   | 异步执行聚类中，触发聚类的commit数。 数据增长快可调小（如2），压力大则建议调大（如 6\~10）。 **此参数仅适用于MRS 3.3.0-LTS及之后版本。**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | 4                                                                                    |
| hoodie.clustering.plan.strategy.target.file.max.bytes | 指定聚类后每个文件大小最大值。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | 1024 \* 1024 \* 1024 byte                                                            |
| hoodie.clustering.plan.strategy.small.file.limit      | 小于该大小的文件会被聚类。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | 300 \* 1024 \* 1024 byte                                                             |
| hoodie.clustering.plan.strategy.sort.columns          | 指定聚类重排的排序字段，多字段用英文逗号分隔。 字段名小写、下划线命名，禁止大写，避免跨引擎兼容问题，多个字段之间无空格，仅用英文逗号分隔。 - 取值为空：聚类只合并小文件，不对数据排序，聚类速度最快，无查询优化效果。  - 取值为单字段：按该字段全局排序，适合单列过滤/范围查询场景。  - 取值为多字段：按字段顺序组合排序，开启z-order/hilbert后，转为多维布局优化。                                                                                                                                                                                                                                                                                 | 无                                                                                    |
| hoodie.layout.optimize.enable                         | 控制是否开启Hudi数据布局优化。 - false：不启用多维布局优化，仅做普通线性排序，聚类计算开销小、速度快，适合单列过滤为主、高吞吐流表、集群资源紧张场景。  - true：开启布局优化，配合"hoodie.layout.optimize.strategy"参数选择排序算法，使用z-order、hilbert算法时需要开启。                                                                                                                                                                                                                                                                                                                                                                                                   | false                                                                                |
| hoodie.layout.optimize.strategy                       | 指定Hudi聚类时的数据重排算法，用于优化多列过滤、查询裁剪效率。 - linear：默认，线性排序，按"hoodie.clustering.plan.strategy.sort.columns"配置的字段依次单维度排序，先按第一列排，同值再按第二列，以此类推。 适用于仅按单个核心字段做过滤/分区查询、追求聚类执行速度、集群资源紧张等场景。   - z-order：对多个排序字段做多维交织编码，将多维数据映射到一维，让不同维度的相近值尽量落在同一个数据块/文件中。 适用于日常多列组合过滤、查询，查询维度多的主流场景。   - hilbert：希尔伯特曲线做多维映射，相比z-order，数据局部性更好，多维数据聚集效果更优。 适用于高并发、高频多列复杂组合查询，对查询性能要求极高的场景。    | linear                                                                               |
| hoodie.clustering.plan.strategy.class                 | 筛选FileGroup进行聚类的策略类。 - SparkSizeBasedClusteringPlanStrategy：默认，按文件大小筛选，筛选小于hoodie.clustering.plan.strategy.small.file.limit阈值的文件，适用全局小文件合并、无强时间过滤需求。  - SparkRecentDaysClusteringPlanStrategy：按最近天数聚类。  - SparkSingleFileSortPlanStrategy：对数据做全局排序并输出少量/单个文件。                                                                                                                                                                                                                                                     | org.apache.hudi.client.clustering.plan.strategy.SparkSizeBasedClusteringPlanStrategy |
| hoodie.clustering.execution.strategy.class            | 执行聚类的策略类（RunClusteringStrategy的子类），用以定义群集计划的执行方式。 默认类按指定的列对计划中的文件组进行排序，同时满足配置的目标文件大小。 **一般情况下指定"hoodie.clustering.plan.strategy.class"为SparkRecentDaysClusteringPlanStrategy或者SparkSizeBasedClusteringPlanStrategy时，"hoodie.clustering.execution.strategy.class"不需要指定。但当"hoodie.clustering.plan.strategy.class"为SparkSingleFileSortPlanStrategy时，需要指定"hoodie.clustering.execution.strategy.class"为SparkSingleFileSortExecutionStrategy。**                                                                                                                                                                                                                                                                     | org.apache.hudi.client.clustering.run.strategy.SparkSortAndSizeExecutionStrategy     |
| hoodie.clustering.plan.strategy.max.num.groups        | 设置执行聚类时最多选择多少个FileGroup，该值越大并发度越大。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 30                                                                                   |
| hoodie.clustering.plan.strategy.max.bytes.per.group   | 设置执行聚类时每个FileGroup最多有多少数据参与。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 2 \* 1024 \* 1024 \* 1024 byte                                                       |
   
#### 常见问题
- **Q：参数配置后不生效如何排查？**
  A：请检查参数配置方式是否正确。通过Spark SQL SET命令配置的参数仅对当前会话生效，如需全局生效请在配置文件中设置。同时确认参数名称拼写无误，部分参数需要重启Spark服务才能生效。
  

- **Q：Hudi表类型创建后能否修改？**
  A：不能。hoodie.datasource.write.table.type参数在表创建时指定后即固定，后续禁止修改。如需更换表类型，需新建表并迁移数据。
  
- **Q：Compaction失败如何处理？**
  A：常见原因包括：JVM内存不足（请调大hoodie.logfile.data.block.max.size或增加executor内存）、Spark任务超时（请增加hoodie.compaction.target.io或调整spark.task.timeout）、日志文件损坏（请通过Hudi CLI执行repair操作）。
  
- **Q：Clustering执行后查询性能没有提升？**
  A：请检查hoodie.clustering.plan.strategy.sort.columns是否配置了实际查询中常用的过滤字段。如果配置为空，聚类仅合并小文件但不排序，查询性能提升有限。建议根据查询模式选择合适的排序字段。
  
 
#### 相关文档
- 了解Hudi写入性能、查询性能和存储优化的最佳实践，请参考[Hudi性能调优](https://support.huaweicloud.com/cmpntguide-lts-mrs/mrs_01_24039.html)。
- 了解COW和MOR表类型的详细区别和选型建议，请参考[Hudi表概述](https://support.huaweicloud.com/cmpntguide-lts-mrs/mrs_01_24103.html)。
- 了解聚类（Clustering）的原理和配置方法，请参考[Hudi Clustering操作说明](https://support.huaweicloud.com/cmpntguide-lts-mrs/mrs_01_24088.html)。
 
