diff --git a/.translation-init b/.translation-init
index 4aeec2c493..1a9924ba12 100644
--- a/.translation-init
+++ b/.translation-init
@@ -1 +1 @@
-Translation initialization: 2025-08-18T07:47:46.585026
+Translation initialization: 2025-08-19T14:40:33.705590
diff --git a/docs/cn/sql-reference/10-sql-commands/00-ddl/20-workload-group/create-workload-group.md b/docs/cn/sql-reference/10-sql-commands/00-ddl/20-workload-group/create-workload-group.md
index 9f936737e2..3b0ec5c2e2 100644
--- a/docs/cn/sql-reference/10-sql-commands/00-ddl/20-workload-group/create-workload-group.md
+++ b/docs/cn/sql-reference/10-sql-commands/00-ddl/20-workload-group/create-workload-group.md
@@ -5,7 +5,7 @@ import FunctionDescription from '@site/src/components/FunctionDescription';
 
 <FunctionDescription description="引入或更新于：v1.2.743"/>
 
-创建一个具有指定配额设置的工作负载组（Workload Group）。工作负载组（Workload Group）通过与用户绑定来控制资源分配和查询（Query）并发。当用户提交查询（Query）时，系统会根据用户所属的工作负载组（Workload Group）自动应用相应的资源限制。
+创建具有指定配额设置的工作负载组（Workload Group）。工作负载组通过与用户绑定来控制资源分配和查询并发。当用户提交查询时，系统会根据用户所属的组应用相应限制。
 
 ## 语法
 
@@ -16,13 +16,13 @@ CREATE WORKLOAD GROUP [IF NOT EXISTS] <group_name>
 
 ## 参数
 
-| 参数                   | 类型             | 是否必需 | 默认值      | 描述                                                                         |
-|------------------------|------------------|----------|-------------|------------------------------------------------------------------------------|
-| `cpu_quota`            | string           | 否       | (无限制)    | CPU 资源配额，以百分比字符串表示（例如 `"20%"`）                             |
-| `query_timeout`        | duration         | 否       | (无限制)    | 查询（Query）超时时长（单位：`s`/`sec`=秒，`m`/`min`=分钟，`h`/`hour`=小时，`d`/`day`=天，`ms`=毫秒，无单位=秒） |
-| `memory_quota`         | string 或 integer | 否       | (无限制)    | 工作负载组（Workload Group）的最大内存使用限制（百分比或绝对值）             |
-| `max_concurrency`      | integer          | 否       | (无限制)    | 工作负载组（Workload Group）的最大并发数                                     |
-| `query_queued_timeout` | duration         | 否       | (无限制)    | 工作负载组（Workload Group）超出最大并发时的最大排队等待时间（单位：`s`/`sec`=秒，`m`/`min`=分钟，`h`/`hour`=小时，`d`/`day`=天，`ms`=毫秒，无单位=秒） |
+| 参数                   | 类型            | 是否必需 | 默认值      | 描述                                                                                                                                                                                          |
+|------------------------|-----------------|----------|-------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `cpu_quota`            | string          | 否       | （无限制）  | CPU 资源配额，以百分比字符串表示（例如 `"20%"`）                                                                                                                                              |
+| `query_timeout`        | duration        | 否       | （无限制）  | 查询超时时长（单位：`s`/`sec`=秒，`m`/`min`=分钟，`h`/`hour`=小时，`d`/`day`=天，`ms`=毫秒，无单位=秒）                                                                                             |
+| `memory_quota`         | string 或 integer | 否       | （无限制）  | 工作负载组的最大内存使用限制（百分比或绝对值）                                                                                                                                                |
+| `max_concurrency`      | integer         | 否       | （无限制）  | 工作负载组的最大并发数                                                                                                                                                                        |
+| `query_queued_timeout` | duration        | 否       | （无限制）  | 当工作负载组超过最大并发数时的最大排队等待时间（单位：`s`/`sec`=秒，`m`/`min`=分钟，`h`/`hour`=小时，`d`/`day`=天，`ms`=毫秒，无单位=秒） |
 
 ## 示例
 
@@ -39,17 +39,20 @@ WITH cpu_quota = '70%', memory_quota = '80%', max_concurrency = 10;
 
 ### 用户分配
 
-用户必须分配到工作负载组（Workload Group）才能启用资源限制。当用户执行查询（Query）时，系统会自动应用该工作负载组（Workload Group）的限制。
+用户必须被分配到工作负载组才能启用资源限制。当用户执行查询时，系统会自动应用工作负载组的限制。
 
 ```sql
--- 创建并分配用户
+-- 创建用户并授予权限
 CREATE USER analytics_user IDENTIFIED BY 'password123';
+GRANT ALL ON *.* TO analytics_user;
+
+-- 将用户分配到工作负载组
 ALTER USER analytics_user WITH SET WORKLOAD GROUP = 'interactive_queries';
 
--- 重新分配到不同工作负载组
+-- 重新分配到不同的工作负载组
 ALTER USER analytics_user WITH SET WORKLOAD GROUP = 'batch_processing';
 
--- 从工作负载组移除（用户将使用默认无限制资源）
+-- 从工作负载组中移除（用户将使用默认的无限制资源）
 ALTER USER analytics_user WITH UNSET WORKLOAD GROUP;
 
 -- 检查用户的工作负载组
@@ -59,30 +62,30 @@ DESC USER analytics_user;
 ## 资源配额归一化
 
 ### 配额限制
-- 每个工作负载组（Workload Group）的 `cpu_quota` 和 `memory_quota` 最高可设为 `100%` (1.0)
-- 所有工作负载组（Workload Group）的配额总和可超过 100%
-- 实际资源分配会基于相对比例进行**归一化**
+- 每个工作负载组的 `cpu_quota` 和 `memory_quota` 最高可设置为 `100%` (1.0)。
+- 所有工作负载组的配额总和可以超过 100%。
+- 实际的资源分配将根据相对比例进行**归一化**。
 
-### 配额归一化原理
+### 配额归一化工作原理
 
-资源按各组配额占总配额的比例分配：
+资源根据每个组的配额相对于总配额的比例进行分配：
 
 ```
-实际分配 = (组配额) / (所有组配额总和) × 100%
+实际分配比例 = (组配额) / (所有组配额之和) × 100%
 ```
 
 **示例 1：总配额 = 100%**
-- 组 A：30% 配额 → 获得 30% 资源 (30/100)
-- 组 B：70% 配额 → 获得 70% 资源 (70/100)
+- 组 A：30% 配额 → 获得 30% 的资源 (30/100)
+- 组 B：70% 配额 → 获得 70% 的资源 (70/100)
 
 **示例 2：总配额 > 100%**
-- 组 A：60% 配额 → 获得 40% 资源 (60/150)
-- 组 B：90% 配额 → 获得 60% 资源 (90/150)
+- 组 A：60% 配额 → 获得 40% 的资源 (60/150)
+- 组 B：90% 配额 → 获得 60% 的资源 (90/150)
 - 总配额：150%
 
 **示例 3：总配额 < 100%**
-- 组 A：20% 配额 → 获得 67% 资源 (20/30)
-- 组 B：10% 配额 → 获得 33% 资源 (10/30)
+- 组 A：20% 配额 → 获得 67% 的资源 (20/30)
+- 组 B：10% 配额 → 获得 33% 的资源 (10/30)
 - 总配额：30%
 
-**特殊情况：** 当仅存在一个工作负载组（Workload Group）时，无论其配置配额如何，都将获得 100% 的计算集群（Warehouse）资源。
\ No newline at end of file
+**特殊情况：**当只存在一个工作负载组时，无论其配置的配额如何，它都将获得 100% 的计算集群（Warehouse）资源。
\ No newline at end of file
diff --git a/docs/cn/sql-reference/10-sql-commands/00-ddl/20-workload-group/index.md b/docs/cn/sql-reference/10-sql-commands/00-ddl/20-workload-group/index.md
index fafa08d7c7..c41230a71b 100644
--- a/docs/cn/sql-reference/10-sql-commands/00-ddl/20-workload-group/index.md
+++ b/docs/cn/sql-reference/10-sql-commands/00-ddl/20-workload-group/index.md
@@ -2,13 +2,13 @@
 title: 工作负载组（Workload Group）
 ---
 
-工作负载组（Workload Group）通过为不同用户组分配 CPU、内存配额和限制并发查询，在 Databend 中实现资源管理与查询并发控制。
+工作负载组（Workload Group）通过为不同用户组分配 CPU、内存配额并限制并发查询，在 Databend 中实现资源管理与查询并发控制。
 
 ## 工作原理
 
-1. **创建工作负载组**，并指定资源配额（CPU、内存、并发限制）
-2. 使用 `ALTER USER` **将用户分配**到工作负载组
-3. **执行查询**时自动应用用户所在工作负载组的资源限制
+1. **创建工作负载组（Workload Group）**，并指定具体的资源配额（CPU、内存、并发限制）。
+2. 使用 `ALTER USER` **将用户分配**到工作负载组（Workload Group）。
+3. **执行查询（Query）**时，系统会根据用户自动应用其所属工作负载组（Workload Group）的资源限制。
 
 ## 快速示例
 
@@ -16,9 +16,15 @@ title: 工作负载组（Workload Group）
 -- 创建工作负载组
 CREATE WORKLOAD GROUP analytics WITH cpu_quota = '50%', memory_quota = '30%', max_concurrency = 5;
 
--- 将用户分配到工作负载组
+-- 创建用户并授予权限
 CREATE USER analyst IDENTIFIED BY 'password';
+GRANT ALL ON *.* TO analyst;
+
+-- 将用户分配到工作负载组
 ALTER USER analyst WITH SET WORKLOAD GROUP = 'analytics';
+
+-- 从工作负载组中移除用户（用户将使用默认的无限资源）
+ALTER USER analyst WITH UNSET WORKLOAD GROUP;
 ```
 
 ## 命令参考
@@ -26,9 +32,9 @@ ALTER USER analyst WITH SET WORKLOAD GROUP = 'analytics';
 ### 管理
 | 命令 | 描述 |
 |---------|-------------|
-| [CREATE WORKLOAD GROUP](create-workload-group.md) | 创建带资源配额的新工作负载组 |
+| [CREATE WORKLOAD GROUP](create-workload-group.md) | 创建新的工作负载组并设置资源配额 |
 | [ALTER WORKLOAD GROUP](alter-workload-group.md) | 修改工作负载组配置 |
-| [DROP WORKLOAD GROUP](drop-workload-group.md) | 移除工作负载组 |
+| [DROP WORKLOAD GROUP](drop-workload-group.md) | 删除工作负载组 |
 | [RENAME WORKLOAD GROUP](rename-workload-group.md) | 重命名工作负载组 |
 
 ### 信息
@@ -37,5 +43,5 @@ ALTER USER analyst WITH SET WORKLOAD GROUP = 'analytics';
 | [SHOW WORKLOAD GROUPS](show-workload-groups.md) | 列出所有工作负载组及其设置 |
 
 :::tip
-在计算集群（Warehouse）中，所有工作负载组的资源配额会被归一化处理。例如，若两组 CPU 配额分别为 60% 和 40%，则它们将分别获得实际资源的 60% 和 40%。
+资源配额在计算集群（Warehouse）中的所有工作负载组之间进行归一化。例如，如果两个组的 CPU 配额分别为 60% 和 40%，它们将分别获得实际资源的 60% 和 40%。
 :::
\ No newline at end of file
diff --git a/docs/cn/sql-reference/20-sql-functions/10-semi-structured-functions/0-json/index.md b/docs/cn/sql-reference/20-sql-functions/10-semi-structured-functions/0-json/index.md
index 053804ae43..1c8d7f53ce 100644
--- a/docs/cn/sql-reference/20-sql-functions/10-semi-structured-functions/0-json/index.md
+++ b/docs/cn/sql-reference/20-sql-functions/10-semi-structured-functions/0-json/index.md
@@ -2,14 +2,14 @@
 title: JSON 函数
 ---
 
-本节提供了 Databend 中 JSON 函数的参考信息。JSON 函数支持解析、验证、查询和操作 JSON 数据结构。
+本节提供 Databend 中 JSON 函数的参考信息。JSON 函数支持解析、验证、查询和操作 JSON 数据结构。
 
 ## JSON 解析与验证
 
 | 函数 | 描述 | 示例 |
 |----------|-------------|---------|
 | [PARSE_JSON](parse-json) | 将 JSON 字符串解析为 VARIANT 值 | `PARSE_JSON('{"name":"John","age":30}')` → `{"name":"John","age":30}` |
-| [CHECK_JSON](check-json) | 验证字符串是否为有效的 JSON | `CHECK_JSON('{"valid": true}')` → `true` |
+| [CHECK_JSON](check-json) | 验证字符串是否为有效 JSON | `CHECK_JSON('{"valid": true}')` → `true` |
 
 ## JSON 类型信息
 
@@ -28,7 +28,7 @@ title: JSON 函数
 | 函数 | 描述 | 示例 |
 |----------|-------------|---------|
 | [JSON_PATH_EXISTS](json-path-exists) | 检查 JSON 路径是否存在 | `JSON_PATH_EXISTS('{"a":1}', '$.a')` → `true` |
-| [JSON_PATH_MATCH](json-path-match) | 根据路径模式匹配 JSON 值 | `JSON_PATH_MATCH('{"items":[1,2,3]}', '$.items[*]')` → `[1,2,3]` |
+| [JSON_PATH_MATCH](json-path-match) | 按路径模式匹配 JSON 值 | `JSON_PATH_MATCH('{"items":[1,2,3]}', '$.items[*]')` → `[1,2,3]` |
 | [JSON_PATH_QUERY](json-path-query) | 使用 JSONPath 查询 JSON 数据 | `JSON_PATH_QUERY('{"a":1,"b":2}', '$.a')` → `1` |
 | [JSON_PATH_QUERY_ARRAY](json-path-query-array) | 查询 JSON 数据并以数组形式返回结果 | `JSON_PATH_QUERY_ARRAY('[1,2,3]', '$[*]')` → `[1,2,3]` |
 | [JSON_PATH_QUERY_FIRST](json-path-query-first) | 返回 JSON 路径查询的第一个结果 | `JSON_PATH_QUERY_FIRST('[1,2,3]', '$[*]')` → `1` |
@@ -37,7 +37,10 @@ title: JSON 函数
 
 | 函数 | 描述 | 示例 |
 |----------|-------------|---------|
-| [JSON_EXTRACT_PATH_TEXT](json-extract-path-text) | 使用路径从 JSON 中提取文本值 | `JSON_EXTRACT_PATH_TEXT('{"name":"John"}', 'name')` → `'John'` |
+| [GET](get) | 按索引或字段名从 JSON 提取值 | `GET('{"name":"John"}', 'name')` → `"John"` |
+| [GET_IGNORE_CASE](get-ignore-case) | 以不区分大小写的方式按字段名提取值 | `GET_IGNORE_CASE('{"Name":"John"}', 'name')` → `"John"` |
+| [GET_PATH](get-path) | 使用路径表示法提取值 | `GET_PATH('{"user":{"name":"John"}}', 'user.name')` → `"John"` |
+| [JSON_EXTRACT_PATH_TEXT](json-extract-path-text) | 使用路径从 JSON 提取文本值 | `JSON_EXTRACT_PATH_TEXT('{"name":"John"}', 'name')` → `'John'` |
 | [JSON_EACH](json-each) | 将 JSON 对象展开为键值对 | `JSON_EACH('{"a":1,"b":2}')` → `[("a",1),("b",2)]` |
 | [JSON_ARRAY_ELEMENTS](json-array-elements) | 将 JSON 数组展开为单个元素 | `JSON_ARRAY_ELEMENTS('[1,2,3]')` → `1, 2, 3` |
 
@@ -45,6 +48,6 @@ title: JSON 函数
 
 | 函数 | 描述 | 示例 |
 |----------|-------------|---------|
-| [JSON_PRETTY](json-pretty) | 使用适当的缩进格式化 JSON | `JSON_PRETTY('{"a":1}')` → 格式化后的 JSON 字符串 |
+| [JSON_PRETTY](json-pretty) | 以适当缩进格式化 JSON | `JSON_PRETTY('{"a":1}')` → 格式化后的 JSON 字符串 |
 | [STRIP_NULL_VALUE](strip-null-value) | 从 JSON 中移除 null 值 | `STRIP_NULL_VALUE('{"a":1,"b":null}')` → `{"a":1}` |
-| [JQ](jq) | 使用 jq 风格的查询处理 JSON | `JQ('{"name":"John"}', '.name')` → `"John"` |
\ No newline at end of file
+| [JQ](jq) | 使用 jq 风格查询处理 JSON | `JQ('{"name":"John"}', '.name')` → `"John"` |
\ No newline at end of file
diff --git a/docs/cn/sql-reference/20-sql-functions/10-semi-structured-functions/index.md b/docs/cn/sql-reference/20-sql-functions/10-semi-structured-functions/index.md
index afdc9209d1..35760d1397 100644
--- a/docs/cn/sql-reference/20-sql-functions/10-semi-structured-functions/index.md
+++ b/docs/cn/sql-reference/20-sql-functions/10-semi-structured-functions/index.md
@@ -2,64 +2,82 @@
 title: 结构化与半结构化函数
 ---
 
-Databend 中的结构化与半结构化函数能够高效处理数组（Array）、对象（Object）、映射（Map）、JSON 以及其他结构化数据格式。这些函数为创建、解析、查询、转换和操作结构化与半结构化数据提供了全面的功能。
+Databend 中的结构化与半结构化函数能够高效处理数组（Array）、对象（Object）、映射（Map）、JSON 以及其他结构化数据格式。这些函数为创建、解析、查询、转换和操作结构化及半结构化数据提供了全面的能力。
 
 ## JSON 函数
 
+### 解析与验证
 | 函数 | 描述 | 示例 |
 |----------|-------------|--------|
 | [PARSE_JSON](json/parse-json) | 将 JSON 字符串解析为 VARIANT 值 | `PARSE_JSON('[1,2,3]')` |
-| [CHECK_JSON](json/check-json) | 验证字符串是否为有效的 JSON | `CHECK_JSON('{"a":1}')` |
+| [CHECK_JSON](json/check-json) | 验证字符串是否为有效 JSON | `CHECK_JSON('{"a":1}')` |
 | [JSON_TYPEOF](json/json-typeof) | 返回 JSON 值的类型 | `JSON_TYPEOF(PARSE_JSON('[1,2,3]'))` |
-| [JSON_TO_STRING](json/json-to-string) | 将 JSON 值转换为字符串 | `JSON_TO_STRING(PARSE_JSON('{"a":1}'))` |
+
+### 基于路径的查询
+| 函数 | 描述 | 示例 |
+|----------|-------------|--------|
 | [JSON_PATH_EXISTS](json/json-path-exists) | 检查 JSON 路径是否存在 | `JSON_PATH_EXISTS(json_obj, '$.name')` |
-| [JSON_PATH_MATCH](json/json-path-match) | 根据路径模式匹配 JSON 值 | `JSON_PATH_MATCH(json_obj, '$.age')` |
 | [JSON_PATH_QUERY](json/json-path-query) | 使用 JSONPath 查询 JSON 数据 | `JSON_PATH_QUERY(json_obj, '$.items[*]')` |
 | [JSON_PATH_QUERY_ARRAY](json/json-path-query-array) | 查询 JSON 数据并以数组形式返回结果 | `JSON_PATH_QUERY_ARRAY(json_obj, '$.items')` |
-| [JSON_PATH_QUERY_FIRST](json/json-path-query-first) | 返回 JSON 路径查询的首个结果 | `JSON_PATH_QUERY_FIRST(json_obj, '$.items[*]')` |
-| [JSON_EXTRACT_PATH_TEXT](json/json-extract-path-text) | 通过路径从 JSON 中提取文本值 | `JSON_EXTRACT_PATH_TEXT(json_obj, 'name')` |
-| [GET](json/get) | 通过键从 JSON 对象获取值，或通过索引从数组获取值 | `GET(PARSE_JSON('[1,2,3]'), 0)` |
-| [GET_PATH](json/get-path) | 使用路径表达式从 JSON 对象获取值 | `GET_PATH(json_obj, 'user.name')` |
-| [GET_IGNORE_CASE](json/get-ignore-case) | 通过不区分大小写的键匹配获取值 | `GET_IGNORE_CASE(json_obj, 'NAME')` |
+| [JSON_PATH_QUERY_FIRST](json/json-path-query-first) | 返回 JSON 路径查询的第一个结果 | `JSON_PATH_QUERY_FIRST(json_obj, '$.items[*]')` |
+| [JSON_PATH_MATCH](json/json-path-match) | 根据路径模式匹配 JSON 值 | `JSON_PATH_MATCH(json_obj, '$.age')` |
+| [JQ](json/jq) | 使用 jq 语法进行高级 JSON 处理 | `JQ('.name', json_obj)` |
+
+### 值提取
+| 函数 | 描述 | 示例 |
+|----------|-------------|--------|
+| [GET](json/get) | 通过键从 JSON 对象或通过索引从数组中获取值 | `GET(PARSE_JSON('[1,2,3]'), 0)` |
+| [GET_PATH](json/get-path) | 使用路径表达式从 JSON 对象中获取值 | `GET_PATH(json_obj, 'user.name')` |
+| [GET_IGNORE_CASE](json/get-ignore-case) | 以不区分大小写的键匹配方式获取值 | `GET_IGNORE_CASE(json_obj, 'NAME')` |
+| [JSON_EXTRACT_PATH_TEXT](json/json-extract-path-text) | 使用路径从 JSON 中提取文本值 | `JSON_EXTRACT_PATH_TEXT(json_obj, 'name')` |
+
+### 转换与输出
+| 函数 | 描述 | 示例 |
+|----------|-------------|--------|
+| [JSON_TO_STRING](json/json-to-string) | 将 JSON 值转换为字符串 | `JSON_TO_STRING(PARSE_JSON('{"a":1}'))` |
+| [JSON_PRETTY](json/json-pretty) | 使用适当缩进格式化 JSON | `JSON_PRETTY(PARSE_JSON('{"a":1}'))` |
+| [STRIP_NULL_VALUE](json/strip-null-value) | 从 JSON 中移除 null 值 | `STRIP_NULL_VALUE(PARSE_JSON('{"a":1,"b":null}'))` |
+
+### 数组/对象展开
+| 函数 | 描述 | 示例 |
+|----------|-------------|--------|
 | [JSON_EACH](json/json-each) | 将 JSON 对象展开为键值对 | `JSON_EACH(PARSE_JSON('{"a":1,"b":2}'))` |
-| [JSON_ARRAY_ELEMENTS](json/json-array-elements) | 将 JSON 数组展开为独立元素 | `JSON_ARRAY_ELEMENTS(PARSE_JSON('[1,2,3]'))` |
-| [JSON_PRETTY](json/json-pretty) | 格式化 JSON 并保留合理缩进 | `JSON_PRETTY(PARSE_JSON('{"a":1}'))` |
-| [STRIP_NULL_VALUE](json/strip-null-value) | 移除 JSON 中的 null 值 | `STRIP_NULL_VALUE(PARSE_JSON('{"a":1,"b":null}'))` |
+| [JSON_ARRAY_ELEMENTS](json/json-array-elements) | 将 JSON 数组展开为单个元素 | `JSON_ARRAY_ELEMENTS(PARSE_JSON('[1,2,3]'))` |
 
 ## 数组函数
 
 | 函数 | 描述 | 示例 |
 |----------|-------------|--------|
-| [ARRAY_CONSTRUCT](array/array-construct) | 从独立值创建数组 | `ARRAY_CONSTRUCT(1, 2, 3)` |
+| [ARRAY_CONSTRUCT](array/array-construct) | 从单个值创建数组 | `ARRAY_CONSTRUCT(1, 2, 3)` |
 | [RANGE](array/range) | 生成连续数字的数组 | `RANGE(1, 5)` |
-| [GET](array/get) | 通过索引从数组获取元素 | `GET(PARSE_JSON('[1,2,3]'), 0)` |
+| [GET](array/get) | 通过索引从数组中获取元素 | `GET(PARSE_JSON('[1,2,3]'), 0)` |
 | [ARRAY_GET](array/array-get) | GET 函数的别名 | `ARRAY_GET([1,2,3], 1)` |
 | [CONTAINS](array/contains) | 检查数组是否包含特定值 | `CONTAINS([1,2,3], 2)` |
 | [ARRAY_CONTAINS](array/array-contains) | 检查数组是否包含特定值 | `ARRAY_CONTAINS([1,2,3], 2)` |
-| [ARRAY_APPEND](array/array-append) | 向数组末尾追加元素 | `ARRAY_APPEND([1,2], 3)` |
-| [ARRAY_PREPEND](array/array-prepend) | 向数组开头添加元素 | `ARRAY_PREPEND([2,3], 1)` |
+| [ARRAY_APPEND](array/array-append) | 将元素追加到数组末尾 | `ARRAY_APPEND([1,2], 3)` |
+| [ARRAY_PREPEND](array/array-prepend) | 将元素前插到数组开头 | `ARRAY_PREPEND([2,3], 1)` |
 | [ARRAY_INSERT](array/array-insert) | 在指定位置插入元素 | `ARRAY_INSERT([1,3], 1, 2)` |
-| [ARRAY_REMOVE](array/array-remove) | 移除所有指定元素 | `ARRAY_REMOVE([1,2,2,3], 2)` |
-| [ARRAY_REMOVE_FIRST](array/array-remove-first) | 移除数组首个元素 | `ARRAY_REMOVE_FIRST([1,2,3])` |
-| [ARRAY_REMOVE_LAST](array/array-remove-last) | 移除数组末尾元素 | `ARRAY_REMOVE_LAST([1,2,3])` |
+| [ARRAY_REMOVE](array/array-remove) | 移除所有出现的指定元素 | `ARRAY_REMOVE([1,2,2,3], 2)` |
+| [ARRAY_REMOVE_FIRST](array/array-remove-first) | 从数组中移除第一个元素 | `ARRAY_REMOVE_FIRST([1,2,3])` |
+| [ARRAY_REMOVE_LAST](array/array-remove-last) | 从数组中移除最后一个元素 | `ARRAY_REMOVE_LAST([1,2,3])` |
 | [ARRAY_CONCAT](array/array-concat) | 连接多个数组 | `ARRAY_CONCAT([1,2], [3,4])` |
-| [ARRAY_SLICE](array/array-slice) | 提取数组的子集 | `ARRAY_SLICE([1,2,3,4], 1, 2)` |
+| [ARRAY_SLICE](array/array-slice) | 提取数组的一部分 | `ARRAY_SLICE([1,2,3,4], 1, 2)` |
 | [SLICE](array/slice) | ARRAY_SLICE 函数的别名 | `SLICE([1,2,3,4], 1, 2)` |
-| [ARRAYS_ZIP](array/arrays-zip) | 按元素组合多个数组 | `ARRAYS_ZIP([1,2], ['a','b'])` |
-| [ARRAY_DISTINCT](array/array-distinct) | 返回数组中的唯一元素 | `ARRAY_DISTINCT([1,2,2,3])` |
+| [ARRAYS_ZIP](array/arrays-zip) | 按元素方式组合多个数组 | `ARRAYS_ZIP([1,2], ['a','b'])` |
+| [ARRAY_DISTINCT](array/array-distinct) | 从数组中返回唯一元素 | `ARRAY_DISTINCT([1,2,2,3])` |
 | [ARRAY_UNIQUE](array/array-unique) | ARRAY_DISTINCT 函数的别名 | `ARRAY_UNIQUE([1,2,2,3])` |
-| [ARRAY_INTERSECTION](array/array-intersection) | 返回数组间的共同元素 | `ARRAY_INTERSECTION([1,2,3], [2,3,4])` |
-| [ARRAY_EXCEPT](array/array-except) | 返回仅存在于首个数组的元素 | `ARRAY_EXCEPT([1,2,3], [2,3])` |
-| [ARRAY_OVERLAP](array/array-overlap) | 检查数组是否存在共同元素 | `ARRAY_OVERLAP([1,2], [2,3])` |
+| [ARRAY_INTERSECTION](array/array-intersection) | 返回数组之间的共同元素 | `ARRAY_INTERSECTION([1,2,3], [2,3,4])` |
+| [ARRAY_EXCEPT](array/array-except) | 返回存在于第一个数组但不存在于第二个数组中的元素 | `ARRAY_EXCEPT([1,2,3], [2,3])` |
+| [ARRAY_OVERLAP](array/array-overlap) | 检查数组是否有共同元素 | `ARRAY_OVERLAP([1,2], [2,3])` |
 | [ARRAY_TRANSFORM](array/array-transform) | 对每个数组元素应用函数 | `ARRAY_TRANSFORM([1,2,3], x -> x * 2)` |
 | [ARRAY_FILTER](array/array-filter) | 根据条件筛选数组元素 | `ARRAY_FILTER([1,2,3,4], x -> x > 2)` |
-| [ARRAY_REDUCE](array/array-reduce) | 使用聚合函数将数组归约为单值 | `ARRAY_REDUCE([1,2,3], 0, (acc, x) -> acc + x)` |
+| [ARRAY_REDUCE](array/array-reduce) | 使用聚合将数组归约为单个值 | `ARRAY_REDUCE([1,2,3], 0, (acc, x) -> acc + x)` |
 | [ARRAY_AGGREGATE](array/array-aggregate) | 使用函数聚合数组元素 | `ARRAY_AGGREGATE([1,2,3], 'sum')` |
-| [ARRAY_COMPACT](array/array-compact) | 移除数组中的 null 值 | `ARRAY_COMPACT([1, NULL, 2, NULL, 3])` |
-| [ARRAY_FLATTEN](array/array-flatten) | 将嵌套数组展平为单层数组 | `ARRAY_FLATTEN([[1,2], [3,4]])` |
-| [ARRAY_REVERSE](array/array-reverse) | 反转数组元素顺序 | `ARRAY_REVERSE([1,2,3])` |
+| [ARRAY_COMPACT](array/array-compact) | 从数组中移除 null 值 | `ARRAY_COMPACT([1, NULL, 2, NULL, 3])` |
+| [ARRAY_FLATTEN](array/array-flatten) | 将嵌套数组展平为单个数组 | `ARRAY_FLATTEN([[1,2], [3,4]])` |
+| [ARRAY_REVERSE](array/array-reverse) | 反转数组元素的顺序 | `ARRAY_REVERSE([1,2,3])` |
 | [ARRAY_INDEXOF](array/array-indexof) | 返回元素首次出现的索引 | `ARRAY_INDEXOF([1,2,3,2], 2)` |
-| [UNNEST](array/unnest) | 将数组展开为独立行 | `UNNEST([1,2,3])` |
+| [UNNEST](array/unnest) | 将数组展开为单独的行 | `UNNEST([1,2,3])` |
 
 ## 对象函数
 
@@ -67,26 +85,26 @@ Databend 中的结构化与半结构化函数能够高效处理数组（Array）
 |----------|-------------|--------|
 | [OBJECT_CONSTRUCT](object/object-construct) | 从键值对创建 JSON 对象 | `OBJECT_CONSTRUCT('name', 'John', 'age', 30)` |
 | [OBJECT_CONSTRUCT_KEEP_NULL](object/object-construct-keep-null) | 创建 JSON 对象并保留 null 值 | `OBJECT_CONSTRUCT_KEEP_NULL('a', 1, 'b', NULL)` |
-| [OBJECT_KEYS](object/object-keys) | 返回 JSON 对象的所有键（数组形式） | `OBJECT_KEYS(PARSE_JSON('{"a":1,"b":2}'))` |
+| [OBJECT_KEYS](object/object-keys) | 以数组形式返回 JSON 对象的所有键 | `OBJECT_KEYS(PARSE_JSON('{"a":1,"b":2}'))` |
 | [OBJECT_INSERT](object/object-insert) | 在 JSON 对象中插入或更新键值对 | `OBJECT_INSERT(json_obj, 'new_key', 'value')` |
 | [OBJECT_DELETE](object/object-delete) | 从 JSON 对象中移除键值对 | `OBJECT_DELETE(json_obj, 'key_to_remove')` |
-| [OBJECT_PICK](object/object-pick) | 创建仅含指定键的新对象 | `OBJECT_PICK(json_obj, 'name', 'age')` |
+| [OBJECT_PICK](object/object-pick) | 使用指定键创建新对象 | `OBJECT_PICK(json_obj, 'name', 'age')` |
 
-## 映射（Map）函数
+## 映射函数
 
 | 函数 | 描述 | 示例 |
 |----------|-------------|--------|
-| [MAP_CAT](map/map-cat) | 合并多个映射为单个映射 | `MAP_CAT({'a':1}, {'b':2})` |
-| [MAP_KEYS](map/map-keys) | 返回映射的所有键（数组形式） | `MAP_KEYS({'a':1, 'b':2})` |
-| [MAP_VALUES](map/map-values) | 返回映射的所有值（数组形式） | `MAP_VALUES({'a':1, 'b':2})` |
-| [MAP_SIZE](map/map-size) | 返回映射中的键值对数量 | `MAP_SIZE({'a':1, 'b':2})` |
+| [MAP_CAT](map/map-cat) | 将多个映射合并为单个映射 | `MAP_CAT({'a':1}, {'b':2})` |
+| [MAP_KEYS](map/map-keys) | 以数组形式返回映射的所有键 | `MAP_KEYS({'a':1, 'b':2})` |
+| [MAP_VALUES](map/map-values) | 以数组形式返回映射的所有值 | `MAP_VALUES({'a':1, 'b':2})` |
+| [MAP_SIZE](map/map-size) | 返回映射中键值对的数量 | `MAP_SIZE({'a':1, 'b':2})` |
 | [MAP_CONTAINS_KEY](map/map-contains-key) | 检查映射是否包含特定键 | `MAP_CONTAINS_KEY({'a':1}, 'a')` |
 | [MAP_INSERT](map/map-insert) | 向映射中插入键值对 | `MAP_INSERT({'a':1}, 'b', 2)` |
 | [MAP_DELETE](map/map-delete) | 从映射中移除键值对 | `MAP_DELETE({'a':1, 'b':2}, 'b')` |
-| [MAP_TRANSFORM_KEYS](map/map-transform-keys) | 对映射的每个键应用函数 | `MAP_TRANSFORM_KEYS(map, k -> UPPER(k))` |
-| [MAP_TRANSFORM_VALUES](map/map-transform-values) | 对映射的每个值应用函数 | `MAP_TRANSFORM_VALUES(map, v -> v * 2)` |
+| [MAP_TRANSFORM_KEYS](map/map-transform-keys) | 对映射中的每个键应用函数 | `MAP_TRANSFORM_KEYS(map, k -> UPPER(k))` |
+| [MAP_TRANSFORM_VALUES](map/map-transform-values) | 对映射中的每个值应用函数 | `MAP_TRANSFORM_VALUES(map, v -> v * 2)` |
 | [MAP_FILTER](map/map-filter) | 根据谓词筛选键值对 | `MAP_FILTER(map, (k, v) -> v > 10)` |
-| [MAP_PICK](map/map-pick) | 创建仅含指定键的新映射 | `MAP_PICK({'a':1, 'b':2, 'c':3}, 'a', 'c')` |
+| [MAP_PICK](map/map-pick) | 使用指定键创建新映射 | `MAP_PICK({'a':1, 'b':2, 'c':3}, 'a', 'c')` |
 
 ## 类型转换函数
 
@@ -106,10 +124,10 @@ Databend 中的结构化与半结构化函数能够高效处理数组（Array）
 
 | 函数 | 描述 | 示例 |
 |----------|-------------|--------|
-| [IS_ARRAY](type-predicate/is-array) | 检查 JSON 值是否为数组 | `IS_ARRAY(PARSE_JSON('[1,2,3]'))` |
-| [IS_OBJECT](type-predicate/is-object) | 检查 JSON 值是否为对象 | `IS_OBJECT(PARSE_JSON('{"a":1}'))` |
-| [IS_STRING](type-predicate/is-string) | 检查 JSON 值是否为字符串 | `IS_STRING(PARSE_JSON('"hello"'))` |
+| [IS_ARRAY](type-predicate/is-array) | 检查 JSON 值是否为 ARRAY | `IS_ARRAY(PARSE_JSON('[1,2,3]'))` |
+| [IS_OBJECT](type-predicate/is-object) | 检查 JSON 值是否为 OBJECT | `IS_OBJECT(PARSE_JSON('{"a":1}'))` |
+| [IS_STRING](type-predicate/is-string) | 检查 JSON 值是否为 STRING | `IS_STRING(PARSE_JSON('"hello"'))` |
 | [IS_INTEGER](type-predicate/is-integer) | 检查 JSON 值是否为整数 | `IS_INTEGER(PARSE_JSON('42'))` |
 | [IS_FLOAT](type-predicate/is-float) | 检查 JSON 值是否为浮点数 | `IS_FLOAT(PARSE_JSON('3.14'))` |
-| [IS_BOOLEAN](type-predicate/is-boolean) | 检查 JSON 值是否为布尔值 | `IS_BOOLEAN(PARSE_JSON('true'))` |
+| [IS_BOOLEAN](type-predicate/is-boolean) | 检查 JSON 值是否为 BOOLEAN | `IS_BOOLEAN(PARSE_JSON('true'))` |
 | [IS_NULL_VALUE](type-predicate/is-null-value) | 检查 JSON 值是否为 null | `IS_NULL_VALUE(PARSE_JSON('null'))` |
\ No newline at end of file