@clickzetta/cz-cli-darwin-x64 0.3.76 → 0.3.78

package/bin/skills/lakehouse-doc/references/python_reference/sqlalchemy.md

@@ -1,77 +0,0 @@
-# ClickZetta SQLAlchemy 适配器
-
-`clickzetta-connector` 是 SQLAlchemy 的 ClickZetta Lakehouse dialect 适配器，它允许使用 SQLAlchemy 接口编写的代码或上层应用轻松地与 ClickZetta Lakehouse 进行交互。
-
-## 安装
-
-0. 删除旧版本依赖
-
-如果已安装旧版本的 SDK，请先卸载以避免冲突：
-
-```shell
-pip uninstall clickzetta-connector clickzetta-connector-python clickzetta-sqlalchemy clickzetta-ingestion-python clickzetta-ingestion-python-v2 -y
-```
-
-> 卸载前请记录旧版本的包信息，以防需要回退。查看已安装包版本的命令：
-
-```shell
-pip show clickzetta-connector clickzetta-sqlalchemy clickzetta-ingestion-python clickzetta-ingestion-python-v2 clickzetta-connector-python
-```
-
-通过 pip 安装 `clickzetta-connector`：
-
-```shell
-pip install clickzetta-connector -U
-```
-
-## 快速入门
-
-### 执行 SQL 查询
-
-```python
-from sqlalchemy import create_engine
-from sqlalchemy import text
-
-# 创建 ClickZetta Lakehouse 的 SQLAlchemy 引擎实例
-engine = create_engine(
-    "clickzetta://username:password@instance.region_id.api.clickzetta.com/workspace?schema=schema&vcluster=default"
-)
-
-# 执行 SQL 查询
-sql = text("SELECT * FROM ecommerce_events_multicategorystore_live;")
-
-# 使用引擎执行查询
-with engine.connect() as conn:
-    result = conn.execute(sql)
-    for row in result:
-        print(row)
-```
-
-### 示例：使用 PyGWalker 对 Lakehouse 数据进行可视化分析
-
-[PyGWalker](https://github.com/Kanaries/pygwalker) 是一个可以将 pandas 和 polars 数据框转换为 Tableau 风格用户界面的工具，用于数据可视化探索。它简化了 Jupyter Notebook 的数据分析和数据可视化工作流程，只需添加一行代码即可实现。
-
-```python
-from sqlalchemy import create_engine
-from sqlalchemy import text
-import pandas as pd
-import pygwalker as pyg
-
-# 创建 ClickZetta Lakehouse 的 SQLAlchemy 引擎实例
-engine = create_engine(
-    "clickzetta://username:password@instance.region_id.api.clickzetta.com/workspace?schema=schema&vcluster=default"
-)
-
-# 执行 SQL 查询
-sql = text("SELECT * FROM ecommerce_events_multicategorystore_live;")
-
-# 使用引擎执行查询并获取结果
-with engine.connect() as conn:
-    result = conn.execute(sql)
-    df = pd.DataFrame(result.fetchall(), columns=result.keys())
-
-# 使用 PyGWalker 对 DataFrame 进行可视化分析
-walker = pyg.walk(df)
-```
-
-^

package/bin/skills/lakehouse-doc/references/python_shell_datasource.md

@@ -1,334 +0,0 @@
-# Python/Shell 任务中使用数据源
-
-## 功能概述
-
-Python/Shell 任务，支持使用预先配置好的[数据源](config-datasource.md)。通过在运行环境里内置的 `clickzetta-dbutils` 工具包，在任务中可直复用`管理->数据源`中的连接配置信息，无需在节点中通过代码来重复设定，可提高敏感信息的安全性，也带来了开发和管理的便捷。
-
-^
-
-当前支持的数据源包括：
-
-* Lakehouse数据源
-* MySQL数据源
-* PostgreSQL数据源
-
-##
-
-## 界面操作指南
-
-### 在Python/Shell任务中选择数据源
-
-在Python/Shell任务的配置面板中，可以选择使用一个或多个数据源（确保数据源已经在管理->数据源里新建并测试连通通过）。该配置会作用于当前任务的直接运行或调度运行：
-
-![](.topwrite/assets/image_1742284598370.png =560)
-
-*注：当前工作空间的默认 Lakehouse 数据源，在此处不需添加即可在代码里直接访问*。
-
-###
-
-### 在代码中访问数据源
-
-添加完数据源后，即可开始编写 Python/Shell 任务代码，我们需要调用 `clickzetta_dbutils` python库中提供的 `get_active_engine("your_datasource_name")` 函数，仅需填写数据源名称，无需指定数据源URL、密码等连接信息即可完成数据源的连接。另外，还支持使用 `Builder` 模式，详见下文的 API 使用指南和代码示例。
-
-##
-
-## API 使用指南
-
-### get\_active\_engine
-
-Studio Python 节点中创建数据库引擎的便捷函数（当前支持MySQL、Postgres、Lakehouse三类数据源）。
-
-#### 函数签名
-
-```py
-def get_active_engine(
-    ds_name: Optional[str] = None,
-    vcluster: Optional[str] = None,
-    workspace: Optional[str] = None,
-    schema: Optional[str] = None,
-    options: Optional[Dict[str, str]] = None,
-    query: Optional[Dict[str, str]] = None,
-    driver: Optional[str] = None,
-    host: Optional[str] = None,
-    *args, **kwargs
-) -> Engine
-```
-
-#### 参数说明
-
-1. ds\_name (str): 数据源名称，必填。该值必须要和`管理->数据源`里引用的数据源名称相同
-2. vcluster (str, optional): ClickZetta数据源的虚拟集群名称，对ClickZetta数据源，必填
-3. workspace (str, optional): 工作空间名称，默认为当前使用的工作空间
-4. schema (str, optional): 连接的schema名称，默认为'public'
-5. options (dict, optional): 额外的连接选项
-6. query (dict, optional): SQLAlchemy URL的额外查询参数
-
-#### 返回值
-
-* SQLAlchemy Engine实例
-
-#### 示例
-
-* 已经在`管理->数据源`里增加了"qiliang\_test\_pg"的Postgres数据源
-* 在当前Python节点里的数据库里增加了"qiliang\_test\_pg"，并且选择的数据库为"answer", 数据库Schema为public
-* 通过get\_active\_engine直接访问qiliang\_test\_pg->answer->public里的表
-
-```
-from sqlalchemy import text
-from clickzetta_dbutils import get_active_engine
-pg_engine = get_active_engine("qiliang_test_pg")
-# 连接并执行查询
-with pg_engine.connect() as pgconnection:
-    result = pgconnection.execute(text("SELECT * FROM question limit 10;"))
-    for row in result:
-        print(row)
-```
-
-* 通过get\_active\_engine设置参数访问qiliang\_test\_pg里其它数据库里的表（需要在`管理->数据源`里增加了"qiliang\_test\_pg"时候配置允许访问其它有权限的数据库，比如PG里的数据库为"sample", 数据库Schema为"public"）
-
-```py
-from sqlalchemy import text
-from clickzetta_dbutils import get_active_engine
-pg_engine = get_active_engine("qiliang_test_pg",schema="sample",options={"search_path":"public"})
-# 连接并执行查询
-with pg_engine.connect() as pgconnection:
-    result = pgconnection.execute(text("SELECT * FROM accounts limit 10;"))
-    for row in result:
-        print(row)
-```
-
-###
-
-### get\_active\_lakehouse\_engine
-
-创建Lakehouse数据源数据库引擎的便捷函数。
-
-#### 函数签名
-
-```py
-def get_active_lakehouse_engine(
-    vcluster: Optional[str] = None,
-    workspace: Optional[str] = None,
-    schema: Optional[str] = None,
-    options: Optional[Dict[str, str]] = None,
-    query: Optional[Dict[str, str]] = None,
-    driver: Optional[str] = None,
-    *args, **kwargs
-) -> Engine
-```
-
-#### 参数说明
-
-1. vcluster (str, optional): ClickZetta数据源的虚拟集群名称，必填
-2. workspace (str, optional): 工作空间名称，默认为当前使用的工作空间
-3. schema (str, optional): 连接的schema名称，默认为'public'
-4. options (dict, optional): 额外的连接选项
-5. query (dict, optional): SQLAlchemy URL的额外查询参数
-6. driver (str, optional): 连接的驱动名称
-
-#### 返回值
-
-* SQLAlchemy Engine实例
-
-#### 异常
-
-* DatabaseConnectionError: 配置中未找到lakehouse数据源时抛出
-
-#### 示例
-
-* 在`计算`->`集群`里查看要使用的集群名称为"default"
-* 在`开发`->`数据`里查看要访问的数据为空间 "ql\_ws" 里的schema "brazilianecommerce" 里的表 "olist\_customers"
-* 通过get\_active\_lakehouse\_engine直接访问qiliang\_test\_pg->answer->public里的表
-
-```py
-from sqlalchemy import text
-import pandas as pd
-
-from clickzetta_dbutils import get_active_lakehouse_engine
-
-engine = get_active_lakehouse_engine(vcluster="default",schema="brazilianecommerce")
-# 连接并执行查询
-with engine.connect() as connection:
-        result = connection.execute(text("SELECT * FROM olist_customers limit 10;"))
-        df = pd.DataFrame(result.fetchall(), columns=result.keys())
-        print(df.head(10))
-```
-
-###
-
-### DatabaseConnectionManager
-
-数据库连接管理器，支持链式调用配置连接参数，仅在 `build(self, *args, **kwargs)` 被调用是才会触发 SQLAlchemy 的实际连接。
-
-#### use\_workspace
-
-设置连接的工作空间，仅 Lakehouse 数据源需要设置。
-
-```Python
-def use_workspace(self, workspace: str) -> 'DatabaseConnectionManager'
-```
-
-#### use\_schema
-
-设置连接的schema。
-
-```Python
-def use_schema(self, schema: str) -> 'DatabaseConnectionManager'
-```
-
-*注*：*由于我们使用SQLAlchemy的设计，Postgres use\_schema 应该填写为 database 名称*
-
-#### use\_vcluster
-
-设置连接的虚拟集群，仅 Lakehouse 数据源需要设置。
-
-```Python
-def use_vcluster(self, vcluster: str) -> 'DatabaseConnectionManager'
-```
-
-#### use\_options
-
-设置额外的连接选项。
-
-```Python
-def use_options(self, options: dict) -> 'DatabaseConnectionManager'
-```
-
-*注*：*由于我们使用SQLAlchemy的设计，Postgres schema 应该填写为* `undefined"})`
-
-#### use\_query
-
-设置连接的查询参数。
-
-```Python
-def use_query(self, query: dict) -> 'DatabaseConnectionManager'
-```
-
-#### build
-
-根据数据源名称和可选配置创建SQLAlchemy引擎。
-
-```Python
-def build(self, *args, **kwargs) -> Engine
-```
-
-#### 使用示例
-
-```py
-from clickzetta_dbutils import DatabaseConnectionManager
-
-# 链式调用示例
-engine = DatabaseConnectionManager("mysql_source_name")\
-    .use_schema("test_schema")\
-    .use_options({"charset": "utf8"})\
-    .build()
-
-# Lakehouse连接示例
-engine = DatabaseConnectionManager("LAKEHOUSE_source_name")\
-    .use_vcluster("default")\
-    .use_workspace("test-workspace")\
-    .use_schema("public")\
-    .build()
-```
-
-> 备注：其中 “LAKEHOUSE\_source\_name” 是指数据源管理中Lakehouse数据源的名称。
-
-## 代码示例
-
-### Python节点中使用PostgreSQL数据源示例
-
-示例为获取 postgres\_source\_name 数据源的所有 pg tables:
-
-```py
-from sqlalchemy import text
-from clickzetta_dbutils import get_active_engine
-
-# 使用默认schema
-engine = get_active_engine("postgres_source_name")
-with engine.connect() as conn:
-    results = conn.execute(text("SELECT * FROM pg_tables WHERE schemaname = 'public';"))
-    for row in results:
-        print(row)
-
-# 指定database和options中指定schema
-engine = get_active_engine("postgres_source_name", 
-                          schema="pg_database", 
-                          options={"search_path":"pg_schema"})
-```
-
-###
-
-### Python节点中使用MySQL数据源示例
-
-```py
-from sqlalchemy import text
-from clickzetta_dbutils import DatabaseConnectionManager
-
-# 查看所有可用的数据源配置
-print(DatabaseConnectionManager.load_connection_configs())
-
-# 创建连接并指定schema
-manager = DatabaseConnectionManager("mysql_source_name")
-manager.use_schema("test_schema")
-engine = manager.build()
-
-with engine.connect() as conn:
-    result = conn.execute(text("select * from test_table limit 1;"))
-```
-
-###
-
-### Python节点中使用Lakehouse数据源示例
-
-```py
-from sqlalchemy import text
-from clickzetta_dbutils import get_active_engine
-
-# 方式一：使用get_active_engine
-engine = get_active_engine("LAKEHOUSE_source_name", 
-                          vcluster="default", 
-                          workspace="test-workspace", 
-                          schema="public")
-
-# 方式二：使用get_active_lakehouse_engine
-from clickzetta_dbutils import get_active_lakehouse_engine
-engine = get_active_lakehouse_engine(vcluster="default", 
-                                   workspace="test-workspace")
-with engine.connect() as conn:
-    results = conn.execute(text("select 1"))
-    for row in results:
-        print(row)
-```
-
-###
-
-### Shell节点中使用数据源示例
-
-在Shell节点中，可以通过创建Python脚本文件的方式使用数据源：
-
-```bash
-cat >> /tmp/db_utils_demo.py << EOF
-from sqlalchemy import text
-from clickzetta_dbutils import get_active_engine
-
-engine = get_active_engine("postgres_source_name")
-with engine.connect() as conn:
-    results = conn.execute(text("SELECT * FROM test_table;"))
-    for row in results:
-        print(row)
-EOF
-
-python /tmp/db_utils_demo.py
-```
-
-##
-
-## 注意事项
-
-1. 数据源配置支持在Adhoc执行和调度执行两种场景下使用。
-2. 使用不存在的数据源名称会报错，请确保在使用前，Studio 中 `开发 -> python 任务 -> 数据源` 要选择相应的数据源。Postgres和MySQL数据源必须要在 `管理->数据源 `中新建并测试连通并确保通过。
-3. 使用Lakehouse数据源时必须配置vcluster参数。Lakehouse数据源直接使用在 `管理->数据源 `看到的内置Lakehouse数据源。
-4. 数据源的连接信息会被安全处理，可避免明文密码泄露。
-5. 支持在同一个节点中使用多个不同类型的数据源。
-
-^

package/bin/skills/lakehouse-doc/references/query-json-sy.md

@@ -1,47 +0,0 @@
-本文旨在指导用户如何利用 SQL 语法高效地查询 JSON 类型的数据。通过掌握这些查询方法，用户能够简化查询流程。JSON 类型的创建请参考文档 [JSON类型](<JSON.md>)。
-
-## **语法**
-
-```SQL
---键名访问JSON对象中的字段
-json_column['key']['key']...
---通过索引访问JSON数组中的元素
-json_array[index]
-```
-
-**参数说明**
-
-* `json_column`：表示一个 JSON 字段，其类型为 JSON 对象。通过键名（`key`，指定为字符串）来定位并检索 JSON 对象内的特定数据字段。使用单个方括号 `[]` 可以访问对象的一级字段；而嵌套使用双方括号 `[][]` 则能够深入检索对象的二级或更深层次的字段。
-* `json_array`：表示数组类型的 JSON 字段，用于根据索引（index）访问 JSON 数组的元素，索引起始值为 0。
-
-**返回值说明**
-- 返回值为 JSON 类型。如需其他类型，可使用 CAST 函数进行强制转换。类型转换请参考 [JSON类型](<JSON.md>) 文档。
-
-## **案例**
-
-### 取出JSON一级结构
-
-```SQL
-SELECT parse_json(s)['firstName'] as j
-      FROM VALUES ('{ "firstName": "John", "lastName": "doe", "age": 26, "address": { "streetAddress": "naist street", "city": "Nara", "postalCode": "630-0192" }, "phoneNumbers": [ { "type": "iPhone", "number": "0123-4567-8888" }, { "type": "home", "number": "0123-4567-8910", "extra": [] } ] }'),
-                  ('{ "firstName": "Ada", "lastName": "doe", "age": 20, "address": { "streetAddress": "naist street", "city": "Nara", "postalCode": "630-0192" }, "address2": {"city": "NewYork"}, "phoneNumbers": [ { "type": "iPhone", "number": "0123-4567-8888" }, { "type": "home", "number": "0123-4567-8910", "extra": [1,2,3] } ] }')
-                 as t(s);
-```
-
-### 取出JSON二级结构
-
-```SQL
-SELECT parse_json(s)['address']['streetAddress'] as j
-      FROM VALUES ('{ "firstName": "John", "lastName": "doe", "age": 26, "address": { "streetAddress": "naist street", "city": "Nara", "postalCode": "630-0192" }, "phoneNumbers": [ { "type": "iPhone", "number": "0123-4567-8888" }, { "type": "home", "number": "0123-4567-8910", "extra": [] } ] }'),
-                  ('{ "firstName": "Ada", "lastName": "doe", "age": 20, "address": { "streetAddress": "naist street", "city": "Nara", "postalCode": "630-0192" }, "address2": {"city": "NewYork"}, "phoneNumbers": [ { "type": "iPhone", "number": "0123-4567-8888" }, { "type": "home", "number": "0123-4567-8910", "extra": [1,2,3] } ] }')
-                 as t(s);
-```
-
-### 取出JSON数组中的元素
-
-```SQL
-SELECT parse_json(s)['phoneNumbers'][0]['number'] as j
-      FROM VALUES ('{ "firstName": "John", "lastName": "doe", "age": 26, "address": { "streetAddress": "naist street", "city": "Nara", "postalCode": "630-0192" }, "phoneNumbers": [ { "type": "iPhone", "number": "0123-4567-8888" }, { "type": "home", "number": "0123-4567-8910", "extra": [] } ] }'),
-                  ('{ "firstName": "Ada", "lastName": "doe", "age": 20, "address": { "streetAddress": "naist street", "city": "Nara", "postalCode": "630-0192" }, "address2": {"city": "NewYork"}, "phoneNumbers": [ { "type": "iPhone", "number": "0123-4567-8888" }, { "type": "home", "number": "0123-4567-8910", "extra": [1,2,3] } ] }')
-                 as t(s);
-```

package/bin/skills/lakehouse-doc/references/query-syntax.md

@@ -1,234 +0,0 @@
-# Lakehouse SQL查询语句
-
-## 功能简介
-
-Lakehouse支持使用标准的SQL SELECT语句进行数据查询。本文档将详细介绍查询语句的基本语法、参数说明以及使用示例，帮助您更高效地进行数据查询。
-
-## 基本语法
-
-```SQL
-[WITH cte [, ...] ]
-SELECT 
-[ hints ] 
-[ ALL | DISTINCT ]
-select_expr [, (except_expr)] ...
-FROM table_reference
-[WHERE where_condition ] 
-[GROUP BY [GROUPING SETS | ROLLUP | CUBE] {col_name | expr | position}]
-    [ HAVING having_condition ]
-[ ORDER BY order_condition [ ASC | DESC ] ]
-[ LIMIT  <number> [OFFSET <number>]]
-```
-
-## 参数说明
-
-**1. WITH cte** (可选)
-[公用表表达式](WITH.md)，用于在查询中定义临时结果集。
-
-**2. ALL | DISTINCT** (可选)：对结果集进行刷选，all 为全部，distinct 将刷选出重复列，默认为 all
-
-```
---表示不对cp_start_date_sk去重
-SELECT ALL cp_start_date_sk FROM catalog_page;
---表示对cp_start_date_sk去重
-SELECT DISTINCT cp_start_date_sk FROM catalog_page;
-```
-
-**3. HINTS** (可选): 帮助Lakehouse优化器作出更好的计划决策。目前支持[map join](mapjoin.md)如下案例
-
-```SQL
-SELECT /*+ MAPJOIN (t2) */ * FROM table1 t1
-JOIN table2 t2
-ON (t1.emp_id = t2.emp_id);
-```
-
-**4. select\_expr** (必填)
-指定需要查询的列，支持列名、列表达式等。例如：col1\_name, col2\_name, 列表达式, ...
-
-**1）排除列**（可选）
-可选。`except_expr`格式为`except(col1_name, col2_name, ...)`。当您希望读取表内大多数列的数据，同时要排除表中少数列的数据时，可以通过`SELECT * except(col1_name, col2_name, ...) from ...;`语句实现，表示读取表数据时会排除指定列（col1、col2）的数据。
-
-命令示例如下。
-
-```SQL
---表结构如下
-DESC students;
-+-------------+-----------+---------+
-| column_name | data_type | comment |
-+-------------+-----------+---------+
-| name        | string    |         |
-| class       | string    |         |
-+-------------+-----------+---------+
---排除class列
-SELECT * EXCEPT(class) FROM students LIMIT 1;
-+-------+
-| name  |
-+-------+
-| Alice |
-+-------+
-```
-
-**2）where\_condition** (可选)
-过滤条件，用于筛选满足指定条件的数据。支持关系运算符、like、rlike、in、not in、between…and等。
-
-* 配合关系运算符，筛选满足指定条件的数据。关系运算符包含：
-
-  * `>`、`<`、`=`、`>=`、`<=`、`<>`
-  * `like`、`rlike`
-  * `in`、`not in`
-  * `between…and`
-
-**5. GROUP BY expression**(可选)
-
-通常，group by和聚合函数配合使用，根据指定的普通列、分区列或正则表达式进行分组。`Grouping Sets`、`Rollup`、`Cube` 为 group by 的扩展，详细可以参考[GROUPING SET](groupby.md)，group by使用规则如下：
-
-* group by操作优先级高于select操作，因此group by的取值是select输入表的列名或由输入表的列构成的表达式。需要注意的是：
-
-  * group by取值为正则表达式时，必须使用列的完整表达式。
-  * select语句中没有使用聚合函数的列必须出现在group by中。
-
-**6. having\_condition**(可选)
-通常`having`子句与聚合函数一起使用，实现过滤。
-
-**7. order\_condition** (可选)
-对所有数据按照指定列或常量进行全局排序。默认为升序排序，可使用`desc`关键字进行降序排序。默认情况下，升序排序会将 `NULL` 值放在最前面，而降序排序则将 `NULL` 放在最后面。Order by 是比较耗时耗资源的操作，因为所有数据都需要发送到 1 个节点后才能排序，排序操作相比不排序操作需要更多的内存。
-
-**8. LIMIT ... OFFSET** (可选)
-
-* LIMIT \<number> 表示查询结果只返回前 \<number> 条记录，其中 \<number> 是一个正整数。这个语法可以用来分页或者限制查询的数据量。支持LIMIT m,n写法。**使用 limit  offset的时候要加上 order by 才有意义，否则每次执行的数据可能会不一致**
-* OFFSET \<number> 表示查询结果跳过前 \<number> 条记录，然后返回剩余的记录，其中 \<number> 是一个正整数。这个语法可以用来指定查询的起始位置。OFFSET关键字也可以用逗号代替
-* LIMIT 和 OFFSET 可以同时使用，也可以单独使用。如果同时使用，那么 OFFSET 必须在 LIMIT 之后。例如，LIMIT 10 OFFSET 20 表示查询结果跳过前 20 条记录，然后返回接下来的 10 条记录。
-
-## 查询历史版本数据
-
-除标准 `SELECT` 选项外，Lakehoue还支持用户在定义的时间段内的任何时间点访问历史数据，包括已更改或删除的数据。支持查询表、动态表和物化视图
-**请注意**：对象的历史查询取决于数据的保留周期。当前版本的数据保留周期默认为1天。您可以通过执行[ALTER命令](TIMETRAVEL.md)来调整保留周期。请注意，修改保留周期可能会增加存储成本。具体使用方式参考[TIME TRAVEL](TIMETRAVEL.md)
-
-```sql
-SELECT 
-    table_identifier TIMESTAMP AS OF timestamp_expression
-```
-
-通过使用TIMESTAMP AS OF子句，用户可以指定具体的时间点，查询保留期内表历史记录中指定点的精确位置或紧邻指定点之前的数据。Timestamp\_expression是一个返回时间戳类型表达式的参数，例如：
-
-* `'2023-11-07 14:49:18'`，即可强制转换为时间戳的字符串。
-* `CAST('2023-11-07 14:49:18' AS TIMESTAMP)`。
-* `CURRENT_TIMESTAMP() - INTERVAL 12 HOURS`。12小时之前的版本
-* 任何本身是时间戳类型或可强制转换为时间戳的表达式。
-  使用示例
-
-```
-SELECT * FROM events TIMESTAMP AS OF TIMESTAMP'2024-10-18 22:15:12.013'
-```
-
-## 语法糖：Trailing Commas
-
-在SQL语句中，使用Trailing Commas可以让语句更容易阅读和编辑。即使在最后一个值或参数后面多了一个逗号，也不会报错。例如：
-
-```SQL
-SELECT    client_ip,
-          client_identity,
-          userid,
-          user_agent,
-          log_time
-          -- status_code 
-FROM      server_logs;
-```
-
-## 注意事项
-
-* 建议您将提交的查询文本（即SQL语句）的大小限制为每个语句5MB。大于5MB的SQL文本将无法提交。如果您有超出5MB的SQL文本，请提交工单解决。
-  当然可以，以下是根据您提供的 Apache Doris `SELECT` 语句文档和 Lakehouse SQL查询语句文档，生成的使用示例和最佳实践：
-
-### 使用示例
-
-1. **基本查询**
-   ```SQL
-   -- 查询所有学生的姓名和班级
-   SELECT name, class FROM students;
-   ```
-
-2. **使用WITH子句（公用表表达式**）
-   ```SQL
-   WITH ranked_students AS (
-     SELECT name, class, RANK() OVER (ORDER BY score DESC) as rank
-     FROM students
-   )
-   SELECT * FROM ranked_students WHERE rank <= 10;
-   ```
-
-3. **去重查询**
-   ```SQL
-   -- 查询不同的班级名称
-   SELECT DISTINCT class FROM students;
-   ```
-
-4. **使用HINTS优化查询**
-   ```SQL
-   SELECT /*+ MAPJOIN(t2) */ * FROM students t1
-   JOIN classes t2 ON t1.class_id = t2.id;
-   ```
-
-5. **条件筛选**
-   ```SQL
-   -- 查询年龄大于20岁的学生姓名
-   SELECT name FROM students WHERE age > 20;
-   ```
-
-6. **GROUP BY 和聚合函数**
-   ```SQL
-   -- 按班级分组，查询每个班级的平均成绩
-   SELECT class, AVG(score) FROM students GROUP BY class;
-   ```
-
-7. **使用HAVING子句**
-   ```SQL
-   -- 查询平均成绩大于60分的班级
-   SELECT class, AVG(score) as avg_score FROM students GROUP BY class HAVING avg_score > 60;
-   ```
-
-8. **ORDER BY 和 LIMIT**
-   ```SQL
-   -- 查询成绩降序排列的前5名学生
-   SELECT name, score FROM students ORDER BY score DESC LIMIT 5;
-   ```
-
-9. **查询历史版本数据**
-   ```SQL
-   -- 查询2024-10-18 22:15:12.013时刻的学生表数据
-   SELECT * FROM students TIMESTAMP AS OF TIMESTAMP'2024-10-18 22:15:12.013';
-   ```
-
-10. join示例
-    参考[Join](JOIN.md)相关使用
-
-## 最佳实践
-
-1. **利用分区分桶过滤**
-   * 尽可能利用Lakehouse的分区分桶作为数据过滤条件，减少数据扫描范围。
-
-2. **使用索引字段**
-   * 充分利用Lakehouse的索引字段作为数据过滤条件加速查询速度。参考[索引](guid-index.md)。
-
-3. **合理使用聚合**
-   * 聚合操作应该在数据量较大时使用，以减少数据传输和提高查询效率。
-
-4. **使用ORDER BY和LIMIT进行分页**
-   * 当需要分页查询时，使用ORDER BY和LIMIT组合可以有效地获取特定页面的数据。
-
-5. **注意数据类型匹配**
-   * 在使用UNION或JOIN时，确保连接的列具有相同的数据类型。
-
-6. **避免大查询文本**
-   * 将查询文本大小限制在5MB以内，以避免提交失败。
-
-7. **使用HAVING子句过滤聚合结果**
-   * HAVING子句应该在聚合函数之后使用，以过滤聚合后的结果集。
-
-8. **使用WITH子句简化复杂查询**
-   * 公用表表达式（WITH子句）可以简化复杂的查询，使其更易于理解和维护。
-
-9. **注意查询成本**
-   * 修改数据保留周期可能会增加存储成本，合理设置数据保留周期以平衡查询需求和成本。
-
-^