AI Translate 20-workload-group to Simplified-Chinese (#2695)

* [INIT] Start translation to Simplified-Chinese

* 🌐 Translate create-workload-group.md to Simplified-Chinese

* 🌐 Translate create-workload-group.md to Simplified-Chinese

* 🌐 Translate create-workload-group.md to Simplified-Chinese

* 🌐 Translate create-workload-group.md to Simplified-Chinese

---------

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

Author: github-actions[bot]

.translation-init

@@ -1 +1 @@
-Translation initialization: 2025-08-18T07:47:46.585026
+Translation initialization: 2025-08-19T14:40:33.705590

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）资源。
+**特殊情况：**当只存在一个工作负载组时，无论其配置的配额如何，它都将获得 100% 的计算集群（Warehouse）资源。

docs/cn/sql-reference/10-sql-commands/00-ddl/20-workload-group/index.md

@@ -2,33 +2,39 @@
 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）的资源限制。
 
 ## 快速示例
 
 ```sql
 -- 创建工作负载组
 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;
 ```
 
 ## 命令参考
 
 ### 管理
 | 命令 | 描述 |
 |---------|-------------|
-| [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%。
 :::

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,14 +37,17 @@ 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` |
 
 ## 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"` |
+| [JQ](jq) | 使用 jq 风格查询处理 JSON | `JQ('{"name":"John"}', '.name')` → `"John"` |