From b1f4e15f18031038a3ba59a0579fac2e3a55db08 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 24 Aug 2025 13:02:32 +0000 Subject: [PATCH 01/34] [INIT] Start translation to Simplified-Chinese --- .translation-init | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.translation-init b/.translation-init index 59868ff1bd..a83f508159 100644 --- a/.translation-init +++ b/.translation-init @@ -1 +1 @@ -Translation initialization: 2025-08-24T10:54:05.598944 +Translation initialization: 2025-08-24T13:02:31.727965 From 2aedfc095686623b92813061f107cd19779fb19c Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 24 Aug 2025 13:04:14 +0000 Subject: [PATCH 02/34] =?UTF-8?q?=F0=9F=8C=90=20Translate=2010-enterprise-?= =?UTF-8?q?features.md=20to=20Simplified-Chinese?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../01-dee/10-enterprise-features.md | 104 +++++++++--------- 1 file changed, 52 insertions(+), 52 deletions(-) diff --git a/docs/cn/guides/00-products/01-dee/10-enterprise-features.md b/docs/cn/guides/00-products/01-dee/10-enterprise-features.md index 37408cd71c..b826c19b44 100644 --- a/docs/cn/guides/00-products/01-dee/10-enterprise-features.md +++ b/docs/cn/guides/00-products/01-dee/10-enterprise-features.md @@ -4,59 +4,59 @@ title: 企业版功能 import DatabendTable from '@site/src/components/DatabendTable'; -本页提供了 Databend 企业版功能的最新列表。要使用这些功能，你需要企业版或试用许可证。更多详情，请参阅 [Databend 许可证](20-license.md)。 +本页面列出了当前可用的企业版功能。如需使用这些功能，您必须拥有企业版或试用版许可证。更多详情，请参阅 [Databend 许可证](20-license.md)。 ### 企业版功能列表 -| 功能 | 类别 | 描述 | -| -------------------------------------------------------------------------------- | -------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -| [审计追踪](/guides/security/audit-trail) | 安全与合规 | 通过全面的审计日志监控数据库活动，以确保合规性和安全性。 | -| [脱敏策略](/sql/sql-commands/ddl/mask-policy/) | 安全与合规 | 使用基于角色的脱敏策略保护敏感数据。 | -| 存储加密 | 安全与合规 | 使用服务管理、KMS 或客户管理的密钥对静态数据进行加密。 | -| [BendSave](/guides/data-management/data-recovery#bendsave) | 灾难恢复 | 备份和恢复整个 Databend 集群数据，以实现灾难恢复。 | -| [故障安全](/guides/security/fail-safe) | 灾难恢复 | 从兼容 S3 的对象存储中恢复丢失或意外删除的数据。 | -| [聚合索引](/sql/sql-commands/ddl/aggregating-index) | 查询性能 | 通过预计算和索引化的聚合来加速查询。 | -| [全文索引](/guides/performance/fulltext-index) | 查询性能 | 通过倒排索引和相关性评分实现闪电般的文本搜索。 | -| [Ngram 索引](/guides/performance/ngram-index) | 查询性能 | 通过通配符搜索加速 LIKE 模式匹配查询。 | -| [虚拟列](/sql/sql-commands/ddl/virtual-column) | 查询性能 | 通过对 VARIANT 数据进行零配置性能优化，自动加速 JSON 查询。 | -| [动态列](/sql/sql-commands/ddl/table/ddl-create-table#computed-columns) | 查询性能 | 使用存储或虚拟计算模式，从标量表达式自动生成列。 | -| [Python UDF](/guides/query/udf#python-requires-databend-enterprise) | 高级分析 | 使用内置处理器在 SQL 查询中执行 Python 代码。 | -| [ATTACH TABLE](/sql/sql-commands/ddl/table/attach-table) | 数据共享 | 创建到现有表数据的只读链接，实现跨环境的零拷贝访问。 | -| [流](/sql/sql-commands/ddl/stream) | 变更数据捕获 | 跟踪和捕获表变更，以实现增量数据处理。 | -| [清理临时文件](/sql/sql-commands/administration-cmds/vacuum-temp-files) | 存储管理 | 清理临时文件（连接、聚合、排序溢出文件），以释放存储空间。 | -| [清理已删除表](/sql/sql-commands/ddl/table/vacuum-drop-table) | 存储管理 | 删除已删除表的数据文件以优化存储，并提供恢复选项。 | -| [清理历史数据](/sql/sql-commands/ddl/table/vacuum-table) | 存储管理 | 移除孤立的段和块文件，以深度清理存储空间。 | - -## Databend 社区版 vs. 企业版 - -本节比较了 Databend 社区版与 Databend 企业版在关键功能上的差异： +| 功能 | 类别 | 描述 | +| -------------------------------------------------------------------------------- | -------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| [审计追踪 (Audit Trail)](/guides/security/audit-trail) | 安全与合规 | 通过全面的审计日志监控数据库活动，满足合规与安全需求。 | +| [脱敏策略 (Masking Policy)](/sql/sql-commands/ddl/mask-policy/) | 安全与合规 | 基于角色的脱敏策略，保护敏感数据。 | +| 存储加密 (Storage Encryption) | 安全与合规 | 使用服务托管、KMS 或客户管理的密钥对静态数据进行加密。 | +| [BendSave](/guides/data-management/data-recovery#bendsave) | 灾难恢复 | 备份并恢复整个 Databend 集群数据，用于灾难恢复。 | +| [故障安全 (Fail-Safe)](/guides/security/fail-safe) | 灾难恢复 | 从兼容 S3 的对象存储中恢复丢失或误删的数据。 | +| [聚合索引 (Aggregating Index)](/sql/sql-commands/ddl/aggregating-index) | 查询性能 | 通过预计算并索引的聚合结果加速查询。 | +| [全文索引 (Full-Text Index)](/guides/performance/fulltext-index) | 查询性能 | 利用倒排索引和相关性评分实现极速文本搜索。 | +| [Ngram 索引 (Ngram Index)](/guides/performance/ngram-index) | 查询性能 | 通过通配符搜索加速 LIKE 模式匹配查询。 | +| [虚拟列 (Virtual Column)](/sql/sql-commands/ddl/virtual-column) | 查询性能 | 对 VARIANT 数据零配置性能优化，自动加速 JSON 查询。 | +| [动态列 (Dynamic Column)](/sql/sql-commands/ddl/table/ddl-create-table#computed-columns) | 查询性能 | 通过存储或虚拟计算模式，从标量表达式自动生成列。 | +| [Python UDF](/guides/query/advanced/udf#python-requires-databend-enterprise) | 高级分析 | 使用内置处理器在 SQL 查询中执行 Python 代码。 | +| [ATTACH TABLE](/sql/sql-commands/ddl/table/attach-table) | 数据共享 | 创建指向现有表数据的只读链接，实现跨环境零拷贝访问。 | +| [流 (Stream)](/sql/sql-commands/ddl/stream) | 变更数据捕获 | 跟踪并捕获表变更，用于增量数据处理。 | +| [清理临时文件 (Vacuum Temp Files)](/sql/sql-commands/administration-cmds/vacuum-temp-files) | 存储管理 | 清理临时文件（连接、聚合、排序溢出文件），释放存储空间。 | +| [清理已删除表 (Vacuum Dropped Table)](/sql/sql-commands/ddl/table/vacuum-drop-table) | 存储管理 | 删除已删除表的数据文件以优化存储，并提供恢复选项。 | +| [清理历史数据 (Vacuum Historical Data)](/sql/sql-commands/ddl/table/vacuum-table) | 存储管理 | 移除孤立的段和块文件，深度清理存储空间。 | + +## Databend 社区版 (Community) vs. 企业版 (Enterprise) + +本节对比 Databend 社区版 (Community) 与 Databend 企业版 (Enterprise) 在关键能力上的差异： ### 核心数据库引擎 @@ -64,15 +64,15 @@ tbody={[ @@ -80,13 +80,13 @@ tbody={[ @@ -94,9 +94,9 @@ tbody={[ @@ -134,7 +134,7 @@ tbody={[ Date: Sun, 24 Aug 2025 13:04:46 +0000 Subject: [PATCH 03/34] =?UTF-8?q?=F0=9F=8C=90=20Translate=2010-enterprise-?= =?UTF-8?q?features.md=20to=20Simplified-Chinese?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/cn/guides/20-cloud/20-manage/01-monitor.md | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/docs/cn/guides/20-cloud/20-manage/01-monitor.md b/docs/cn/guides/20-cloud/20-manage/01-monitor.md index 6697e4a4cf..aad48774ed 100644 --- a/docs/cn/guides/20-cloud/20-manage/01-monitor.md +++ b/docs/cn/guides/20-cloud/20-manage/01-monitor.md @@ -2,7 +2,7 @@ title: "监控使用情况" --- -Databend Cloud 提供了监控功能，帮助您全面了解您和您的组织成员在平台上的使用情况。要访问 **Monitor** 页面，请单击主页侧边栏菜单中的 **Monitor**。该页面包括以下选项卡： +Databend Cloud 提供监控功能，帮助你全面了解你和组织成员在平台上的使用情况。要访问 **Monitor** 页面，请在主页侧边栏菜单中点击 **Monitor**。该页面包含以下选项卡： - [Metrics](#metrics) - [SQL History](#sql-history) @@ -11,7 +11,7 @@ Databend Cloud 提供了监控功能，帮助您全面了解您和您的组织 ## Metrics -**Metrics** 选项卡显示图表，以可视化方式展示以下指标的使用统计信息，涵盖过去一小时、一天或一周的数据： +**Metrics** 选项卡以图表形式直观展示以下指标的使用统计，数据范围涵盖过去一小时、一天或一周： - Storage Size - SQL Query Count @@ -22,17 +22,17 @@ Databend Cloud 提供了监控功能，帮助您全面了解您和您的组织 ## SQL History -**SQL History** 选项卡显示组织内所有用户已执行的 SQL 语句列表。通过单击列表顶部的 **Filter**，您可以按多个维度过滤记录。 +**SQL History** 选项卡列出组织内所有用户已执行的 SQL 语句。点击列表顶部的 **Filter**，可按多个维度筛选记录。 -单击 **SQL History** 页面上的记录会显示有关 Databend Cloud 如何执行 SQL 语句的详细信息，从而可以访问以下选项卡： +在 **SQL History** 页面点击某条记录，可查看 Databend Cloud 执行该 SQL 语句的详细信息，并访问以下选项卡： -- **Query Details**：包括 Query State（成功或失败）、Rows Scanned、Warehouse、Bytes Scanned、Start Time、End Time 和 Handler Type。 -- **Query Profile**：说明 SQL 语句的执行方式。有关更多信息，请参见 [Query Profile](/guides/query/query-profile)。 +- **Query Details**：包含 Query State（成功或失败）、Rows Scanned、Warehouse、Bytes Scanned、Start Time、End Time 和 Handler Type。 +- **Query Profile**：展示 SQL 语句的执行过程。 ## Task History -**Task History** 选项卡提供了组织内所有已执行任务的完整日志，使用户可以查看任务设置并监控其状态。 +**Task History** 选项卡提供组织内所有已执行任务的完整日志，方便用户查看任务配置并监控其状态。 ## Audit -**Audit** 选项卡记录所有组织成员的操作日志，包括操作类型、操作时间、IP 地址和操作员帐户。通过单击列表顶部的 **Filter**，您可以按多个维度过滤记录。 \ No newline at end of file +**Audit** 选项卡记录所有组织成员的操作日志，包括操作类型、操作时间、IP 地址和操作者账号。点击列表顶部的 **Filter**，可按多个维度筛选记录。 \ No newline at end of file From 3ac54748741d98f9af6878ba4dd2b6be068d0946 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 24 Aug 2025 13:05:17 +0000 Subject: [PATCH 04/34] =?UTF-8?q?=F0=9F=8C=90=20Translate=2010-enterprise-?= =?UTF-8?q?features.md=20to=20Simplified-Chinese?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../51-ai-functions/01-external-functions.md | 24 +++++++++---------- 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/docs/cn/guides/51-ai-functions/01-external-functions.md b/docs/cn/guides/51-ai-functions/01-external-functions.md index be2d1fe0ef..770fe08cb3 100644 --- a/docs/cn/guides/51-ai-functions/01-external-functions.md +++ b/docs/cn/guides/51-ai-functions/01-external-functions.md @@ -1,10 +1,10 @@ --- -title: 使用外部函数（External Function）自定义 AI/ML +title: 使用外部函数自定义 AI/ML --- -# 使用外部函数（External Function）自定义 AI/ML +# 使用外部函数自定义 AI/ML -通过将 Databend 与您自己的基础设施连接，构建强大的 AI/ML 能力。外部函数（External Function）让您部署自定义模型、利用 GPU 加速并与任何 ML 框架集成，同时确保数据安全。 +通过将 Databend 与您自己的基础设施连接，构建强大的 AI/ML 能力。外部函数（External Function）让您能够部署自定义模型、利用 GPU 加速，并与任何 ML 框架集成，同时确保数据安全。 ## 核心能力 @@ -13,14 +13,14 @@ title: 使用外部函数（External Function）自定义 AI/ML | **自定义模型** | 使用任何开源或专有的 AI/ML 模型 | | **GPU 加速** | 部署在配备 GPU 的机器上以加快推理速度 | | **数据隐私** | 将数据保留在您的基础设施内 | -| **可扩展性** | 独立扩展并优化资源 | +| **可扩展性** | 独立扩展和资源优化 | | **灵活性** | 支持任何编程语言和 ML 框架 | ## 工作原理 -1. **创建 AI 服务器**：使用 Python 和 [databend-udf](https://pypi.org/project/databend-udf) 构建 AI/ML 服务器 -2. **注册函数**：通过 `CREATE FUNCTION` 将服务器接入 Databend -3. **在 SQL 中使用**：直接在 SQL 查询中调用自定义 AI 函数 +1. **创建 AI 服务器**：使用 Python 和 [databend-udf](https://pypi.org/project/databend-udf) 构建您的 AI/ML 服务器 +2. **注册函数**：使用 `CREATE FUNCTION` 将您的服务器连接到 Databend +3. **在 SQL 中使用**：直接在 SQL 查询中调用您的自定义 AI 函数 ## 示例：文本嵌入函数 @@ -44,12 +44,12 @@ def ai_embed_768(inputs: list[str], headers) -> list[list[float]]: # 转换为列表格式 return [embedding.tolist() for embedding in embeddings] except Exception as e: - print(f"生成嵌入时出错：{e}") - # 出错时返回空列表 + print(f"Error generating embeddings: {e}") + # 如果出错，则返回空列表 return [[] for _ in inputs] if __name__ == '__main__': - print("在端口 8815 启动嵌入 UDF 服务器...") + print("正在端口 8815 上启动嵌入 UDF 服务器...") server = UDFServer("0.0.0.0:8815") server.add_function(ai_embed_768) server.serve() @@ -78,5 +78,5 @@ LIMIT 5; ## 了解更多 -- **[外部函数（External Function）指南](/guides/query/external-function)** - 完整的设置与部署说明 -- **[Databend Cloud](https://databend.cn)** - 免费账户体验外部函数 \ No newline at end of file +- **[外部函数指南](/guides/query/advanced/external-function)** - 完整的设置和部署说明 +- **[Databend Cloud](https://databend.cn)** - 使用免费账户试用外部函数 \ No newline at end of file From 23f3f82b73be55a275510b4686408edabdfe04f7 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 24 Aug 2025 13:05:50 +0000 Subject: [PATCH 05/34] =?UTF-8?q?=F0=9F=8C=90=20Translate=2010-enterprise-?= =?UTF-8?q?features.md=20to=20Simplified-Chinese?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../54-query/00-basics/aggregating-data.md | 90 +++++++++++++++++++ 1 file changed, 90 insertions(+) create mode 100644 docs/cn/guides/54-query/00-basics/aggregating-data.md diff --git a/docs/cn/guides/54-query/00-basics/aggregating-data.md b/docs/cn/guides/54-query/00-basics/aggregating-data.md new file mode 100644 index 0000000000..77c6cd7527 --- /dev/null +++ b/docs/cn/guides/54-query/00-basics/aggregating-data.md @@ -0,0 +1,90 @@ +--- +title: 聚合数据 +--- + +学习如何使用 GROUP BY、聚合函数（Aggregate Function）和高级分组技术来汇总和分析数据。 + +## 基本聚合 + +### 常用聚合函数 +```sql +-- 计算行数 +SELECT COUNT(*) FROM employees; + +-- 统计函数 +SELECT + AVG(salary) as avg_salary, + MIN(salary) as min_salary, + MAX(salary) as max_salary, + SUM(salary) as total_salary +FROM employees; +``` + +## GROUP BY 基础 + +### 单列分组 +```sql +-- 按部门统计员工人数 +SELECT department, COUNT(*) as emp_count +FROM employees +GROUP BY department; + +-- 按部门计算平均薪资 +SELECT department, AVG(salary) as avg_salary +FROM employees +GROUP BY department +ORDER BY avg_salary DESC; +``` + +### 多列分组 +```sql +-- 按部门和入职年份分组 +SELECT + department, + EXTRACT(YEAR FROM hire_date) as hire_year, + COUNT(*) as count, + AVG(salary) as avg_salary +FROM employees +GROUP BY department, EXTRACT(YEAR FROM hire_date) +ORDER BY department, hire_year; +``` + +### GROUP BY 与 HAVING +```sql +-- 查找员工人数超过 5 人的部门 +SELECT department, COUNT(*) as emp_count +FROM employees +GROUP BY department +HAVING COUNT(*) > 5; + +-- 平均薪资大于 70000 的部门 +SELECT department, AVG(salary) as avg_salary +FROM employees +GROUP BY department +HAVING AVG(salary) > 70000; +``` + +## 高级分组 + +### GROUP BY ALL +```sql +-- 自动按所有非聚合列进行分组 +SELECT department, job_title, COUNT(*) as count +FROM employees +GROUP BY ALL; +``` + +## 高级分组扩展 + +Databend 支持 SQL:2003 标准分组扩展： + +- **[ROLLUP](./groupby/group-by-rollup.md)** - 分层小计 +- **[CUBE](./groupby/group-by-cube.md)** - 所有可能的组合 +- **[GROUPING SETS](./groupby/group-by-grouping-sets.md)** - 自定义组合 + +## 最佳实践 + +1. **使用适当的聚合函数** - COUNT(*) 与 COUNT(column) +2. **分组前过滤** - 在 GROUP BY 前使用 WHERE +3. **使用 HAVING 进行聚合条件过滤** - 在聚合后过滤分组 +4. **考虑索引（Index）** - GROUP BY 的列应当被索引 \ No newline at end of file From e89227beec62d16540dce586da9b4b29e28b47e2 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 24 Aug 2025 13:06:21 +0000 Subject: [PATCH 06/34] =?UTF-8?q?=F0=9F=8C=90=20Translate=2010-enterprise-?= =?UTF-8?q?features.md=20to=20Simplified-Chinese?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../54-query/00-basics/filtering-selection.md | 103 ++++++++++++++++++ 1 file changed, 103 insertions(+) create mode 100644 docs/cn/guides/54-query/00-basics/filtering-selection.md diff --git a/docs/cn/guides/54-query/00-basics/filtering-selection.md b/docs/cn/guides/54-query/00-basics/filtering-selection.md new file mode 100644 index 0000000000..feb82c5e56 --- /dev/null +++ b/docs/cn/guides/54-query/00-basics/filtering-selection.md @@ -0,0 +1,103 @@ +--- +title: 过滤与选择 +--- + +学习在 Databend 中使用 SELECT、WHERE 和基本操作查询（Query）数据的基础知识。 + +## 基本 SELECT 查询 + +### 选择列 +```sql +-- 选择特定列 +SELECT name, salary FROM employees; + +-- 选择所有列 +SELECT * FROM employees; + +-- 使用列别名进行选择 +SELECT name AS employee_name, salary AS monthly_pay +FROM employees; +``` + +### 使用 WHERE 进行过滤 +```sql +-- 简单条件 +SELECT * FROM employees WHERE department = 'Engineering'; + +-- 多重条件 +SELECT * FROM employees +WHERE salary > 70000 AND department = 'Engineering'; + +-- 使用 OR +SELECT * FROM employees +WHERE department = 'Engineering' OR department = 'Marketing'; + +-- 范围条件 +SELECT * FROM employees +WHERE salary BETWEEN 60000 AND 80000; + +-- 模式匹配 +SELECT * FROM employees +WHERE name LIKE 'A%'; -- 名字以 'A' 开头 +``` + +## 排序结果 + +### ORDER BY 子句 +```sql +-- 按单列排序 +SELECT * FROM employees ORDER BY salary DESC; + +-- 按多列排序 +SELECT * FROM employees +ORDER BY department ASC, salary DESC; + +-- 按列位置排序 +SELECT name, salary FROM employees ORDER BY 2 DESC; +``` + +## 限制结果 + +### LIMIT 和 OFFSET +```sql +-- 获取薪水最高的 5 名员工 +SELECT * FROM employees +ORDER BY salary DESC +LIMIT 5; + +-- 分页 - 跳过前 10 条，获取接下来的 5 条 +SELECT * FROM employees +ORDER BY salary DESC +LIMIT 5 OFFSET 10; +``` + +## 常用运算符 + +### 比较运算符 +- `=` 等于 +- `!=` 或 `<>` 不等于 +- `>` 大于 +- `<` 小于 +- `>=` 大于或等于 +- `<=` 小于或等于 + +### 逻辑运算符 +- `AND` 两个条件都必须为真 +- `OR` 任一条件为真即可 +- `NOT` 对条件取反 + +### NULL 处理 +```sql +-- 检查 NULL 值 +SELECT * FROM employees WHERE manager_id IS NULL; + +-- 检查非 NULL 值 +SELECT * FROM employees WHERE manager_id IS NOT NULL; +``` + +## 最佳实践 + +1. **明确指定列** - 在生产环境中避免使用 `SELECT *` +2. **使用索引（Index）** - 对索引列使用 WHERE 条件可以加快查询速度 +3. **限制大量结果** - 在进行探索性查询时，始终使用 LIMIT +4. **尽早过滤** - 尽可能在进行连接（JOIN）之前应用 WHERE 条件 \ No newline at end of file From b5bad28d42ea8f3676887936cc26711b8860f704 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 24 Aug 2025 13:06:56 +0000 Subject: [PATCH 07/34] =?UTF-8?q?=F0=9F=8C=90=20Translate=2010-enterprise-?= =?UTF-8?q?features.md=20to=20Simplified-Chinese?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../00-basics/groupby/group-by-cube.md | 77 +++++++++++++++++++ 1 file changed, 77 insertions(+) create mode 100644 docs/cn/guides/54-query/00-basics/groupby/group-by-cube.md diff --git a/docs/cn/guides/54-query/00-basics/groupby/group-by-cube.md b/docs/cn/guides/54-query/00-basics/groupby/group-by-cube.md new file mode 100644 index 0000000000..913a332b39 --- /dev/null +++ b/docs/cn/guides/54-query/00-basics/groupby/group-by-cube.md @@ -0,0 +1,77 @@ +--- +title: GROUP BY CUBE +--- + +`GROUP BY CUBE` 是 [GROUP BY](index.md) 子句的扩展，与 [GROUP BY ROLLUP](group-by-rollup.md) 类似。除了生成 `GROUP BY ROLLUP` 的所有行之外，`GROUP BY CUBE` 还会添加所有“交叉表”行。小计行是进一步聚合的行，其值通过计算用于生成分组行的相同聚合函数得出。 + +一个 `CUBE` 分组等价于一连串的 GROUPING SETS（分组集），本质上是一种更简洁的写法。CUBE 规范中的 N 个元素对应 `2^N` 个 `GROUPING SETS`。 + +## 语法 + +```sql +SELECT ... +FROM ... +[ ... ] +GROUP BY CUBE ( groupCube [ , groupCube [ , ... ] ] ) +[ ... ] +``` + +其中： +```sql +groupCube ::= { | | } +``` + +- ``：查询块 SELECT 列表中出现的列别名。 + +- ``：SELECT 列表中表达式的位置。 + +- ``：当前作用域内表的任意表达式。 + + +## 示例 + +假设我们有一张名为 sales_data 的表，其结构及示例数据如下： + +```sql +CREATE TABLE sales_data ( + region VARCHAR(255), + product VARCHAR(255), + sales_amount INT +); + +INSERT INTO sales_data (region, product, sales_amount) VALUES + ('North', 'WidgetA', 200), + ('North', 'WidgetB', 300), + ('South', 'WidgetA', 400), + ('South', 'WidgetB', 100), + ('West', 'WidgetA', 300), + ('West', 'WidgetB', 200); +``` + +现在，我们使用 `GROUP BY CUBE` 子句获取每个地区与产品的总销售额，以及所有可能的聚合结果： + +```sql +SELECT region, product, SUM(sales_amount) AS total_sales +FROM sales_data +GROUP BY CUBE (region, product); +``` + +结果如下： +```sql ++--------+---------+-------------+ +| region | product | total_sales | ++--------+---------+-------------+ +| South | NULL | 500 | +| NULL | WidgetB | 600 | +| West | NULL | 500 | +| North | NULL | 500 | +| West | WidgetB | 200 | +| NULL | NULL | 1500 | +| North | WidgetB | 300 | +| South | WidgetA | 400 | +| North | WidgetA | 200 | +| NULL | WidgetA | 900 | +| West | WidgetA | 300 | +| South | WidgetB | 100 | ++--------+---------+-------------+ +``` \ No newline at end of file From 97c3477fddadea5222707821711d079ea8702f9b Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 24 Aug 2025 13:07:46 +0000 Subject: [PATCH 08/34] =?UTF-8?q?=F0=9F=8C=90=20Translate=2010-enterprise-?= =?UTF-8?q?features.md=20to=20Simplified-Chinese?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../groupby/group-by-grouping-sets.md | 130 ++++++++++++++++++ 1 file changed, 130 insertions(+) create mode 100644 docs/cn/guides/54-query/00-basics/groupby/group-by-grouping-sets.md diff --git a/docs/cn/guides/54-query/00-basics/groupby/group-by-grouping-sets.md b/docs/cn/guides/54-query/00-basics/groupby/group-by-grouping-sets.md new file mode 100644 index 0000000000..d35623a5e7 --- /dev/null +++ b/docs/cn/guides/54-query/00-basics/groupby/group-by-grouping-sets.md @@ -0,0 +1,130 @@ +--- +title: GROUP BY GROUPING SETS +--- + +`GROUP BY GROUPING SETS` 是 [GROUP BY](index.md) 子句的强大扩展，可在一条语句中完成多个分组计算。分组集（Grouping Set）是一组维度列。 + +`GROUP BY GROUPING SETS` 等价于在同一结果集中对两个或多个 GROUP BY 操作取 UNION： + +- `GROUP BY GROUPING SETS((a))` 等价于单个分组集操作 `GROUP BY a`。 +- `GROUP BY GROUPING SETS((a),(b))` 等价于 `GROUP BY a UNION ALL GROUP BY b`。 + +## 语法 + +```sql +SELECT ... +FROM ... +[ ... ] +GROUP BY GROUPING SETS ( groupSet [ , groupSet [ , ... ] ] ) +[ ... ] +``` + +其中： +```sql +groupSet ::= { | | } +``` + +- ``：查询块 SELECT 列表中出现的列别名。 +- ``：SELECT 列表中表达式的位置。 +- ``：当前作用域内针对表的任意表达式。 + +## 示例 + +示例数据准备： +```sql +-- 创建示例销售表 +CREATE TABLE sales ( + id INT, + sale_date DATE, + product_id INT, + store_id INT, + quantity INT +); + +-- 向销售表插入示例数据 +INSERT INTO sales (id, sale_date, product_id, store_id, quantity) +VALUES (1, '2021-01-01', 101, 1, 5), + (2, '2021-01-01', 102, 1, 10), + (3, '2021-01-01', 101, 2, 15), + (4, '2021-01-02', 102, 1, 8), + (5, '2021-01-02', 101, 2, 12), + (6, '2021-01-02', 103, 2, 20); +``` + +### 使用列别名的 GROUP BY GROUPING SETS + +```sql +SELECT product_id AS pid, + store_id AS sid, + SUM(quantity) AS total_quantity +FROM sales +GROUP BY GROUPING SETS((pid), (sid)); +``` + +该查询等价于： + +```sql +SELECT product_id AS pid, + NULL AS sid, + SUM(quantity) AS total_quantity +FROM sales +GROUP BY pid +UNION ALL +SELECT NULL AS pid, + store_id AS sid, + SUM(quantity) AS total_quantity +FROM sales +GROUP BY sid; +``` + +输出： +```sql ++------+------+----------------+ +| pid | sid | total_quantity | ++------+------+----------------+ +| 102 | NULL | 18 | +| NULL | 2 | 47 | +| 101 | NULL | 32 | +| 103 | NULL | 20 | +| NULL | 1 | 23 | ++------+------+----------------+ +``` + +### 使用位置的 GROUP BY GROUPING SETS + +```sql +SELECT product_id, + store_id, + SUM(quantity) AS total_quantity +FROM sales +GROUP BY GROUPING SETS((1), (2)); +``` + +该查询等价于： + +```sql +SELECT product_id, + NULL AS store_id, + SUM(quantity) AS total_quantity +FROM sales +GROUP BY product_id +UNION ALL +SELECT NULL AS product_id, + store_id, + SUM(quantity) AS total_quantity +FROM sales +GROUP BY store_id; +``` + +输出： +```sql ++------------+----------+----------------+ +| product_id | store_id | total_quantity | ++------------+----------+----------------+ +| 102 | NULL | 18 | +| NULL | 2 | 47 | +| 101 | NULL | 32 | +| 103 | NULL | 20 | +| NULL | 1 | 23 | ++------------+----------+----------------+ +``` \ No newline at end of file From ad740aa4a2bc7a18a2b831ba1bf823410f01e5f4 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 24 Aug 2025 13:08:22 +0000 Subject: [PATCH 09/34] =?UTF-8?q?=F0=9F=8C=90=20Translate=2010-enterprise-?= =?UTF-8?q?features.md=20to=20Simplified-Chinese?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../00-basics/groupby/group-by-rollup.md | 73 +++++++++++++++++++ 1 file changed, 73 insertions(+) create mode 100644 docs/cn/guides/54-query/00-basics/groupby/group-by-rollup.md diff --git a/docs/cn/guides/54-query/00-basics/groupby/group-by-rollup.md b/docs/cn/guides/54-query/00-basics/groupby/group-by-rollup.md new file mode 100644 index 0000000000..cac0eb9abd --- /dev/null +++ b/docs/cn/guides/54-query/00-basics/groupby/group-by-rollup.md @@ -0,0 +1,73 @@ +--- +title: GROUP BY ROLLUP +--- + +`GROUP BY ROLLUP` 是 [GROUP BY](index.md) 子句的扩展，它在分组行之外额外生成小计行。小计行通过再次聚合得到，其值由用于生成分组行的相同聚合函数计算得出。 + +## 语法 + +```sql +SELECT ... +FROM ... +[ ... ] +GROUP BY ROLLUP ( groupRollup [ , groupRollup [ , ... ] ] ) +[ ... ] +``` + +其中： +```sql +groupRollup ::= { | | } +``` + +- ``：查询块 SELECT 列表中出现的列别名。 + +- ``：SELECT 列表中表达式的位置。 + +- ``：当前作用域内表的任意表达式。 + + +## 示例 + +首先创建一个名为 sales_data 的示例表并插入数据： +```sql +CREATE TABLE sales_data ( + region VARCHAR(255), + product VARCHAR(255), + sales_amount INT +); + +INSERT INTO sales_data (region, product, sales_amount) VALUES + ('North', 'WidgetA', 200), + ('North', 'WidgetB', 300), + ('South', 'WidgetA', 400), + ('South', 'WidgetB', 100), + ('West', 'WidgetA', 300), + ('West', 'WidgetB', 200); +``` + +接下来，使用 GROUP BY ROLLUP 子句获取每个区域和产品的销售额，以及每个区域的小计： +```sql +SELECT region, product, SUM(sales_amount) AS total_sales +FROM sales_data +GROUP BY ROLLUP (region, product); +``` + +结果如下： +```sql ++--------+---------+-------------+ +| region | product | total_sales | ++--------+---------+-------------+ +| South | NULL | 500 | +| West | NULL | 500 | +| North | NULL | 500 | +| West | WidgetB | 200 | +| NULL | NULL | 1500 | +| North | WidgetB | 300 | +| South | WidgetA | 400 | +| North | WidgetA | 200 | +| West | WidgetA | 300 | +| South | WidgetB | 100 | ++--------+---------+-------------+ +``` + +在此示例中，GROUP BY ROLLUP 子句计算了每个区域-产品组合、每个区域以及总计的销售额。 \ No newline at end of file From b66aea65f08eef586bb0f792508ef77c43e0c84e Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 24 Aug 2025 13:09:36 +0000 Subject: [PATCH 10/34] =?UTF-8?q?=F0=9F=8C=90=20Translate=2010-enterprise-?= =?UTF-8?q?features.md=20to=20Simplified-Chinese?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../54-query/00-basics/groupby/index.md | 157 ++++++++++++++++++ 1 file changed, 157 insertions(+) create mode 100644 docs/cn/guides/54-query/00-basics/groupby/index.md diff --git a/docs/cn/guides/54-query/00-basics/groupby/index.md b/docs/cn/guides/54-query/00-basics/groupby/index.md new file mode 100644 index 0000000000..2ecb20bf4b --- /dev/null +++ b/docs/cn/guides/54-query/00-basics/groupby/index.md @@ -0,0 +1,157 @@ +--- +title: GROUP BY +--- +import FunctionDescription from '@site/src/components/FunctionDescription'; + + + +`GROUP BY` 子句允许您根据相同的分组项表达式对行进行分组，然后对每个结果组应用聚合函数。分组项表达式可以包括列名或别名、`SELECT` 列表中位置的数字引用、通用表达式或 `SELECT` 列表中的所有非聚合项。 + +Databend 中的 `GROUP BY` 子句附带以下扩展，以实现更全面的数据分组和灵活的数据分析： + +- [GROUP BY CUBE](group-by-cube.md) +- [GROUP BY GROUPING SETS](group-by-grouping-sets.md) +- [GROUP BY ROLLUP](group-by-rollup.md) + +## 语法 + +```sql +SELECT ... + FROM ... + [ ... ] +GROUP BY [ ALL | groupItem [ , groupItem [ , ... ] ] ] + [ ... ] +``` + +其中： + +- **ALL**：当使用关键字 "ALL" 时，Databend 会根据 `SELECT` 列表中的所有非聚合项对数据进行分组。 +- **groupItem**：分组项可以是以下之一： + - 在 `SELECT` 列表中定义的列名或别名。 + - 对 `SELECT` 列表中列位置的数字引用。 + - 任何涉及当前查询上下文中使用的表的列的表达式。 + +## 示例 + +本节中的 `GROUP BY` 示例基于以下数据设置： + +```sql +-- 创建一个名为 "employees" 的示例表 +CREATE TABLE employees ( + id INT, + first_name VARCHAR(50), + last_name VARCHAR(50), + department_id INT, + job_id INT, + hire_date DATE +); + +-- 向 "employees" 表中插入示例数据 +INSERT INTO employees (id, first_name, last_name, department_id, job_id, hire_date) +VALUES (1, 'John', 'Doe', 1, 101, '2021-01-15'), + (2, 'Jane', 'Smith', 1, 101, '2021-02-20'), + (3, 'Alice', 'Johnson', 1, 102, '2021-03-10'), + (4, 'Bob', 'Brown', 2, 201, '2021-03-15'), + (5, 'Charlie', 'Miller', 2, 202, '2021-04-10'), + (6, 'Eve', 'Davis', 2, 202, '2021-04-15'); +``` + +### 按单列分组 + +此查询按 `department_id` 对员工进行分组，并计算每个部门的员工人数： +```sql +SELECT department_id, COUNT(*) AS num_employees +FROM employees +GROUP BY department_id; +``` + +输出： +```sql ++---------------+---------------+ +| department_id | num_employees | ++---------------+---------------+ +| 1 | 3 | +| 2 | 3 | ++---------------+---------------+ +``` + +### 按多列分组 + +此查询按 `department_id` 和 `job_id` 对员工进行分组，然后计算每个组中的员工人数： +```sql +SELECT department_id, job_id, COUNT(*) AS num_employees +FROM employees +GROUP BY department_id, job_id; +``` + +输出： +```sql ++---------------+--------+---------------+ +| department_id | job_id | num_employees | ++---------------+--------+---------------+ +| 1 | 101 | 2 | +| 1 | 102 | 1 | +| 2 | 201 | 1 | +| 2 | 202 | 2 | ++---------------+--------+---------------+ +``` + +### 按 ALL 分组 + +此查询使用 `GROUP BY ALL` 子句对员工进行分组，该子句会对 `SELECT` 列表中的所有非聚合列进行分组。请注意，在这种情况下，结果将与按 `department_id` 和 `job_id` 分组相同，因为它们是 `SELECT` 列表中唯一的非聚合项。 + +```sql +SELECT department_id, job_id, COUNT(*) AS num_employees +FROM employees +GROUP BY ALL; +``` + +输出： +```sql ++---------------+--------+---------------+ +| department_id | job_id | num_employees | ++---------------+--------+---------------+ +| 1 | 101 | 2 | +| 1 | 102 | 1 | +| 2 | 201 | 1 | +| 2 | 202 | 2 | ++---------------+--------+---------------+ +``` + + +### 按位置分组 + +此查询等同于上面的 "按单列分组" 示例。位置 1 指的是 `SELECT` 列表中的第一项，即 `department_id`： +```sql +SELECT department_id, COUNT(*) AS num_employees +FROM employees +GROUP BY 1; +``` + +输出： +```sql ++---------------+---------------+ +| department_id | num_employees | ++---------------+---------------+ +| 1 | 3 | +| 2 | 3 | ++---------------+---------------+ +``` + +### 按表达式分组 + +此查询按员工被雇佣的年份进行分组，并计算每年雇佣的员工人数： +```sql +SELECT EXTRACT(YEAR FROM hire_date) AS hire_year, COUNT(*) AS num_hires +FROM employees +GROUP BY EXTRACT(YEAR FROM hire_date); +``` + +输出： +```sql ++-----------+-----------+ +| hire_year | num_hires | ++-----------+-----------+ +| 2021 | 6 | ++-----------+-----------+ +``` \ No newline at end of file From db748cd5ed8eb9f7cf6e27dddc749b7dc9bc3f8c Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 24 Aug 2025 13:09:56 +0000 Subject: [PATCH 11/34] =?UTF-8?q?=F0=9F=8C=90=20Translate=2010-enterprise-?= =?UTF-8?q?features.md=20to=20Simplified-Chinese?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/cn/guides/54-query/00-basics/index.md | 63 ++++++++++++++++++++++ 1 file changed, 63 insertions(+) create mode 100644 docs/cn/guides/54-query/00-basics/index.md diff --git a/docs/cn/guides/54-query/00-basics/index.md b/docs/cn/guides/54-query/00-basics/index.md new file mode 100644 index 0000000000..5a70b1eb54 --- /dev/null +++ b/docs/cn/guides/54-query/00-basics/index.md @@ -0,0 +1,63 @@ +--- +title: 基础查询 +--- + +掌握在 Databend 中查询（Query）数据的基本方法。如果你是 SQL 新手或需要复习核心概念，可以从这里开始。 + +## 你将学到 + +- 高效地选择和筛选数据 +- 对查询结果进行排序和限制 +- 对数据进行分组和聚合计算 +- 使用高级分组技巧 + +## 查询要点 + +### [筛选与选择](./filtering-selection.md) +学习基础知识：SELECT、WHERE、ORDER BY 和 LIMIT +```sql +SELECT name, salary FROM employees +WHERE department = 'Engineering' +ORDER BY salary DESC; +``` + +### [聚合数据](./aggregating-data.md) +使用 GROUP BY 和聚合函数（Aggregate Functions）汇总数据 +```sql +SELECT department, AVG(salary) as avg_salary +FROM employees +GROUP BY department; +``` + +### [高级分组](./groupby/index.md) +使用 CUBE、ROLLUP 和 GROUPING SETS 进行多维分析 +```sql +-- 生成所有可能的分组组合 +SELECT department, job_level, COUNT(*) +FROM employees +GROUP BY CUBE(department, job_level); +``` + +## 快速参考 + +### 最常用模式 +```sql +-- Top N 查询 +SELECT * FROM table ORDER BY column DESC LIMIT 10; + +-- 按类别计数 +SELECT category, COUNT(*) FROM table GROUP BY category; + +-- 筛选和聚合 +SELECT region, AVG(sales) +FROM orders +WHERE order_date >= '2023-01-01' +GROUP BY region +HAVING AVG(sales) > 1000; +``` + +## 后续步骤 + +熟悉基础查询后，你可以继续学习： +- [组合数据](../01-combining-data/index.md) - 连接（JOIN）表和使用公共表表达式（CTE） +- [高级功能](../02-advanced/index.md) - 自定义函数和存储过程 \ No newline at end of file From a7e5a15205f8b08a6ab8b093f4844324b644d8f2 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 24 Aug 2025 13:10:19 +0000 Subject: [PATCH 12/34] =?UTF-8?q?=F0=9F=8C=90=20Translate=2010-enterprise-?= =?UTF-8?q?features.md=20to=20Simplified-Chinese?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../guides/54-query/01-combining-data/cte.md | 94 +++++++++++++++++++ 1 file changed, 94 insertions(+) create mode 100644 docs/cn/guides/54-query/01-combining-data/cte.md diff --git a/docs/cn/guides/54-query/01-combining-data/cte.md b/docs/cn/guides/54-query/01-combining-data/cte.md new file mode 100644 index 0000000000..2e90000c94 --- /dev/null +++ b/docs/cn/guides/54-query/01-combining-data/cte.md @@ -0,0 +1,94 @@ +--- +title: 公用表表达式（CTE） +--- + +CTE 通过 `WITH` 将复杂查询拆解为简单、易读的步骤。 + +## 快速入门 + +```sql +-- 替代复杂嵌套查询 +WITH high_earners AS ( + SELECT * FROM employees WHERE salary > 70000 +) +SELECT department, COUNT(*) +FROM high_earners +GROUP BY department; +``` + +**结果**：代码清晰易读，调试方便。 + +## 何时使用 CTE + +**✅ 使用 CTE：** +- 查询包含多个步骤 +- 同一子查询需使用两次 +- 查询难以阅读 + +**❌ 跳过 CTE：** +- 简单单步查询 +- 性能至关重要 + +## 三种核心模式 + +### 1. 筛选 → 分析 +```sql +WITH filtered_data AS ( + SELECT * FROM sales WHERE date >= '2023-01-01' +) +SELECT product, SUM(amount) +FROM filtered_data +GROUP BY product; +``` + +### 2. 多步处理 +```sql +WITH step1 AS ( + SELECT department, AVG(salary) as avg_sal FROM employees GROUP BY department +), +step2 AS ( + SELECT * FROM step1 WHERE avg_sal > 70000 +) +SELECT * FROM step2; +``` + +### 3. 复用同一份数据 +```sql +WITH dept_stats AS ( + SELECT department, AVG(salary) as avg_sal FROM employees GROUP BY department +) +SELECT d1.department, d1.avg_sal +FROM dept_stats d1 +JOIN dept_stats d2 ON d1.avg_sal > d2.avg_sal; +``` + +## 进阶：递归 CTE + +递归 CTE 解决需要反复应用同一逻辑的问题。想象爬楼梯：从第 1 级开始，每次向上 1 级。 + +```sql +-- 生成序列（用于报表、测试或填补空缺） +WITH RECURSIVE countdown AS ( + -- 基例：起点 + SELECT 10 as num, 'Starting countdown' as message + + UNION ALL + + -- 递归：重复动作 + SELECT num - 1, CONCAT('Count: ', CAST(num - 1 AS VARCHAR)) + FROM countdown + WHERE num > 1 -- 终止条件 +) +SELECT num, message FROM countdown; +``` + +**结果**：数字从 10 倒数到 1，并附带消息。 + +**真实场景**：为销售报表补全缺失月份 +- 起点：2024-01 +- 重复：加一个月 +- 终点：2024-12 + +**核心思想**：递归 = 起点 + 重复动作 + 终止条件。 + +**到此为止。** 从简单 CTE 开始，仅在需要时增加复杂度。 \ No newline at end of file From ad2b2a8b009c77d55e77df7953d2cd77fa2b162b Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 24 Aug 2025 13:13:16 +0000 Subject: [PATCH 13/34] =?UTF-8?q?=F0=9F=8C=90=20Translate=2010-enterprise-?= =?UTF-8?q?features.md=20to=20Simplified-Chinese?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../54-query/01-combining-data/index.md | 98 +++++++++++++++++++ 1 file changed, 98 insertions(+) create mode 100644 docs/cn/guides/54-query/01-combining-data/index.md diff --git a/docs/cn/guides/54-query/01-combining-data/index.md b/docs/cn/guides/54-query/01-combining-data/index.md new file mode 100644 index 0000000000..f8da5cca73 --- /dev/null +++ b/docs/cn/guides/54-query/01-combining-data/index.md @@ -0,0 +1,98 @@ +--- +title: 合并数据 +--- + +学习如何使用 JOIN、公用表表达式（CTE）和高级查询结构来合并多个数据源的数据。 + +## 核心概念 + +### [JOIN](./joins.md) +连接多个表的数据 +```sql +-- 内连接（Inner Join）（最常用） +SELECT e.name, d.department_name +FROM employees e +JOIN departments d ON e.dept_id = d.id; +``` +**涵盖**：Inner、Left、Right、Full Outer、Semi、Anti 和 AsOf 连接 + +### [公用表表达式（Common Table Expressions, CTE）](./cte.md) +使用 WITH 子句构建复杂查询 +```sql +-- 将复杂逻辑拆分为多个步骤 +WITH high_performers AS ( + SELECT * FROM employees WHERE rating > 4.0 +) +SELECT department, COUNT(*) +FROM high_performers +GROUP BY department; +``` +**涵盖**：基本 CTE、递归 CTE、物化 CTE + +## 高级组合 + +### 子查询 +```sql +-- 相关子查询 +SELECT name, salary, + (SELECT AVG(salary) FROM employees e2 + WHERE e2.department = e1.department) as dept_avg +FROM employees e1; + +-- EXISTS 子句 +SELECT * FROM customers c +WHERE EXISTS ( + SELECT 1 FROM orders o + WHERE o.customer_id = c.id +); +``` + +### 集合操作 +```sql +-- 合并多个查询的结果 +SELECT name FROM employees WHERE department = 'Sales' +UNION +SELECT name FROM contractors WHERE active = true; + +-- 其他集合操作 +INTERSECT -- 仅共同行 +EXCEPT -- 第一个查询有而第二个查询没有的行 +``` + +## 实践模式 + +### 数据增强 +```sql +-- 向主表添加查找数据 +WITH region_lookup AS ( + SELECT zip_code, region_name + FROM zip_regions +) +SELECT + c.customer_name, + c.zip_code, + r.region_name, + SUM(o.amount) as total_sales +FROM customers c +LEFT JOIN region_lookup r ON c.zip_code = r.zip_code +LEFT JOIN orders o ON c.id = o.customer_id +GROUP BY c.customer_name, c.zip_code, r.region_name; +``` + +### 层级数据 +```sql +-- 用于组织结构的递归 CTE +WITH RECURSIVE org_chart AS ( + -- 基本情况：顶级管理者 + SELECT id, name, manager_id, 1 as level + FROM employees WHERE manager_id IS NULL + + UNION ALL + + -- 递归情况：添加直接下属 + SELECT e.id, e.name, e.manager_id, o.level + 1 + FROM employees e + JOIN org_chart o ON e.manager_id = o.id +) +SELECT * FROM org_chart ORDER BY level, name; +``` \ No newline at end of file From 5ae3f4e52be6bd20bd0d291bfc7495c16878332c Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 24 Aug 2025 13:14:22 +0000 Subject: [PATCH 14/34] =?UTF-8?q?=F0=9F=8C=90=20Translate=2010-enterprise-?= =?UTF-8?q?features.md=20to=20Simplified-Chinese?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../54-query/01-combining-data/joins.md | 200 ++++++++++++++++++ 1 file changed, 200 insertions(+) create mode 100644 docs/cn/guides/54-query/01-combining-data/joins.md diff --git a/docs/cn/guides/54-query/01-combining-data/joins.md b/docs/cn/guides/54-query/01-combining-data/joins.md new file mode 100644 index 0000000000..7dc25d3571 --- /dev/null +++ b/docs/cn/guides/54-query/01-combining-data/joins.md @@ -0,0 +1,200 @@ +--- +title: JOINs +--- + +JOIN 用于将两个表中的行组合起来，创建一个新的组合行，以便在查询（Query）中使用。 + +## 简介 + +当数据分散在多个相关表中时，JOIN 非常有用。例如，一个表存储员工信息，另一个表存储部门详情。 + +我们来看一下示例数据： + +**员工表（Employees Table）：** +```sql +SELECT * FROM employees ORDER BY id; +``` + +| id | name | department | salary | +|----|-------|-------------|----------| +| 1 | Alice | Engineering | 75000.00 | +| 2 | Bob | Engineering | 80000.00 | +| 3 | Carol | Marketing | 65000.00 | +| 4 | David | Sales | 70000.00 | +| 5 | Eve | Marketing | 68000.00 | + +**部门表（Departments Table）：** +```sql +SELECT * FROM departments ORDER BY id; +``` + +| id | name | budget | +|----|-------------|------------| +| 1 | Engineering | 1000000.00 | +| 2 | Marketing | 500000.00 | +| 3 | Sales | 750000.00 | + +这两个表有一个共同的关系：`employees.department` 与 `departments.name` 匹配。JOIN 让我们能够组合这些相关数据。 + +## JOIN 的类型 + +### 内连接（INNER JOIN） + +内连接（INNER JOIN）将一个表中的每一行与另一个表中的匹配行配对。 + +```sql +-- 获取员工及其部门预算 +SELECT e.name, e.salary, d.name as department_name, d.budget +FROM employees e +INNER JOIN departments d ON e.department = d.name +ORDER BY e.name; +``` + +**输出：** +| name | salary | department_name | budget | +|-------|----------|-----------------|------------| +| Alice | 75000.00 | Engineering | 1000000.00 | +| Bob | 80000.00 | Engineering | 1000000.00 | +| Carol | 65000.00 | Marketing | 500000.00 | +| David | 70000.00 | Sales | 750000.00 | +| Eve | 68000.00 | Marketing | 500000.00 | + +输出仅包含 `employees.department` 和 `departments.name` 之间存在匹配的行。 + +### 左连接（LEFT JOIN） + +左连接（LEFT JOIN）返回左表中的所有行，以及右表中匹配的数据。如果没有匹配项，右表的列将包含 NULL。 + +```sql +-- 获取所有员工，并显示其部门预算（如果可用） +SELECT e.name, e.department, d.budget +FROM employees e +LEFT JOIN departments d ON e.department = d.name +ORDER BY e.name; +``` + +**输出：** +| name | department | budget | +|-------|-------------|------------| +| Alice | Engineering | 1000000.00 | +| Bob | Engineering | 1000000.00 | +| Carol | Marketing | 500000.00 | +| David | Sales | 750000.00 | +| Eve | Marketing | 500000.00 | + +所有员工都会显示，即使他们所在的部门不存在（此时预算将为 NULL）。 + +### 右连接（RIGHT JOIN） + +右连接（RIGHT JOIN）返回右表中的所有行，以及左表中匹配的数据。 + +```sql +-- 获取所有部门，并显示其中的员工（如果有） +SELECT d.name as department_name, e.name as employee_name +FROM employees e +RIGHT JOIN departments d ON e.department = d.name +ORDER BY d.name, e.name; +``` + +**输出：** +| department_name | employee_name | +|-----------------|---------------| +| Engineering | Alice | +| Engineering | Bob | +| Marketing | Carol | +| Marketing | Eve | +| Sales | David | + +所有部门都会显示，即使部门中没有员工（此时 employee_name 将为 NULL）。 + +### 全连接（FULL JOIN） + +全连接（FULL JOIN）返回两个表中的所有行，并在可能的情况下进行匹配。 + +```sql +-- 获取所有员工和所有部门 +SELECT e.name as employee_name, d.name as department_name +FROM employees e +FULL JOIN departments d ON e.department = d.name +ORDER BY e.name, d.name; +``` + +**输出：** +| employee_name | department_name | +|---------------|-----------------| +| Alice | Engineering | +| Bob | Engineering | +| Carol | Marketing | +| David | Sales | +| Eve | Marketing | + +显示所有员工和部门，没有匹配项的地方为 NULL。 + +### 交叉连接（CROSS JOIN） + +交叉连接（CROSS JOIN）会创建一个笛卡尔积（Cartesian product）——第一个表中的每一行都与第二个表中的每一行组合。 + +**警告**：这可能会产生非常大的结果集。请谨慎使用。 + +```sql +-- 每个员工与每个部门配对（很少使用） +SELECT e.name, d.name as department +FROM employees e +CROSS JOIN departments d +ORDER BY e.name, d.name; +``` + +**输出（部分 - 总共 15 行）：** +| name | department | +|-------|-------------| +| Alice | Engineering | +| Alice | Marketing | +| Alice | Sales | +| Bob | Engineering | +| Bob | Marketing | +| Bob | Sales | +| Carol | Engineering | +| ... | ... | + +**结果**：5 名员工 × 3 个部门 = 总共 15 行。 + +## JOIN 的实现 + +### 使用 ON 子句（推荐） + +```sql +SELECT e.name, d.budget +FROM employees e +JOIN departments d ON e.department = d.name; +``` + +### 使用 WHERE 子句（旧式） + +```sql +SELECT e.name, d.budget +FROM employees e, departments d +WHERE e.department = d.name; +``` + +**建议**：使用 ON 子句语法，因为它更清晰，并且能正确处理外连接。 + +## 多表 JOIN + +你可以将多个 JOIN 链接在一起，以组合来自两个以上表的数据： + +```sql +-- 获取员工、部门预算和项目信息（如果存在 projects 表） +SELECT e.name, d.name as department, d.budget +FROM employees e +JOIN departments d ON e.department = d.name +JOIN projects p ON d.id = p.department_id +WHERE p.status = 'Active'; +``` + +## 何时使用各种 JOIN 类型 + +- **内连接（INNER JOIN）**：当你只需要两个表中都匹配的记录时。 +- **左连接（LEFT JOIN）**：当你需要左表中的所有记录，并尽可能匹配右表时。 +- **右连接（RIGHT JOIN）**：当你需要右表中的所有记录，并尽可能匹配左表时。 +- **全连接（FULL JOIN）**：当你需要两个表中的所有记录时。 +- **交叉连接（CROSS JOIN）**：很少使用；仅在明确需要笛卡尔积（Cartesian product）时使用。 \ No newline at end of file From b1e5e621ee9d2d7c163880708071f32a0b63d117 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 24 Aug 2025 13:14:56 +0000 Subject: [PATCH 15/34] =?UTF-8?q?=F0=9F=8C=90=20Translate=2010-enterprise-?= =?UTF-8?q?features.md=20to=20Simplified-Chinese?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../54-query/01-combining-data/subqueries.md | 157 ++++++++++++++++++ 1 file changed, 157 insertions(+) create mode 100644 docs/cn/guides/54-query/01-combining-data/subqueries.md diff --git a/docs/cn/guides/54-query/01-combining-data/subqueries.md b/docs/cn/guides/54-query/01-combining-data/subqueries.md new file mode 100644 index 0000000000..0e013a5810 --- /dev/null +++ b/docs/cn/guides/54-query/01-combining-data/subqueries.md @@ -0,0 +1,157 @@ +--- +title: 子查询（Subquery） +--- + +子查询（Subquery）是嵌套在另一条查询语句中的查询。利用子查询（Subquery）可以筛选、比较或计算依赖于主查询数据的值。 + +## 快速上手 + +```sql +-- 查找薪资高于部门平均值的员工 +SELECT name, salary, department +FROM employees +WHERE salary > ( + SELECT AVG(salary) + FROM employees AS e2 + WHERE e2.department = employees.department +); +``` + +**结果**：薪资高于其所在部门平均薪资的员工。 + +## 子查询（Subquery）的类型 + +### 1. 标量子查询（Scalar Subquery）（单值） +```sql +-- 与公司整体平均薪资比较 +SELECT name, salary, + (SELECT AVG(salary) FROM employees) AS company_avg +FROM employees +WHERE salary > (SELECT AVG(salary) FROM employees); +``` + +**返回**：单个值（一行一列）。 + +### 2. 表子查询（Table Subquery）（多行） +```sql +-- 按部门条件筛选 +SELECT name, department +FROM employees +WHERE department IN ( + SELECT name + FROM departments + WHERE budget > 500000 +); +``` + +**返回**：多行，可与 IN、EXISTS、ANY、ALL 等运算符配合使用。 + +## 子查询（Subquery）的位置 + +### WHERE 子句——用于筛选 +```sql +-- 查询高预算部门的员工 +SELECT name, salary +FROM employees +WHERE department IN ( + SELECT name FROM departments WHERE budget > 500000 +); +``` + +### FROM 子句——作为数据源 +```sql +-- 按部门分析高收入员工 +SELECT department, AVG(salary) AS avg_salary +FROM ( + SELECT * FROM employees WHERE salary > 70000 +) AS high_earners +GROUP BY department; +``` + +### SELECT 子句——作为计算列 +```sql +-- 显示薪资与部门平均薪资的对比 +SELECT name, salary, + (SELECT AVG(salary) + FROM employees e2 + WHERE e2.department = e1.department) AS dept_avg +FROM employees e1; +``` + +## 相关子查询（Correlated Subquery）与非相关子查询（Uncorrelated Subquery） + +### 非相关子查询（Uncorrelated Subquery）——独立 +```sql +-- 子查询仅执行一次 +SELECT name, salary +FROM employees +WHERE salary > (SELECT AVG(salary) FROM employees); +``` + +**性能**：子查询（Subquery）执行一次，结果复用。 + +### 相关子查询（Correlated Subquery）——依赖外部 +```sql +-- 子查询对外部查询的每一行都执行一次 +SELECT name, salary, department +FROM employees e1 +WHERE salary > ( + SELECT AVG(salary) + FROM employees e2 + WHERE e2.department = e1.department +); +``` + +**性能**：子查询（Subquery）对外部查询的每一行都执行一次。 + +## 常见模式 + +### EXISTS——检查相关数据 +```sql +-- 查询有项目参与的员工 +SELECT name, department +FROM employees e +WHERE EXISTS ( + SELECT 1 FROM projects p WHERE p.employee_id = e.id +); +``` + +### NOT EXISTS——检查缺失数据 +```sql +-- 查询无项目参与的员工 +SELECT name, department +FROM employees e +WHERE NOT EXISTS ( + SELECT 1 FROM projects p WHERE p.employee_id = e.id +); +``` + +### ANY/ALL——多重比较 +```sql +-- 查询薪资高于市场部（Marketing）任意员工的员工 +SELECT name, salary +FROM employees +WHERE salary > ANY ( + SELECT salary FROM employees WHERE department = 'Marketing' +); + +-- 查询薪资高于市场部（Marketing）所有员工的员工 +SELECT name, salary +FROM employees +WHERE salary > ALL ( + SELECT salary FROM employees WHERE department = 'Marketing' +); +``` + +## 何时使用子查询（Subquery）与 JOIN + +**✅ 使用子查询（Subquery）的场景：** +- 基于聚合条件进行筛选 +- 检查存在/不存在 +- 需要在 SELECT 中计算值 +- 逻辑以嵌套步骤呈现更清晰 + +**✅ 使用 JOIN 的场景：** +- 需要来自多个表的列 +- 大数据集性能更佳 +- 目的在于合并数据而非筛选 \ No newline at end of file From f66df6b1f0fa15d9a51cf5f289fefe5d0f882ae5 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 24 Aug 2025 13:18:53 +0000 Subject: [PATCH 16/34] =?UTF-8?q?=F0=9F=8C=90=20Translate=2010-enterprise-?= =?UTF-8?q?features.md=20to=20Simplified-Chinese?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../54-query/02-advanced/external-function.md | 224 ++++++++++++++++++ 1 file changed, 224 insertions(+) create mode 100644 docs/cn/guides/54-query/02-advanced/external-function.md diff --git a/docs/cn/guides/54-query/02-advanced/external-function.md b/docs/cn/guides/54-query/02-advanced/external-function.md new file mode 100644 index 0000000000..63f4b354fc --- /dev/null +++ b/docs/cn/guides/54-query/02-advanced/external-function.md @@ -0,0 +1,224 @@ +--- +title: "Databend Cloud 中的外部函数" +sidebar_label: "外部函数" +sidebar_position: 2 +--- + +Databend 中的外部函数（External Function）允许你使用 Python 等编程语言编写的外部服务器来定义处理数据的自定义操作。这些函数通过集成自定义逻辑、利用外部库和处理复杂任务，帮助你扩展 Databend 的能力。外部函数的主要特点包括： + +- **可扩展性**：非常适合复杂且资源密集的数据操作。 +- **外部库**：通过外部库和依赖项利用额外功能。 +- **高级逻辑**：为复杂场景实现复杂的数据处理逻辑。 + +## 支持的编程语言 + +下表列出了在 Databend 中创建外部函数所支持的语言及所需库： + +| 语言 | 所需库 | +| -------- | ----------------------------------------------------- | +| Python | [databend-udf](https://pypi.org/project/databend-udf) | + +## 管理外部函数 + +你可以使用 `CREATE FUNCTION`、`DROP FUNCTION` 和 `SHOW FUNCTIONS` 等 SQL 命令管理外部函数。更多详情，请参见 [外部函数](/sql/sql-commands/ddl/external-function/)。 + +## 在 Databend Cloud 中配置外部函数 + +要在 Databend Cloud 中使用外部函数，你需要**将外部函数服务器地址加入白名单**。外部函数服务器必须通过域名以 HTTPS 方式访问。请联系 Databend Cloud 支持团队，添加你允许的 UDF 服务器地址： + +1. 在 Databend Cloud 控制台中，导航到 **支持** > **创建新工单**。 +2. 提供你希望加入白名单的外部服务器地址（使用 HTTPS 域名）。 +3. 提交工单并等待支持团队确认。 + +## 使用示例：用 Python 创建外部函数 + +本节演示如何使用 Python 创建外部函数。 + +### 1. 安装所需库 + +使用 `pip` 安装 [databend-udf](https://pypi.org/project/databend-udf) 库： + +```bash +pip install databend-udf +``` + +### 2. 定义函数 + +创建 Python 文件（例如 `external_function.py`）并定义外部函数。以下示例定义了一个 Python 外部服务器，公开自定义函数 `gcd`，用于计算两个整数的最大公约数： + +```python +from databend_udf import udf, UDFServer + +@udf( + input_types=["INT", "INT"], + result_type="INT", + skip_null=True, +) +def gcd(x: int, y: int) -> int: + while y != 0: + x, y = y, x % y + return x + +if __name__ == '__main__': + # 创建监听 '0.0.0.0:8815' 的外部服务器 + server = UDFServer("0.0.0.0:8815") + # 添加已定义函数 + server.add_function(gcd) + # 启动外部服务器 + server.serve() +``` + +**`@udf` 装饰器参数说明：** + +| 参数 | 描述 | +| ------------- | ------------------------------------------------------------------------------------------------------------------------------------ | +| `input_types` | 字符串列表，指定输入数据类型（例如 `["INT", "VARCHAR"]`）。 | +| `result_type` | 字符串，指定返回值类型（例如 `"INT"`）。 | +| `name` | （可选）函数自定义名称。若未提供，则使用原始函数名。 | +| `io_threads` | 每个数据块用于 I/O 密集型函数的 I/O 线程数。 | +| `skip_null` | 若设为 `True`，NULL 值不会传递给函数，对应返回值设为 NULL。默认为 `False`。 | + +**Databend 与 Python 的数据类型映射：** + +| Databend 类型 | Python 类型 | +| ------------------- | ------------------- | +| BOOLEAN | `bool` | +| TINYINT (UNSIGNED) | `int` | +| SMALLINT (UNSIGNED) | `int` | +| INT (UNSIGNED) | `int` | +| BIGINT (UNSIGNED) | `int` | +| FLOAT | `float` | +| DOUBLE | `float` | +| DECIMAL | `decimal.Decimal` | +| DATE | `datetime.date` | +| TIMESTAMP | `datetime.datetime` | +| VARCHAR | `str` | +| VARIANT | `any` | +| MAP(K,V) | `dict` | +| ARRAY(T) | `list[T]` | +| TUPLE(T,...) | `tuple(T,...)` | + +### 3. 运行外部服务器 + +运行 Python 文件启动外部服务器： + +```bash +python3 external_function.py +``` + +**注意：** 确保服务器可从 Databend Cloud 访问且地址已加入白名单。若尚未完成，请联系 Databend Cloud 支持团队将服务器地址添加到白名单。 + +### 4. 在 Databend Cloud 中注册函数 + +使用 `CREATE FUNCTION` 语句在 Databend 中注册 `gcd` 函数： + +```sql +CREATE FUNCTION gcd (INT, INT) + RETURNS INT + LANGUAGE PYTHON + HANDLER = 'gcd' + ADDRESS = ''; +``` + +- 将 `` 替换为已在 Databend Cloud 白名单中的外部服务器实际地址（必须为 HTTPS 域名）。 +- `HANDLER` 指定 Python 代码中定义的函数名称。 +- `ADDRESS` 必须与外部服务器运行地址一致，且已被 Databend Cloud 加入白名单。 + +**示例：** + +```sql +CREATE FUNCTION gcd (INT, INT) + RETURNS INT + LANGUAGE PYTHON + HANDLER = 'gcd' + ADDRESS = 'https://your-server-address'; +``` + +**重要：** 执行此语句前，请确保通过联系支持团队将 `'https://your-server-address'` 加入 Databend Cloud 白名单。 + +现在你可以在 SQL 查询中使用外部函数 `gcd`： + +```sql +SELECT gcd(48, 18); -- 返回 6 +``` + +## 外部函数负载均衡 + +部署多个外部函数服务器时，可根据函数名称实现负载均衡。Databend 在每个 UDF 请求中包含 `X-DATABEND-FUNCTION` 标头，内容为被调用函数的小写名称。此标头可用于将请求路由到不同后端服务器。 + +### 使用 Nginx 进行基于函数的路由 + +以下示例展示如何配置 Nginx，将不同 UDF 请求路由到特定后端服务器： + +```nginx +# 为不同 UDF 函数定义上游服务器 +upstream udf_default { + server 10.0.0.1:8080; + server 10.0.0.2:8080 backup; +} + +upstream udf_math_functions { + server 10.0.1.1:8080; + server 10.0.1.2:8080 backup; +} + +upstream udf_string_functions { + server 10.0.2.1:8080; + server 10.0.2.2:8080 backup; +} + +upstream udf_database_functions { + server 10.0.3.1:8080; + server 10.0.3.2:8080 backup; +} + +# 将函数名称映射到后端服务器 +map $http_x_databend_function $udf_backend { + default "udf_default"; + gcd "udf_math_functions"; + lcm "udf_math_functions"; + string_* "udf_string_functions"; + *_db "udf_database_functions"; +} + +# 服务器配置 +server { + listen 443 ssl; + server_name udf.example.com; + + # SSL 配置 + ssl_certificate /etc/nginx/ssl/udf.example.com.crt; + ssl_certificate_key /etc/nginx/ssl/udf.example.com.key; + + # 安全标头 + add_header Strict-Transport-Security "max-age=31536000" always; + + location / { + proxy_pass http://$udf_backend; + proxy_http_version 1.1; + proxy_set_header Host $host; + proxy_set_header X-Real-IP $remote_addr; + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + proxy_set_header X-Forwarded-Proto $scheme; + + # 超时设置 + proxy_connect_timeout 60s; + proxy_send_timeout 60s; + proxy_read_timeout 60s; + } +} +``` + +在 Databend 中注册函数时，请使用 Nginx 服务器的域名： + +```sql +CREATE FUNCTION gcd (INT, INT) + RETURNS INT + LANGUAGE PYTHON + HANDLER = 'gcd' + ADDRESS = 'https://udf.example.com'; +``` + +## 总结 + +Databend Cloud 中的外部函数通过集成用 Python 等语言编写的自定义代码，为扩展数据处理 Pipeline 功能提供了强大方式。按照上述步骤，你可以创建并使用外部函数处理复杂任务、利用外部库并实现高级逻辑。 \ No newline at end of file From ac65a9ece5b0bcc4dc2b79dea88cf9c224ce690c Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 24 Aug 2025 13:19:22 +0000 Subject: [PATCH 17/34] =?UTF-8?q?=F0=9F=8C=90=20Translate=2010-enterprise-?= =?UTF-8?q?features.md=20to=20Simplified-Chinese?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/cn/guides/54-query/02-advanced/index.md | 59 ++++++++++++++++++++ 1 file changed, 59 insertions(+) create mode 100644 docs/cn/guides/54-query/02-advanced/index.md diff --git a/docs/cn/guides/54-query/02-advanced/index.md b/docs/cn/guides/54-query/02-advanced/index.md new file mode 100644 index 0000000000..58edccbbf0 --- /dev/null +++ b/docs/cn/guides/54-query/02-advanced/index.md @@ -0,0 +1,59 @@ +--- +title: 高级功能 +--- + +通过自定义函数、外部集成、存储过程和序列（Sequence）扩展 Databend 的能力。 + +## [用户定义函数（UDF）](./udf.md) +使用 SQL、Python 或 JavaScript 创建可复用的自定义函数。 +```sql +-- SQL 函数 +CREATE FUNCTION calculate_bonus(salary FLOAT, rating FLOAT) +RETURNS FLOAT AS $$ salary * rating * 0.1 $$; + +-- 使用函数 +SELECT name, calculate_bonus(salary, performance_rating) as bonus +FROM employees; +``` + +## [外部函数](./external-function.md) +与外部服务和 API 集成。 +```sql +-- 调用外部机器学习模型 +SELECT customer_id, predict_churn(age, tenure, usage) as churn_risk +FROM customers; +``` + +## [存储过程](./stored-procedure.md) +支持控制流的多步操作。 +```sql +-- 复杂的业务逻辑 +CALL monthly_report_generation('2023-12'); +``` + +## [序列（Sequence）](./sequences.md) +生成唯一标识符和序列值。 +```sql +-- 创建自增 ID +CREATE SEQUENCE user_id_seq; +INSERT INTO users VALUES (NEXTVAL(user_id_seq), 'John Doe'); +``` + + +## 最佳实践 + +### 函数设计 +- **保持函数纯粹** - 相同输入始终产生相同输出。 +- **处理 NULL 值** - 考虑 NULL 输入的处理方式。 +- **使用合适类型** - 使输入/输出类型与使用场景匹配。 +- **完善文档** - 清晰描述参数和返回值。 + +### 性能考量 +- **UDF 开销** - SQL 函数最快，Python/JS 较慢。 +- **批量操作** - 尽可能批量处理数据。 +- **资源限制** - 监控复杂函数的内存使用。 + +### 安全性 +- **验证输入** - 在 UDF 代码中检查参数。 +- **最小权限** - 外部连接应仅拥有必要权限。 +- **审计使用** - 监控 UDF 和外部函数的调用。 \ No newline at end of file From 37a5be3ac8f297029f630a71733bbe68d57c3b83 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 24 Aug 2025 13:20:05 +0000 Subject: [PATCH 18/34] =?UTF-8?q?=F0=9F=8C=90=20Translate=2010-enterprise-?= =?UTF-8?q?features.md=20to=20Simplified-Chinese?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../guides/54-query/02-advanced/sequences.md | 134 ++++++++++++++++++ 1 file changed, 134 insertions(+) create mode 100644 docs/cn/guides/54-query/02-advanced/sequences.md diff --git a/docs/cn/guides/54-query/02-advanced/sequences.md b/docs/cn/guides/54-query/02-advanced/sequences.md new file mode 100644 index 0000000000..f6df5602b9 --- /dev/null +++ b/docs/cn/guides/54-query/02-advanced/sequences.md @@ -0,0 +1,134 @@ +--- +title: 序列（Sequence） +sidebar_position: 4 +--- + +序列（Sequence）用于生成唯一的、连续的数值，通常用于主键（Primary Key）和自增标识符。 + +## 什么是序列（Sequence）？ + +序列（Sequence）提供了一种线程安全的方式，用于在并发操作中生成唯一的数字。与自增列不同，序列（Sequence）是数据库对象，可以在多个表之间共享使用。 + +## 创建序列（Sequence） + +### 基本序列（Sequence） +```sql +-- 创建一个简单的序列 +CREATE SEQUENCE user_id_seq; + +-- 使用序列 +SELECT NEXTVAL(user_id_seq); -- 返回: 1 +SELECT NEXTVAL(user_id_seq); -- 返回: 2 +SELECT NEXTVAL(user_id_seq); -- 返回: 3 +``` + +### 带选项的序列（Sequence） +```sql +-- 创建带自定义设置的序列 +CREATE SEQUENCE order_id_seq + START = 1000 + INCREMENT = 1 + MINVALUE = 1000 + MAXVALUE = 999999999 + CACHE = 50; +``` + +## 使用序列（Sequence） + +### 在 INSERT 语句中使用 +```sql +-- 创建使用序列生成 ID 的表 +CREATE TABLE users ( + id BIGINT, + name VARCHAR(100), + email VARCHAR(100) +); + +-- 使用序列值插入数据 +INSERT INTO users VALUES + (NEXTVAL(user_id_seq), 'John Doe', 'john@example.com'), + (NEXTVAL(user_id_seq), 'Jane Smith', 'jane@example.com'); +``` + +### 当前值与下一个值 +```sql +-- 获取下一个值（序列会前进） +SELECT NEXTVAL(user_id_seq); + +-- 获取当前值（序列不会前进） +SELECT CURRVAL(user_id_seq); +``` + +## 序列（Sequence）函数 + +| 函数 | 描述 | 示例 | +|----------|-------------|---------| +| `NEXTVAL(seq)` | 获取下一个值并推进序列 | `NEXTVAL(user_id_seq)` | +| `CURRVAL(seq)` | 获取当前值，不推进序列 | `CURRVAL(user_id_seq)` | + +## 管理序列（Sequence） + +### 查看序列（Sequence） +```sql +-- 显示所有序列 +SHOW SEQUENCES; + +-- 查看特定序列的描述 +DESC SEQUENCE user_id_seq; +``` + +### 修改序列（Sequence） +```sql +-- 将序列重置为特定值 +ALTER SEQUENCE user_id_seq RESTART = 5000; + +-- 更改增量值 +ALTER SEQUENCE user_id_seq INCREMENT = 10; +``` + +### 删除序列（Sequence） +```sql +-- 移除序列 +DROP SEQUENCE user_id_seq; +``` + +## 最佳实践 + +### 性能优化 +- **使用 CACHE** - 通过预分配值来提高性能 +- **适当的 INCREMENT** - 匹配你的应用需求 +- **监控间隙** - 如果服务器重启，缓存的值可能会产生间隙 + +### 常见模式 +```sql +-- 自增主键模式 +CREATE SEQUENCE pk_seq START = 1 INCREMENT = 1 CACHE = 100; + +CREATE TABLE products ( + id BIGINT DEFAULT NEXTVAL(pk_seq), + name VARCHAR(100), + price DECIMAL(10,2) +); + +-- 订单号模式（可读 ID） +CREATE SEQUENCE order_seq START = 10000 INCREMENT = 1; + +INSERT INTO orders VALUES + (NEXTVAL(order_seq), customer_id, order_date); +``` + +## 与自增列的对比 + +| 特性 | 序列（Sequence） | 自增（Auto-Increment） | +|---------|-----------|----------------| +| **可重用性** | ✅ 多个表 | ❌ 单个列 | +| **控制** | ✅ 完全控制 | ❌ 选项有限 | +| **间隙** | ✅ 可预测 | ❌ 可能有间隙 | +| **性能** | ✅ 可缓存 | ✅ 已优化 | + +## 常见用例 + +1. **主键（Primary Key）** - 跨表的唯一标识符 +2. **订单号** - 连续的业务标识符 +3. **版本号** - 文档或记录的版本控制 +4. **批次 ID** - 处理批次的标识 \ No newline at end of file From ed85ca3ae8167564ba3b5b4255d55369abc1b169 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 24 Aug 2025 13:20:51 +0000 Subject: [PATCH 19/34] =?UTF-8?q?=F0=9F=8C=90=20Translate=2010-enterprise-?= =?UTF-8?q?features.md=20to=20Simplified-Chinese?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../54-query/02-advanced/stored-procedure.md | 64 +++++++++++++++++++ 1 file changed, 64 insertions(+) create mode 100644 docs/cn/guides/54-query/02-advanced/stored-procedure.md diff --git a/docs/cn/guides/54-query/02-advanced/stored-procedure.md b/docs/cn/guides/54-query/02-advanced/stored-procedure.md new file mode 100644 index 0000000000..b287a346cb --- /dev/null +++ b/docs/cn/guides/54-query/02-advanced/stored-procedure.md @@ -0,0 +1,64 @@ +--- +title: 存储过程 +sidebar_position: 3 +--- + +存储过程（Stored Procedure）是一组存储在数据库中的可执行命令或逻辑块，用 SQL 或其他编程语言编写，旨在通过可重用方式高效完成特定任务或操作。 + +## 支持语言 + +**Databend 目前仅支持 [SQL 脚本](/sql/sql-reference/sql-scripting)**。借助 SQL 脚本，用户可定义包含循环（FOR、WHILE、REPEAT）和条件（IF、CASE）等控制流结构的存储过程，从而实现复杂逻辑并高效执行多步操作。 + +## 限制 + +使用存储过程时存在以下限制： + +- 存储过程为实验性功能。使用前请将 `enable_experimental_procedure` 设为 1； + + ```sql + SET enable_experimental_procedure = 1; + ``` + +- 无论声明的返回类型为何，存储过程均以字符串形式返回结果，且不会对返回值强制执行声明的类型。 + +## 管理存储过程 + +Databend 提供了一系列用于管理存储过程的命令。更多详情请参阅 [存储过程](/sql/sql-commands/ddl/procedure/)。 + +## 使用示例 + +假设我们要计算给定范围内所有偶数的和。以下存储过程接受起始值 `start_val` 和结束值 `end_val`，并计算该范围内所有偶数的和。 + +```sql +SET enable_experimental_procedure = 1; + +CREATE PROCEDURE sum_even_numbers(start_val UInt8, end_val UInt8) +RETURNS UInt8 NOT NULL +LANGUAGE SQL +COMMENT='计算所有偶数的和' +AS $$ +BEGIN + LET sum := 0; + FOR i IN start_val TO end_val DO + IF i % 2 = 0 THEN + sum := sum + i; + END IF; + END FOR; + + RETURN sum; +END; +$$; +``` + +若要计算 1 到 10 的所有偶数的和，可按如下方式调用该存储过程： + +```sql +CALL PROCEDURE sum_even_numbers(1, 10); + +-- 结果：2 + 4 + 6 + 8 + 10 = 30 +┌────────┐ +│ 结果 │ +├────────┤ +│ 30 │ +└────────┘ +``` \ No newline at end of file From 8adf2fe967756fc2e248cc036558598b2e13344e Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 24 Aug 2025 13:21:46 +0000 Subject: [PATCH 20/34] =?UTF-8?q?=F0=9F=8C=90=20Translate=2010-enterprise-?= =?UTF-8?q?features.md=20to=20Simplified-Chinese?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/cn/guides/54-query/02-advanced/udf.md | 123 +++++++++++++++++++++ 1 file changed, 123 insertions(+) create mode 100644 docs/cn/guides/54-query/02-advanced/udf.md diff --git a/docs/cn/guides/54-query/02-advanced/udf.md b/docs/cn/guides/54-query/02-advanced/udf.md new file mode 100644 index 0000000000..385a45b8fb --- /dev/null +++ b/docs/cn/guides/54-query/02-advanced/udf.md @@ -0,0 +1,123 @@ +--- +title: 用户自定义函数 +sidebar_position: 1 +--- + +# Databend 中的用户自定义函数（UDF） + +用户自定义函数（UDF）允许您根据特定的数据处理需求创建自定义操作。为了保持一致性，Databend 在所有函数类型中都使用了**统一的 `$$` 语法**。 + +## 快速入门指南 + +根据您需要返回的内容选择函数类型： + +| **需要返回** | **函数类型** | **文档** | +|-------------------|-------------------|-------------------| +| 单个值（数字、字符串等） | **标量 SQL** | [CREATE SCALAR FUNCTION](/sql/sql-commands/ddl/udf/ddl-create-function) | +| 多行/多列 | **表函数 SQL** | [CREATE TABLE FUNCTION](/sql/sql-commands/ddl/udf/ddl-create-table-function) | +| 使用 Python/JS/WASM 实现复杂逻辑 | **嵌入式** | [CREATE EMBEDDED FUNCTION](/sql/sql-commands/ddl/udf/ddl-create-function-embedded) | + +所有函数类型都使用相同的统一语法模式： +```sql +CREATE FUNCTION name(params) RETURNS type AS $$ logic $$; +``` + +## 标量 SQL 函数 + +使用 SQL 表达式返回单个值。非常适合用于计算、格式化和简单的转换。 + +```sql +-- 计算 BMI +CREATE FUNCTION calculate_bmi(weight FLOAT, height FLOAT) +RETURNS FLOAT +AS $$ weight / (height * height) $$; + +-- 格式化全名 +CREATE FUNCTION full_name(first VARCHAR, last VARCHAR) +RETURNS VARCHAR +AS $$ concat(first, ' ', last) $$; + +-- 使用函数 +SELECT + full_name('John', 'Doe') AS name, + calculate_bmi(70.0, 1.75) AS bmi; +``` + + +## 表函数（UDTF） + +返回包含多行和多列的结果集。非常适合用于封装带参数的复杂查询。 + +```sql +-- 按部门获取员工 +CREATE FUNCTION get_dept_employees(dept_name VARCHAR) +RETURNS TABLE (id INT, name VARCHAR, salary DECIMAL) +AS $$ + SELECT id, name, salary + FROM employees + WHERE department = dept_name +$$; + +-- 部门统计 +CREATE FUNCTION dept_stats() +RETURNS TABLE (department VARCHAR, count INT, avg_salary DECIMAL) +AS $$ + SELECT department, COUNT(*), AVG(salary) + FROM employees + GROUP BY department +$$; + +-- 使用表函数 +SELECT * FROM get_dept_employees('Engineering'); +SELECT * FROM dept_stats(); +``` + +## 嵌入式函数 + +对于无法用 SQL 轻松表达的复杂逻辑，可以使用 Python、JavaScript 或 WASM。 + +| 语言 | 需要企业版 | 包支持 | +|----------|-------------------|-----------------| +| Python | 是 | PyPI 包 | +| JavaScript | 否 | 否 | +| WASM | 否 | 否 | + +### Python 示例 +```sql +-- 带有类型安全的简单计算 +CREATE FUNCTION py_calc(INT, INT) +RETURNS INT +LANGUAGE python HANDLER = 'calculate' +AS $$ +def calculate(x, y): + return x * y + 10 +$$; + +SELECT py_calc(5, 3); -- 返回：25 +``` + +### JavaScript 示例 +```sql +-- 字符串处理 +CREATE FUNCTION js_format(VARCHAR, INT) +RETURNS VARCHAR +LANGUAGE javascript HANDLER = 'formatPerson' +AS $$ +export function formatPerson(name, age) { + return `${name} is ${age} years old`; +} +$$; + +SELECT js_format('Alice', 25); -- 返回："Alice is 25 years old" +``` + +## 函数管理 + +| 命令 | 文档 | +|---------|--------------| +| **CREATE** 函数 | [标量](/sql/sql-commands/ddl/udf/ddl-create-function)、[表](/sql/sql-commands/ddl/udf/ddl-create-table-function)、[嵌入式](/sql/sql-commands/ddl/udf/ddl-create-function-embedded) | +| **ALTER** 函数 | [ALTER FUNCTION](/sql/sql-commands/ddl/udf/ddl-alter-function) | +| **DROP** 函数 | [DROP FUNCTION](/sql/sql-commands/ddl/udf/ddl-drop-function) | +| **SHOW** 函数 | [SHOW USER FUNCTIONS](/sql/sql-commands/ddl/udf/ddl-show-user-functions) | + +有关用户自定义函数（UDF）的完整概述和比较，请参阅 [用户自定义函数命令](/sql/sql-commands/ddl/udf/)。 \ No newline at end of file From 0a8a69c83ac2d0cbda8b0391ba059c49ff1e5842 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 24 Aug 2025 13:22:59 +0000 Subject: [PATCH 21/34] =?UTF-8?q?=F0=9F=8C=90=20Translate=2010-enterprise-?= =?UTF-8?q?features.md=20to=20Simplified-Chinese?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../guides/54-query/03-optimization/index.md | 201 ++++++++++++++++++ 1 file changed, 201 insertions(+) create mode 100644 docs/cn/guides/54-query/03-optimization/index.md diff --git a/docs/cn/guides/54-query/03-optimization/index.md b/docs/cn/guides/54-query/03-optimization/index.md new file mode 100644 index 0000000000..c52950f6fe --- /dev/null +++ b/docs/cn/guides/54-query/03-optimization/index.md @@ -0,0 +1,201 @@ +--- +title: 查询优化 (Query Optimization) +--- + +通过性能分析工具、执行计划 (Execution Plan) 和优化技术来分析和提升查询性能。 + +## 性能分析工具 + +### [查询概况 (Query Profile)](./query-profile.md) +Databend Cloud 中的可视化执行计划分析 +- **访问**：监控 → SQL 历史 → 查询概况 (Query Profile) 选项卡 +- **展示**：执行节点、耗时、资源使用情况 +- **用途**：识别瓶颈、理解查询执行过程 + +### [查询哈希 (Query Hash)](./query-hash.md) +用于性能追踪的唯一查询指纹 +```sql +-- 获取查询指纹 +SELECT query_hash('SELECT * FROM table WHERE id = ?'); +``` + +## 查询优化基础 + +### 执行计划分析 (Execution Plan Analysis) +```sql +-- 查看查询执行计划 +EXPLAIN SELECT * FROM orders o +JOIN customers c ON o.customer_id = c.id +WHERE o.order_date >= '2023-01-01'; +``` + +**关注点：** +- **表扫描 (Table Scans)** vs **索引使用 (Index Usage)** +- **连接算法 (Join Algorithms)**（哈希、合并、嵌套循环） +- **过滤器下推 (Filter Pushdown)** 的有效性 +- **资源消耗 (Resource Consumption)** 估算 + +### 索引策略 (Index Strategy) +```sql +-- 为常见查询模式创建索引 +CREATE INDEX idx_orders_date ON orders(order_date); +CREATE INDEX idx_orders_customer ON orders(customer_id); +``` + +**索引指南：** +- 为 WHERE 子句中的列创建索引 +- 为连接 (JOIN) 两侧的列创建索引 +- 考虑为多列过滤器创建复合索引 (Composite Index) +- 监控索引使用统计信息 + +## 性能优化技巧 + +### 查询重写 (Query Rewriting) +```sql +-- ❌ 低效：对列使用函数导致无法使用索引 +SELECT * FROM orders WHERE YEAR(order_date) = 2023; + +-- ✅ 优化：范围条件可以使用索引 +SELECT * FROM orders +WHERE order_date >= '2023-01-01' + AND order_date < '2024-01-01'; +``` + +### 过滤器下推 (Filter Pushdown) +```sql +-- ❌ 在连接后过滤 +SELECT * FROM ( + SELECT o.*, c.name + FROM orders o JOIN customers c ON o.customer_id = c.id +) WHERE order_date >= '2023-01-01'; + +-- ✅ 在连接前过滤 +SELECT o.*, c.name +FROM orders o +JOIN customers c ON o.customer_id = c.id +WHERE o.order_date >= '2023-01-01'; +``` + +### 聚合优化 (Aggregation Optimization) +```sql +-- 使用合适的 GROUP BY 扩展 +SELECT + region, + product_category, + COUNT(*) as sales_count, + SUM(amount) as total_sales +FROM sales +GROUP BY CUBE(region, product_category); +``` + +## 常见性能问题 + +### 问题 1：结果集过大 +```sql +-- ❌ 问题：对大表查询未加限制 +SELECT * FROM events ORDER BY timestamp DESC; + +-- ✅ 解决方案：始终限制探索性查询的结果集大小 +SELECT * FROM events ORDER BY timestamp DESC LIMIT 1000; +``` + +### 问题 2：低效的连接 (Join) +```sql +-- ❌ 问题：笛卡尔积 +SELECT * FROM table1, table2 WHERE condition; + +-- ✅ 解决方案：使用带有正确条件的显式连接 +SELECT * FROM table1 t1 +INNER JOIN table2 t2 ON t1.id = t2.foreign_id +WHERE condition; +``` + +### 问题 3：不必要的复杂性 +```sql +-- ❌ 问题：嵌套子查询 (Subquery) +SELECT * FROM ( + SELECT * FROM ( + SELECT col1, col2 FROM table WHERE condition1 + ) WHERE condition2 +) WHERE condition3; + +-- ✅ 解决方案：合并条件 +SELECT col1, col2 FROM table +WHERE condition1 AND condition2 AND condition3; +``` + +## 监控与指标 + +### 关键性能指标 (Key Performance Indicators) +- **查询执行时间 (Query Execution Time)** +- **扫描行数 vs 返回行数** +- **内存使用量 (Memory Usage)** +- **CPU 使用率 (CPU Utilization)** +- **I/O 操作 (I/O Operations)** + +### 性能监控查询 +```sql +-- 从查询历史中查找慢查询 +SELECT + query_text, + query_duration_ms, + scan_bytes, + result_bytes, + memory_usage +FROM system.query_log +WHERE query_duration_ms > 10000 -- 超过 10 秒的查询 +ORDER BY query_duration_ms DESC +LIMIT 10; +``` + +## 优化清单 + +### 查询设计 +- [ ] 使用合适的 WHERE 条件 +- [ ] 通过选择列来最小化扫描的数据量 +- [ ] 在连接前应用过滤器 +- [ ] 使用正确的连接类型 +- [ ] 适当地限制结果集 + +### 索引 (Indexing) +- [ ] 为频繁过滤的列创建索引 +- [ ] 为连接列创建索引 +- [ ] 移除未使用的索引 +- [ ] 监控索引的有效性 + +### 模式设计 (Schema Design) +- [ ] 选择合适的数据类型 +- [ ] 适度规范化（避免过度规范化） +- [ ] 考虑为大表进行分区 (Partitioning) +- [ ] 使用聚簇键 (Cluster Key) 进行排序优化 + +## 高级优化 + +### 物化视图 (Materialized Views) +```sql +-- 预计算开销大的聚合 +CREATE MATERIALIZED VIEW daily_sales AS +SELECT + DATE(order_time) as order_date, + product_id, + COUNT(*) as order_count, + SUM(amount) as total_sales +FROM orders +GROUP BY DATE(order_time), product_id; +``` + +### 查询提示 (Query Hints) +```sql +-- 在需要时强制使用特定的连接算法 +SELECT /*+ USE_HASH_JOIN */ * +FROM large_table l +JOIN small_table s ON l.id = s.foreign_id; +``` + +## 最佳实践总结 + +1. **首先测量** - 使用查询概况 (Query Profile) 识别瓶颈 +2. **策略性地创建索引** - 覆盖你的查询模式 +3. **尽早过滤** - 尽快应用 WHERE 条件 +4. **适当限制** - 不要获取超出需要的数据 +5. **持续监控** - 长期跟踪查询性能 \ No newline at end of file From 3ae9a1fa66ac041089c2ee58d5718fa55b4848c5 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 24 Aug 2025 13:24:24 +0000 Subject: [PATCH 22/34] =?UTF-8?q?=F0=9F=8C=90=20Translate=2010-enterprise-?= =?UTF-8?q?features.md=20to=20Simplified-Chinese?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../54-query/03-optimization/query-hash.md | 112 ++++++++++++++++++ 1 file changed, 112 insertions(+) create mode 100644 docs/cn/guides/54-query/03-optimization/query-hash.md diff --git a/docs/cn/guides/54-query/03-optimization/query-hash.md b/docs/cn/guides/54-query/03-optimization/query-hash.md new file mode 100644 index 0000000000..df4e3e52b9 --- /dev/null +++ b/docs/cn/guides/54-query/03-optimization/query-hash.md @@ -0,0 +1,112 @@ +--- +title: 查询哈希（Query Hash） +--- + +查询哈希（Query Hash）是用于表示唯一 SQL 查询（Query）的标识符。它将查询的结构和内容转换为一个固定长度的值，因此即使查询文本有细微差异，只要逻辑结构相同，其哈希值也会相同。这有助于识别相似查询和频繁执行的查询。 + +## 查询哈希类型 + +Databend 支持两种类型的查询哈希： + +- `query_hash`：`query_hash` 确保重复查询即使在空格或注释上存在差异，也共享相同的哈希值。例如，以下查询共享相同的哈希值： + + ```sql + SELECT * FROM t1 WHERE name = 'jim' + SELECT * FROM t1 WHERE name = 'jim' + ``` + +- `query_parameterized_hash`：`query_parameterized_hash` 通过处理比较谓词（例如 `=`、`!=`、`>=`、`<=`）中涉及的字面量来规范化查询，从而能够识别结构相似的查询，而不受所用具体值的影响。例如，以下查询共享相同的哈希值： + + ```sql + SELECT * FROM t1 WHERE name = 'data' + SELECT * FROM t1 WHERE name = 'bend' + ``` + +## 检索哈希值 + +Databend 将历史查询的哈希值存储在系统表 [system.query_log](/sql/sql-reference/system-tables/system-query-log) 中名为 `query_hash` 和 `query_parameterized_hash` 的列中。要检索查询的哈希值，您可以使用 SELECT 语句从系统表中提取它们。例如： + +```sql +SELECT * FROM books; + +┌───────────────────────────────────────────────────────────────┐ +│ id │ title │ genre │ +├──────────────────┼─────────────────────────┼──────────────────┤ +│ 1 │ To Kill a Mockingbird │ Fiction │ +│ 2 │ A Brief History of Time │ Science │ +└───────────────────────────────────────────────────────────────┘ + +SELECT query_text, query_hash, query_parameterized_hash +FROM system.query_log +WHERE query_text = 'SELECT * FROM books'; + +┌───────────────────────────────────────────────────────────────────────────────────────────┐ +│ query_text │ query_hash │ query_parameterized_hash │ +├─────────────────────┼──────────────────────────────────┼──────────────────────────────────┤ +│ SELECT * FROM books │ 7e612be4897104109449c74d3970c9e7 │ 7e612be4897104109449c74d3970c9e7 │ +│ SELECT * FROM books │ 7e612be4897104109449c74d3970c9e7 │ 7e612be4897104109449c74d3970c9e7 │ +└───────────────────────────────────────────────────────────────────────────────────────────┘ +``` + +## 示例 + +假设我们有一个包含以下行的表： + +```sql +SELECT * FROM books; + +┌───────────────────────────────────────────────────────────────┐ +│ id │ title │ genre │ +├──────────────────┼─────────────────────────┼──────────────────┤ +│ 1 │ To Kill a Mockingbird │ Fiction │ +│ 2 │ A Brief History of Time │ Science │ +└───────────────────────────────────────────────────────────────┘ +``` + +以下查询将共享相同的哈希值： + +```sql +SELECT * FROM books WHERE id = 1; +SELECT * FROM books WHERE id = 1; +``` + +检查它们： + +```sql +SELECT query_text, query_hash, query_parameterized_hash +FROM system.query_log +WHERE query_text = 'SELECT * FROM books WHERE id = 1' + OR query_text = 'SELECT * FROM books WHERE id = 1'; + +┌────────────────────────────────────────────────────────────────────────────────────────────────────────┐ +│ query_text │ query_hash │ query_parameterized_hash │ +├──────────────────────────────────┼──────────────────────────────────┼──────────────────────────────────┤ +│ SELECT * FROM books WHERE id = 1 │ ae040c4b3a9388c75e10be76ba407b17 │ b68f516c17d3c15b2c070e4af528464c │ +│ SELECT * FROM books WHERE id = 1 │ ae040c4b3a9388c75e10be76ba407b17 │ b68f516c17d3c15b2c070e4af528464c │ +│ SELECT * FROM books WHERE id = 1 │ ae040c4b3a9388c75e10be76ba407b17 │ b68f516c17d3c15b2c070e4af528464c │ +│ SELECT * FROM books WHERE id = 1 │ ae040c4b3a9388c75e10be76ba407b17 │ b68f516c17d3c15b2c070e4af528464c │ +└────────────────────────────────────────────────────────────────────────────────────────────────────────┘ +``` + +以下查询共享相同的 `query_parameterized_hash` 值： + +```sql +SELECT * FROM books WHERE id = 1; +SELECT * FROM books WHERE id = 2; + +SELECT query_text, query_hash, query_parameterized_hash +FROM system.query_log +WHERE query_text = 'SELECT * FROM books WHERE id = 1' + OR query_text = 'SELECT * FROM books WHERE id = 2'; + +┌────────────────────────────────────────────────────────────────────────────────────────────────────────┐ +│ query_text │ query_hash │ query_parameterized_hash │ +├──────────────────────────────────┼──────────────────────────────────┼──────────────────────────────────┤ +│ SELECT * FROM books WHERE id = 1 │ ae040c4b3a9388c75e10be76ba407b17 │ b68f516c17d3c15b2c070e4af528464c │ +│ SELECT * FROM books WHERE id = 1 │ ae040c4b3a9388c75e10be76ba407b17 │ b68f516c17d3c15b2c070e4af528464c │ +│ SELECT * FROM books WHERE id = 1 │ ae040c4b3a9388c75e10be76ba407b17 │ b68f516c17d3c15b2c070e4af528464c │ +│ SELECT * FROM books WHERE id = 1 │ ae040c4b3a9388c75e10be76ba407b17 │ b68f516c17d3c15b2c070e4af528464c │ +│ SELECT * FROM books WHERE id = 2 │ 26f135b4936d6a21922074861e5180a4 │ b68f516c17d3c15b2c070e4af528464c │ +│ SELECT * FROM books WHERE id = 2 │ 26f135b4936d6a21922074861e5180a4 │ b68f516c17d3c15b2c070e4af528464c │ +└────────────────────────────────────────────────────────────────────────────────────────────────────────┘ +``` \ No newline at end of file From c1fba79dbe8e39c8eb4c32b6228c63909adfb6cf Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 24 Aug 2025 13:25:27 +0000 Subject: [PATCH 23/34] =?UTF-8?q?=F0=9F=8C=90=20Translate=2010-enterprise-?= =?UTF-8?q?features.md=20to=20Simplified-Chinese?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../54-query/03-optimization/query-profile.md | 64 +++++++++++++++++++ 1 file changed, 64 insertions(+) create mode 100644 docs/cn/guides/54-query/03-optimization/query-profile.md diff --git a/docs/cn/guides/54-query/03-optimization/query-profile.md b/docs/cn/guides/54-query/03-optimization/query-profile.md new file mode 100644 index 0000000000..1f77215b47 --- /dev/null +++ b/docs/cn/guides/54-query/03-optimization/query-profile.md @@ -0,0 +1,64 @@ +--- +title: 查询分析（Query Profile） +--- + +查询分析（Query Profile）是指特定 SQL 语句执行方式的图形化表示或可视化分解。它本质上是 [EXPLAIN](/sql/sql-commands/explain-cmds/explain) 命令的图形化版本，可以深入了解查询的执行计划和性能细节。 + +## 访问查询分析（Query Profile） + +查询分析（Query Profile）可以直接在 Databend Cloud 中访问。要查看查询的查询分析（Query Profile），请前往 **监控（Monitor）** > **SQL 历史（SQL History）**。从历史记录列表中选择一个 SQL 语句，然后单击 **查询分析（Query Profile）** 选项卡。如果您使用的是自托管的 Databend，可以使用 [EXPLAIN](/sql/sql-commands/explain-cmds/explain) 命令作为替代方案。 + +## 查询分析（Query Profile）包含什么 + +以下是一个查询分析（Query Profile）的示例，由三个层级结构的算子节点（Operator Node）组成。执行 SQL 语句时，Databend Cloud 会按自下而上的顺序处理这些节点。查询分析（Query Profile）中包含的算子节点（Operator Node）的数量和类型取决于 SQL 语句的具体内容。有关常见的算子及其统计字段，请参见[常见算子和字段](#common-operators--fields)。 + +![alt text](/img/cloud/query-profile-1.png) + +*请注意，每个节点标题中括号内的数字代表节点 ID，并*不*表示执行步骤。* + +查询分析（Query Profile）附带一组提供更多详细信息的信息窗格。上面的示例包括两个信息窗格： + +| 窗格 | 描述 | +| -------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| 开销最大的节点 | 列出执行时间最长的节点。 | +| 分析概览 | 显示 CPU 和 I/O 耗时的百分比。请注意，如果选择一个节点，此信息窗格将显示特定于所选节点的信息，而不是整个查询的信息。 | + +如果单击 `TableScan [4]` 节点，您会注意到右侧新增了两个信息窗格： + +![alt text](/img/cloud/query-profile-2.png) + +| 窗格 | 描述 | +| ---------- | ---------------------------------------------------------------------------------------------------------- | +| 统计信息 | 包括扫描进度、扫描字节数、从缓存中扫描的百分比、扫描的分区数等信息。 | +| 属性 | 显示特定于节点的详细信息。显示的字段根据节点的功能而有所不同。 | + +## 常见算子和字段 + +解释计划（Explained Plan）包括各种算子，具体取决于您希望 Databend EXPLAIN 的 SQL 语句。以下是常见算子及其字段的列表： + +* **TableScan**: 从表中读取数据。 + - table: 表的全名。例如，`catalog1.database1.table1`。 + - read rows: 要读取的行数。 + - read bytes: 要读取的数据字节数。 + - partition total: 表的总分区数。 + - partition scanned: 要读取的分区数。 + - push downs: 要下推到存储层进行处理的筛选器和限制。 +* **Filter**: 筛选读取的数据。 + - filters: 用于筛选数据的谓词表达式。表达式求值为 false 的数据将被筛选掉。 +* **EvalScalar**: 计算标量表达式。例如，`SELECT a+1 AS b FROM t` 中的 `a+1`。 + - expressions: 要计算的标量表达式。 +* **AggregatePartial** & **AggregateFinal**: 按键进行聚合，并返回聚合函数的结果。 + - group by: 用于聚合的键。 + - aggregate functions: 用于聚合的函数。 +* **Sort**: 按键对数据进行排序。 + - sort keys: 用于排序的表达式。 +* **Limit**: 限制返回的行数。 + - limit: 要返回的行数。 + - offset: 在返回任何行之前要跳过的行数。 +* **HashJoin**: 使用哈希连接（Hash Join）算法对两个表执行连接操作。哈希连接（Hash Join）算法会选择其中一个表作为构建端来构建哈希表。然后，它将使用另一个表作为探测端，从哈希表中读取匹配的数据以形成结果。 + - join type: JOIN 类型（INNER、LEFT OUTER、RIGHT OUTER、FULL OUTER、CROSS、SINGLE 或 MARK）。 + - build keys: 构建端用于构建哈希表的表达式。 + - probe keys: 探测端用于从哈希表中读取数据的表达式。 + - filters: 非等值 JOIN 条件，例如 `t.a > t1.a`。 +* **Exchange**: 在 Databend 查询节点之间交换数据，以进行分布式并行计算。 + - exchange type: 数据重分区类型（Hash、Broadcast 或 Merge）。 \ No newline at end of file From 8cbd9c53d140cbce80e2edb41942a3ad02189026 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 24 Aug 2025 13:29:39 +0000 Subject: [PATCH 24/34] =?UTF-8?q?=F0=9F=8C=90=20Translate=2010-enterprise-?= =?UTF-8?q?features.md=20to=20Simplified-Chinese?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/cn/guides/54-query/index.md | 146 ++++++++++++++++++++++--------- 1 file changed, 107 insertions(+), 39 deletions(-) diff --git a/docs/cn/guides/54-query/index.md b/docs/cn/guides/54-query/index.md index d99d09f8bf..b1dab4a9cc 100644 --- a/docs/cn/guides/54-query/index.md +++ b/docs/cn/guides/54-query/index.md @@ -2,55 +2,123 @@ title: 在 Databend 中查询数据 --- -Databend 支持标准 SQL 以及 ANSI SQL:1999 和 SQL:2003 分析扩展。本节涵盖查询技术、优化工具和高效数据处理的高级功能。 +Databend 支持标准 SQL，并带有 ANSI SQL:2003 分析扩展。本指南涵盖从基础到高级的核心查询技术，按学习路径组织，便于高效掌握。 -## 核心查询功能 +## 学习路径 -| 功能 | 描述 | 主要优势 | -|---------|-------------|--------------| -| [**通用表表达式 (CTE)**](00-cte.md) | 使用 WITH 子句定义命名临时结果集 | 提升查询可读性，支持子查询复用 | -| [**JOIN**](02-join.md) | 合并多表数据 | 支持内连接 (Inner)、外连接 (Outer)、交叉连接 (Cross)、半连接 (Semi) 和反连接 (Anti) | -| [**GROUP BY**](01-groupby/index.md) | 分组聚合数据（含扩展功能） | 支持 CUBE、ROLLUP 和 GROUPING SETS | -| [**Sequence**](02-sequences.md) | 生成连续数值序列 | 自动递增标识符与计数器 | +**📚 SQL 新手？** 从[基础查询](./00-basics/index.md)开始 +**🔗 需要连接数据？** 前往[组合数据](./01-combining-data/index.md) +**⚡ 需要自定义逻辑？** 查看[高级功能](./02-advanced/index.md) +**🚀 遇到性能问题？** 访问[查询优化（Query Optimization）](./03-optimization/index.md) -## 高级查询功能 +--- + +## 📚 [基础查询](./00-basics/index.md) + +掌握数据选择与聚合的基本 SQL 操作。 + +### [筛选与选择](./00-basics/filtering-selection.md) +```sql +-- 选择与筛选数据 +SELECT name, salary FROM employees +WHERE department = 'Engineering' +ORDER BY salary DESC; +``` + +### [聚合数据](./00-basics/aggregating-data.md) +```sql +-- 分组并汇总数据 +SELECT department, + COUNT(*) as emp_count, + AVG(salary) as avg_salary +FROM employees +GROUP BY department; +``` + +### [高级分组](./00-basics/groupby/index.md) +使用 CUBE、ROLLUP 和 GROUPING SETS 进行多维分析 + +--- + +## 🔗 [组合数据](./01-combining-data/index.md) + +通过 JOIN 和 CTE 连接多源数据。 -| 功能 | 类型 | 描述 | 使用场景 | -|---------|------|-------------|-----------| -| [**用户定义函数 (UDF)**](03-udf.md) | Lambda & 嵌入式 | 使用 Python、JavaScript、WebAssembly 实现自定义操作 | 复杂数据转换，定制业务逻辑 | -| [**外部函数**](04-external-function.md) | 云特性 | 通过外部服务器执行自定义操作 | 弹性扩展处理，集成外部库 | -| [**字典**](07-dictionary.md) | 数据集成 | 外部数据的内存键值存储 | 快速查询 MySQL、Redis 等数据源 | -| [**存储过程**](08-stored-procedure.md) | SQL 脚本 | 含控制流的可重用命令集 | 多步骤操作，复杂业务逻辑 | +### [JOIN](./01-combining-data/joins.md) +```sql +-- 关联相关表 +SELECT e.name, d.department_name +FROM employees e +JOIN departments d ON e.department_id = d.id; +``` -## 查询优化与分析 +### [公用表表达式（CTE）](./01-combining-data/cte.md) +```sql +-- 构建复杂查询 +WITH high_earners AS ( + SELECT * FROM employees WHERE salary > 75000 +) +SELECT department, COUNT(*) as count +FROM high_earners GROUP BY department; +``` -| 工具 | 用途 | 访问方式 | 核心特性 | -|------|---------|---------------|--------------| -| [**Query Profile**](05-query-profile.md) | 性能分析 | Databend Cloud Monitor | 可视化执行计划，性能指标 | -| [**Query Hash**](06-query-hash.md) | 查询标识 | SQL 函数 | 唯一查询指纹，性能追踪 | +--- + +## ⚡ [高级功能](./02-advanced/index.md) + +通过自定义函数与外部集成扩展能力。 + +### [用户自定义函数（User-Defined Functions）](./02-advanced/udf.md) +```sql +-- 创建可复用函数 +CREATE FUNCTION calculate_bonus(salary FLOAT, rating FLOAT) +RETURNS FLOAT AS $$ salary * rating * 0.1 $$; +``` + +### 更多高级功能 +- [外部函数（External Functions）](./02-advanced/external-function.md) - 云端机器学习集成 +- [存储过程（Stored Procedures）](./02-advanced/stored-procedure.md) - 多步操作 +- [序列（Sequences）](./02-advanced/sequences.md) - 唯一 ID 生成 -## GROUP BY 扩展 +--- + +## 🚀 [查询优化（Query Optimization）](./03-optimization/index.md) -| 扩展 | 描述 | 适用场景 | -|-----------|-------------|----------| -| [**CUBE**](01-groupby/group-by-cube.md) | 分组列的全组合聚合 | 多维数据分析 | -| [**ROLLUP**](01-groupby/group-by-rollup.md) | 分层小计与总计 | 层级报表生成 | -| [**GROUPING SETS**](01-groupby/group-by-grouping-sets.md) | 自定义分组组合 | 灵活聚合场景 | +利用分析工具诊断并提升查询性能。 -## 快速开始指南 +### [查询画像（Query Profile）](./03-optimization/query-profile.md) +可视化执行计划分析（Databend Cloud：监控 → SQL 历史） -1. **基础查询**：通过 [JOIN](02-join.md) 和 [GROUP BY](01-groupby/index.md) 实现基础数据操作 -2. **高级逻辑**：运用 [CTE](00-cte.md) 构建复杂查询结构 -3. **自定义函数**：通过 [UDF](03-udf.md) 实现定制化数据处理 -4. **性能优化**：利用 [Query Profile](05-query-profile.md) 获取优化建议 -5. **外部数据**：通过 [Dictionary](07-dictionary.md) 集成外部数据源 +### [性能分析](./03-optimization/query-hash.md) +```sql +-- 分析查询执行 +EXPLAIN SELECT * FROM orders o +JOIN customers c ON o.customer_id = c.id +WHERE o.order_date >= '2023-01-01'; +``` --- -### 优化说明： -1. 统一术语格式：技术术语采用 **中文 (英文)** 结构（如 "通用表表达式 (CTE)"） -2. 精简表达：将 "进行基本数据操作" 优化为 "实现基础数据操作"，"具有控制流的" 简化为 "含控制流的" -3. 专业表述："云功能" 改为 "云特性"，"获取优化洞察" 改为 "获取优化建议" -4. 术语一致性：全文档统一使用 "GROUP BY" 等原生技术名词 -5. 空格规范：确保中文与英文/数字间保留空格（如 "Python、JavaScript"） -6. 表格优化："最适用于" 改为 "适用场景"，"主要功能" 改为 "核心特性" \ No newline at end of file +## 快速参考 + +### 最常用模式 +```sql +-- Top N 查询 +SELECT * FROM employees ORDER BY salary DESC LIMIT 10; + +-- 筛选并聚合 +SELECT department, AVG(salary) +FROM employees +WHERE hire_date >= '2023-01-01' +GROUP BY department +HAVING AVG(salary) > 70000; + +-- 使用 CTE 进行连接 +WITH recent_orders AS ( + SELECT * FROM orders WHERE order_date >= '2023-01-01' +) +SELECT c.name, COUNT(*) as order_count +FROM customers c +JOIN recent_orders o ON c.id = o.customer_id +GROUP BY c.name; +``` \ No newline at end of file From 48ca12286d03c5a420eaaae3cb27e398932399f0 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 24 Aug 2025 13:30:19 +0000 Subject: [PATCH 25/34] =?UTF-8?q?=F0=9F=8C=90=20Translate=2010-enterprise-?= =?UTF-8?q?features.md=20to=20Simplified-Chinese?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../00-sql-reference/98-sql-scripting.md | 52 +++++++++---------- 1 file changed, 26 insertions(+), 26 deletions(-) diff --git a/docs/cn/sql-reference/00-sql-reference/98-sql-scripting.md b/docs/cn/sql-reference/00-sql-reference/98-sql-scripting.md index 46ddfc89cb..12130bf334 100644 --- a/docs/cn/sql-reference/00-sql-reference/98-sql-scripting.md +++ b/docs/cn/sql-reference/00-sql-reference/98-sql-scripting.md @@ -2,56 +2,56 @@ title: SQL 脚本 --- -本页概述了 Databend 中可用的 SQL 脚本选项。您可以将 SQL 脚本与以下任一查询方法结合使用： +本页面概述了 Databend 中可用的 SQL 脚本选项。你可以通过以下任一查询方法使用 SQL 脚本： -- [存储过程](/guides/query/stored-procedure) +- [存储过程 (Stored Procedure)](/sql/sql-commands/ddl/procedure/create-procedure) - [EXECUTE IMMEDIATE](/sql/sql-commands/administration-cmds/execute-immediate) ### 变量声明 -可以使用 `LET` 关键字声明变量，后跟变量名、可选类型和初始值。 +可以使用 `LET` 关键字声明变量，后跟变量名、可选的类型和初始值。 -```sql title='Examples:' +```sql title='示例：' LET x := 100; ``` ### 查询执行 -SQL 查询可以在脚本中执行，结果可以存储在变量或结果集中。 +SQL 查询可以在脚本中执行，结果可以存储在变量或结果集 (Result Set) 中。 -```sql title='Examples:' +```sql title='示例：' LET result RESULTSET := SELECT * FROM t1; ``` ### 控制流结构 -- **FOR 循环**: 迭代一个范围或结果集。 +- **FOR 循环**：遍历一个范围或结果集。 - ```sql title='Examples:' + ```sql title='示例：' FOR i IN 1..10 DO ... END FOR; ``` -- **WHILE 循环**: 只要指定的条件为真，就执行一个代码块。 +- **WHILE 循环**：在指定条件为真时执行代码块。 - ```sql title='Examples:' + ```sql title='示例：' WHILE condition DO ... END WHILE; ``` -- **REPEAT 循环**: 执行一个代码块，直到满足条件。 +- **REPEAT 循环**：执行代码块直到满足条件。 - ```sql title='Examples:' + ```sql title='示例：' REPEAT ... UNTIL condition END REPEAT; ``` -- **LOOP**: 无限期地执行一个代码块，直到遇到 `BREAK` 语句。 +- **LOOP**：无限期执行代码块，直到遇到 `BREAK` 语句。 - ```sql title='Examples:' + ```sql title='示例：' LOOP ... END LOOP; ``` -- **CASE 语句**: 允许基于不同条件有条件地执行代码块。 +- **CASE 语句**：允许根据不同条件有条件地执行代码块。 - ```sql title='Examples:' + ```sql title='示例：' CASE [operand] WHEN condition1 THEN ... WHEN condition2 THEN ... @@ -59,9 +59,9 @@ LET result RESULTSET := SELECT * FROM t1; END; ``` -- **IF 语句**: 基于条件执行一个代码块。 +- **IF 语句**：根据条件执行代码块。 - ```sql title='Examples:' + ```sql title='示例：' IF condition THEN ... ELSEIF condition THEN ... ELSE ... @@ -70,17 +70,17 @@ LET result RESULTSET := SELECT * FROM t1; ### RETURN -从脚本返回，带有一个可选值。 +从脚本返回，并可选择性地附带一个值。 -```sql title='Examples:' +```sql title='示例：' RETURN [expr]; ``` ### RETURN TABLE -从脚本返回，返回一个表结果作为 String 列。 +从脚本返回，并将表结果作为字符串列返回。 -```sql title='Examples:' +```sql title='示例：' EXECUTE IMMEDIATE $$ BEGIN CREATE OR REPLACE TABLE t1 (a INT, b FLOAT, c STRING); @@ -90,8 +90,8 @@ END; $$; ┌─────────────────────────────────────────────┐ -│ Result │ -│ String │ +│ 结果 │ +│ String │ ├─────────────────────────────────────────────┤ │ ┌─────────────────────────────────────────┐ │ │ │ a │ b │ c │ │ @@ -104,5 +104,5 @@ $$; ### 注释 -- **单行注释**: `-- comment` -- **多行注释**: `/* comment */` +- **单行注释**：`-- comment` +- **多行注释**：`/* comment */` \ No newline at end of file From 2415fe57df68492d2c3b2b40fde06e1de5f61467 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 24 Aug 2025 13:30:45 +0000 Subject: [PATCH 26/34] =?UTF-8?q?=F0=9F=8C=90=20Translate=2010-enterprise-?= =?UTF-8?q?features.md=20to=20Simplified-Chinese?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../create-aggregating-index.md | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/docs/cn/sql-reference/10-sql-commands/00-ddl/07-aggregating-index/create-aggregating-index.md b/docs/cn/sql-reference/10-sql-commands/00-ddl/07-aggregating-index/create-aggregating-index.md index cfc7056cce..e8fbae7a52 100644 --- a/docs/cn/sql-reference/10-sql-commands/00-ddl/07-aggregating-index/create-aggregating-index.md +++ b/docs/cn/sql-reference/10-sql-commands/00-ddl/07-aggregating-index/create-aggregating-index.md @@ -5,13 +5,13 @@ sidebar_position: 1 import FunctionDescription from '@site/src/components/FunctionDescription'; - + import EEFeature from '@site/src/components/EEFeature'; -在 Databend 中创建一个新的聚合索引。 +在 Databend 中创建一个新的聚合索引（Aggregating Index）。 ## 语法 @@ -19,23 +19,23 @@ import EEFeature from '@site/src/components/EEFeature'; CREATE [ OR REPLACE ] [ ASYNC ] AGGREGATING INDEX AS SELECT ... ``` -- `ASYNC` 选项：添加 ASYNC 是可选的。它允许异步创建索引。这意味着索引不会立即构建。要稍后构建它，请使用 [REFRESH AGGREGATING INDEX](refresh-aggregating-index.md) 命令。 +- `ASYNC` 选项：添加 ASYNC 是可选的。它允许异步创建索引，即索引不会立即构建。要稍后构建，请使用 [REFRESH AGGREGATING INDEX](refresh-aggregating-index.md) 命令。 -- 创建聚合索引时，请将其使用限制为标准 [Aggregate Functions](../../../20-sql-functions/07-aggregate-functions/index.md)（例如，AVG、SUM、MIN、MAX、COUNT 和 GROUP BY），同时请记住不接受 [GROUPING SETS](/guides/query/groupby/group-by-grouping-sets)、[Window Functions](../../../20-sql-functions/08-window-functions/index.md)、[LIMIT](../../20-query-syntax/01-query-select.md#limit-clause) 和 [ORDER BY](../../20-query-syntax/01-query-select.md#order-by-clause)，否则会出现错误：`Currently create aggregating index just support simple query, like: SELECT ... FROM ... WHERE ... GROUP BY ...`。 +- 创建聚合索引（Aggregating Index）时，请将其使用限制在标准的[聚合函数](../../../20-sql-functions/07-aggregate-functions/index.md)（例如 AVG、SUM、MIN、MAX、COUNT 和 GROUP BY）内，同时请注意，不支持 GROUPING SETS、[窗口函数](../../../20-sql-functions/08-window-functions/index.md)、[LIMIT](../../20-query-syntax/01-query-select.md#limit-clause) 和 [ORDER BY](../../20-query-syntax/01-query-select.md#order-by-clause)，否则将收到错误提示：`Currently create aggregating index just support simple query, like: SELECT ... FROM ... WHERE ... GROUP BY ...`。 -- 创建聚合索引时定义的查询筛选器范围应与实际查询的范围匹配或包含实际查询的范围。 +- 创建聚合索引（Aggregating Index）时定义的查询（Query）筛选范围应与实际查询（Query）的范围匹配或包含实际查询（Query）的范围。 -- 要确认聚合索引是否适用于查询，请使用 [EXPLAIN](../../40-explain-cmds/explain.md) 命令来分析查询。 +- 要确认聚合索引（Aggregating Index）是否对某个查询（Query）生效，请使用 [EXPLAIN](../../40-explain-cmds/explain.md) 命令来分析该查询（Query）。 ## 示例 -此示例为查询 "SELECT MIN(a), MAX(c) FROM agg" 创建一个名为 _my_agg_index_ 的聚合索引： +此示例为查询（Query） “SELECT MIN(a), MAX(c) FROM agg” 创建一个名为 *my_agg_index* 的聚合索引（Aggregating Index）： ```sql --- Prepare data +-- 准备数据 CREATE TABLE agg(a int, b int, c int); INSERT INTO agg VALUES (1,1,4), (1,2,1), (1,2,4), (2,2,5); --- Create an aggregating index +-- 创建一个聚合索引 CREATE AGGREGATING INDEX my_agg_index AS SELECT MIN(a), MAX(c) FROM agg; -``` +``` \ No newline at end of file From b896f21ffc4d9f9c1a538053a40896d6a48c826a Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 24 Aug 2025 13:31:12 +0000 Subject: [PATCH 27/34] =?UTF-8?q?=F0=9F=8C=90=20Translate=2010-enterprise-?= =?UTF-8?q?features.md=20to=20Simplified-Chinese?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../ddl-create-function.md | 30 ++++++++++++------- 1 file changed, 19 insertions(+), 11 deletions(-) diff --git a/docs/cn/sql-reference/10-sql-commands/00-ddl/11-external-function/ddl-create-function.md b/docs/cn/sql-reference/10-sql-commands/00-ddl/11-external-function/ddl-create-function.md index 8c73ced678..c68f67d490 100644 --- a/docs/cn/sql-reference/10-sql-commands/00-ddl/11-external-function/ddl-create-function.md +++ b/docs/cn/sql-reference/10-sql-commands/00-ddl/11-external-function/ddl-create-function.md @@ -4,9 +4,9 @@ sidebar_position: 1 --- import FunctionDescription from '@site/src/components/FunctionDescription'; - + -创建外部函数。 +创建外部函数（External Function）。 ## 语法 @@ -17,18 +17,26 @@ CREATE [ OR REPLACE ] FUNCTION [ IF NOT EXISTS ] [DESC=''] ``` -| 参数 | 描述 | +| 参数 | 描述 | |-----------------------|---------------------------------------------------------------------------------------------------| -| `` | 函数的名称。 | -| `` | 定义函数行为的 lambda 表达式或代码片段。 | -| `DESC=''` | UDF 的描述。| +| `` | 函数名称。 | +| `` | 定义函数行为的 lambda 表达式或代码片段。 | +| `DESC=''` | UDF 的描述。| | `<`| 输入参数名称列表，以逗号分隔。| | `<`| 输入参数类型列表，以逗号分隔。| -| `` | 函数的返回类型。 | -| `LANGUAGE` | 指定用于编写函数的语言。可用值：`python`。 | -| `HANDLER = ''` | 指定函数处理程序的名称。 | -| `ADDRESS = ''` | 指定 UDF 服务器的地址。 | +| `` | 函数的返回类型。 | +| `LANGUAGE` | 指定编写函数所用的语言。可选值：`python`。 | +| `HANDLER = ''` | 指定函数的处理程序名称。 | +| `ADDRESS = ''` | 指定 UDF 服务器的地址。 | ## 示例 -更多信息请参考 [使用示例](/guides/query/external-function#usage-examples)。 \ No newline at end of file +以下示例创建一个外部函数，用于计算两个整数的最大公约数（GCD）： + +```sql +CREATE FUNCTION gcd AS (INT, INT) + RETURNS INT + LANGUAGE python + HANDLER = 'gcd' + ADDRESS = 'http://localhost:8815'; +``` \ No newline at end of file From fc69f11a5c6235e95c5566cf36d0cb5f416ecc6d Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 24 Aug 2025 13:31:28 +0000 Subject: [PATCH 28/34] =?UTF-8?q?=F0=9F=8C=90=20Translate=2010-enterprise-?= =?UTF-8?q?features.md=20to=20Simplified-Chinese?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../00-ddl/11-external-function/index.md | 16 ++++++---------- 1 file changed, 6 insertions(+), 10 deletions(-) diff --git a/docs/cn/sql-reference/10-sql-commands/00-ddl/11-external-function/index.md b/docs/cn/sql-reference/10-sql-commands/00-ddl/11-external-function/index.md index 604e7d44ec..5232c4dcdd 100644 --- a/docs/cn/sql-reference/10-sql-commands/00-ddl/11-external-function/index.md +++ b/docs/cn/sql-reference/10-sql-commands/00-ddl/11-external-function/index.md @@ -2,20 +2,16 @@ title: 外部函数（External Function） --- -本文档全面介绍 Databend 中的外部函数操作，按功能分类组织以便查阅。 +本页面全面概述了 Databend 中的外部函数（External Function）操作，并按功能进行组织，方便参考。 -## 外部函数管理 +## 外部函数（External Function）管理 | 命令 | 描述 | |---------|-------------| -| [CREATE EXTERNAL FUNCTION](ddl-create-function.md) | 创建新的外部函数 | -| [ALTER EXTERNAL FUNCTION](ddl-alter-function.md) | 修改现有外部函数 | -| [DROP EXTERNAL FUNCTION](ddl-drop-function.md) | 删除外部函数 | - -## 相关主题 - -- [外部函数](/guides/query/external-function) +| [CREATE EXTERNAL FUNCTION](ddl-create-function.md) | 创建一个新的外部函数（External Function） | +| [ALTER EXTERNAL FUNCTION](ddl-alter-function.md) | 修改一个现有的外部函数（External Function） | +| [DROP EXTERNAL FUNCTION](ddl-drop-function.md) | 移除一个外部函数（External Function） | :::note -Databend 的外部函数支持通过 HTTP/HTTPS 端点与外部服务集成，从而扩展系统功能并利用外部计算资源。 +Databend 中的外部函数（External Function）允许你通过与 HTTP/HTTPS 端点集成的外部服务来扩展功能，从而利用外部处理能力。 ::: \ No newline at end of file From 26e05e615684088d047f3479b05bc7bf463a6c0d Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 24 Aug 2025 13:32:08 +0000 Subject: [PATCH 29/34] =?UTF-8?q?=F0=9F=8C=90=20Translate=2010-enterprise-?= =?UTF-8?q?features.md=20to=20Simplified-Chinese?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../00-ddl/18-procedure/create-procedure.md | 34 +++++++++---------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/docs/cn/sql-reference/10-sql-commands/00-ddl/18-procedure/create-procedure.md b/docs/cn/sql-reference/10-sql-commands/00-ddl/18-procedure/create-procedure.md index 00ec68fabc..bfdb74f9ed 100644 --- a/docs/cn/sql-reference/10-sql-commands/00-ddl/18-procedure/create-procedure.md +++ b/docs/cn/sql-reference/10-sql-commands/00-ddl/18-procedure/create-procedure.md @@ -3,9 +3,9 @@ title: CREATE PROCEDURE --- import FunctionDescription from '@site/src/components/FunctionDescription'; - + -定义一个存储过程，用于执行 SQL 操作并返回结果。 +定义一个存储过程（Stored Procedure），用于执行 SQL 操作并返回结果。 ## 语法 @@ -18,30 +18,30 @@ AS $$ BEGIN RETURN ; -- 用于返回单个值 - -- 或者 - RETURN TABLE(); -- 用于返回表 + -- OR + RETURN TABLE(); -- 用于返回一个表 END; $$; ``` -| 参数 | 描述 | -|-----------------------------------------|---------------------------------------------------------------------------------------------------------------------------| -| `` | 存储过程的名称。 | -| ` ` | 输入参数 (可选)，每个参数都有指定的数据类型。可以定义多个参数，用逗号分隔。 | -| `RETURNS [NOT NULL]` | 指定返回值的数据类型。`NOT NULL` 确保返回值不能为 NULL。 | -| `LANGUAGE` | 指定编写存储过程主体的语言。目前仅支持 `SQL`。详情请参见 [SQL Scripting](/guides/query/stored-procedure#sql-scripting)。 | -| `COMMENT` | 描述存储过程的可选文本。 | -| `AS ...` | 包含存储过程主体，其中包含 SQL 语句、变量声明、循环和 RETURN 语句。 | +| 参数 | 描述 | +|---|---| +| `` | 过程的名称。 | +| ` ` | 输入参数（可选），每个参数都有指定的数据类型。可以定义多个参数，并用逗号分隔。 | +| `RETURNS [NOT NULL]` | 指定返回值的数据类型。`NOT NULL` 确保返回值不能为 NULL。 | +| `LANGUAGE` | 指定编写过程主体的语言。目前仅支持 `SQL`。 | +| `COMMENT` | 描述过程的可选文本。 | +| `AS ...` | 包含过程主体，其中包含 SQL 语句、变量声明、循环和 RETURN 语句。 | ## 示例 -此示例定义了一个将重量从千克 (kg) 转换为磅 (lb) 的存储过程： +此示例定义了一个存储过程，用于将重量从千克（kg）转换为磅（lb）： ```sql CREATE PROCEDURE convert_kg_to_lb(kg DECIMAL(4, 2)) RETURNS DECIMAL(10, 2) LANGUAGE SQL -COMMENT = 'Converts kilograms to pounds' +COMMENT = '将千克转换为磅' AS $$ BEGIN RETURN kg * 2.20462; @@ -49,14 +49,14 @@ END; $$; ``` -您还可以定义一个使用循环、条件和动态变量的存储过程。 +你还可以定义一个使用循环、条件和动态变量的存储过程。 ```sql CREATE OR REPLACE PROCEDURE loop_test() RETURNS INT LANGUAGE SQL -COMMENT = 'loop test' +COMMENT = '循环测试' AS $$ BEGIN LET x RESULTSET := select number n from numbers(10); @@ -78,7 +78,7 @@ $$; ```sql CALL PROCEDURE loop_test(); -┌─Result─┐ +┌─ 结果 ─┐ │ -5 │ └────────┘ ``` \ No newline at end of file From 4a84c70d3b1b88283346a53075b5989cac5faa8a Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 24 Aug 2025 13:36:12 +0000 Subject: [PATCH 30/34] =?UTF-8?q?=F0=9F=8C=90=20Translate=2010-enterprise-?= =?UTF-8?q?features.md=20to=20Simplified-Chinese?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../10-sql-commands/20-query-syntax/04-query-join.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/cn/sql-reference/10-sql-commands/20-query-syntax/04-query-join.md b/docs/cn/sql-reference/10-sql-commands/20-query-syntax/04-query-join.md index 22a5411ae4..df4c4bf217 100644 --- a/docs/cn/sql-reference/10-sql-commands/20-query-syntax/04-query-join.md +++ b/docs/cn/sql-reference/10-sql-commands/20-query-syntax/04-query-join.md @@ -1,5 +1,5 @@ --- -title: JOIN +title: JOIN（连接） --- -Databend 支持多种 JOIN。 有关详细信息，请参阅 [JOINs](/guides/query/join)。 +Databend 支持多种 JOIN（连接）。 \ No newline at end of file From d5b487983404f1c142debcc9f41c616c5f283141 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 24 Aug 2025 13:36:20 +0000 Subject: [PATCH 31/34] =?UTF-8?q?=F0=9F=8C=90=20Translate=2010-enterprise-?= =?UTF-8?q?features.md=20to=20Simplified-Chinese?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../10-sql-commands/20-query-syntax/06-query-group-by.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/cn/sql-reference/10-sql-commands/20-query-syntax/06-query-group-by.md b/docs/cn/sql-reference/10-sql-commands/20-query-syntax/06-query-group-by.md index bf6e9e40d0..6d28bf4282 100644 --- a/docs/cn/sql-reference/10-sql-commands/20-query-syntax/06-query-group-by.md +++ b/docs/cn/sql-reference/10-sql-commands/20-query-syntax/06-query-group-by.md @@ -2,4 +2,4 @@ title: GROUP BY --- -Databend 支持 GROUP BY 以及各种扩展。更多信息，请参考 [GROUP BY](/guides/query/groupby/)。 \ No newline at end of file +Databend 支持 GROUP BY 及其多种扩展。 \ No newline at end of file From a95ed6aac3aa2774ca7629df7291f5e176659dbf Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 24 Aug 2025 13:36:36 +0000 Subject: [PATCH 32/34] =?UTF-8?q?=F0=9F=8C=90=20Translate=2010-enterprise-?= =?UTF-8?q?features.md=20to=20Simplified-Chinese?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../10-sql-commands/20-query-syntax/with-clause.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/cn/sql-reference/10-sql-commands/20-query-syntax/with-clause.md b/docs/cn/sql-reference/10-sql-commands/20-query-syntax/with-clause.md index f2a4f4ac75..9747c3822e 100644 --- a/docs/cn/sql-reference/10-sql-commands/20-query-syntax/with-clause.md +++ b/docs/cn/sql-reference/10-sql-commands/20-query-syntax/with-clause.md @@ -2,4 +2,4 @@ title: WITH 子句 --- -Databend 使用 WITH 子句来实现通用表表达式 (CTEs)。 更多信息，请参考 [CTEs](/guides/query/cte)。 \ No newline at end of file +Databend 使用 WITH 子句来定义公用表表达式（Common Table Expressions, CTE）。 \ No newline at end of file From 645aee541a0c79fcb7995b439b307ad059c0d60f Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 24 Aug 2025 13:36:59 +0000 Subject: [PATCH 33/34] =?UTF-8?q?=F0=9F=8C=90=20Translate=2010-enterprise-?= =?UTF-8?q?features.md=20to=20Simplified-Chinese?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../10-sql-commands/40-explain-cmds/explain.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/cn/sql-reference/10-sql-commands/40-explain-cmds/explain.md b/docs/cn/sql-reference/10-sql-commands/40-explain-cmds/explain.md index fe044b2ebd..484d79926b 100644 --- a/docs/cn/sql-reference/10-sql-commands/40-explain-cmds/explain.md +++ b/docs/cn/sql-reference/10-sql-commands/40-explain-cmds/explain.md @@ -2,9 +2,9 @@ title: EXPLAIN --- -显示 SQL 语句的执行计划。执行计划显示为一棵由不同算子组成的树，您可以在其中看到 Databend 将如何执行 SQL 语句。一个算子通常包含一个或多个字段，用于描述 Databend 将执行的操作或与查询相关的对象。 +显示 SQL 语句的执行计划。执行计划以树状结构展示，由不同的算子（Operator）组成，从中可以看到 Databend 将如何执行该 SQL 语句。一个算子（Operator）通常包含一个或多个字段，用于描述 Databend 将执行的操作或与查询相关的对象。 -例如，由 EXPLAIN 命令返回的以下执行计划包括一个名为 *TableScan* 的算子，其中包含多个字段。有关常见算子和字段的列表，请参见 [常见算子和字段](/guides/query/query-profile#common-operators--fields)。 +例如，以下 EXPLAIN 命令返回的执行计划包含一个名为 *TableScan* 的算子（Operator），该算子（Operator）包含多个字段。 ```sql EXPLAIN SELECT * FROM allemployees; @@ -19,7 +19,7 @@ TableScan └── push downs: [filters: [], limit: NONE] ``` -如果您正在使用 Databend Cloud，则可以利用查询 Profile 功能来可视化 SQL 语句的执行计划。有关更多信息，请参见 [查询 Profile](/guides/query/query-profile)。 +如果你正在使用 Databend Cloud，可以利用查询分析（Query Profile）功能来可视化 SQL 语句的执行计划。 ## 语法 From ed3243ecf5d5c53e4789bd5a927ebd1760fe71ff Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 24 Aug 2025 13:37:16 +0000 Subject: [PATCH 34/34] =?UTF-8?q?=F0=9F=8C=90=20Translate=2010-enterprise-?= =?UTF-8?q?features.md=20to=20Simplified-Chinese?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../19-dictionary-functions/dict-get.md | 22 +++++++++++-------- 1 file changed, 13 insertions(+), 9 deletions(-) diff --git a/docs/cn/sql-reference/20-sql-functions/19-dictionary-functions/dict-get.md b/docs/cn/sql-reference/20-sql-functions/19-dictionary-functions/dict-get.md index cc18385d0a..de066a6957 100644 --- a/docs/cn/sql-reference/20-sql-functions/19-dictionary-functions/dict-get.md +++ b/docs/cn/sql-reference/20-sql-functions/19-dictionary-functions/dict-get.md @@ -1,12 +1,11 @@ --- title: DICT_GET --- - import FunctionDescription from '@site/src/components/FunctionDescription'; - + -使用提供的键表达式从字典中检索指定属性的值。 +使用提供的键表达式（Key Expression）从字典（Dictionary）中检索指定属性（Attribute）的值。 ## 语法 @@ -14,12 +13,17 @@ import FunctionDescription from '@site/src/components/FunctionDescription'; DICT_GET([db_name.], '', ) ``` -| 参数 | 描述 | -| --------- | ------------------------------------------------------------------------ | -| dict_name | 字典的名称。 | -| attr_name | 字典中要检索值的属性名称。 | -| key_expr | 用于定位字典中特定条目的键表达式。它代表字典的主键值，以检索对应的数据。 | +| 参数 | 描述 | +|-----------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------| +| dict_name | 字典（Dictionary）的名称。 | +| attr_name | 要检索其值的字典（Dictionary）中的属性（Attribute）名称。 | +| key_expr | 用于在字典（Dictionary）中定位特定条目的键表达式（Key Expression）。它代表字典（Dictionary）主键（Primary Key）的值，用于检索相应的数据。 | ## 示例 -请参见 [使用示例](/guides/query/dictionary#usage-example). +此示例演示如何使用 DICT_GET 从字典（Dictionary）中检索值： + +```sql +-- 假设我们有一个名为 'user_info' 的字典，其中 'user_id' 是键，'name' 是一个属性 +SELECT DICT_GET('user_info', 'name', 12345); +``` \ No newline at end of file