npm - @clickzetta/cz-cli-darwin-x64 - Versions diffs - 0.3.76 → 0.3.80 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1236) hide show

package/bin/skills/lakehouse-doc/references/python-igs.md DELETED Viewed

@@ -1,297 +0,0 @@
-## ClickZetta Lakehouse Python SDK 实时写入
-## 安装
-1. 删除旧版本依赖
-如果安装过旧版本的sdk，先卸载旧版本的 clickzetta-connector-python 包 和 clickzetta-sqlalchemy 包
-```shell
-pip uninstall clickzetta-connector clickzetta-sqlalchemy clickzetta-ingestion-python clickzetta-ingestion-python-v2 -y
-```
-2. 安装 clickzetta-connector，Python版本要求 3.7 以上：
-```Bash
-pip install clickzetta-connector
-```
-## **实时写入原理**
-实时写入 Lakehouse 的Python SDK是一种高效的数据流处理工具，它允许用户将数据实时地上传并存储到Lakehouse中。以下是实时写入的工作原理：
-1. SDK上传数据 ：用户通过Python SDK将数据实时上传到Lakehouse的Ingestion Service。
-2. Ingestion Service处理 ：Ingestion Service接收到数据后，直接将数据写入到Lakehouse的表中，此时数据以临时中间文件的形式存储，这个阶段称为 混合表 。
-3. 查询实时数据 ：在数据提交之前，用户即可查询（select）到这些实时写入的新数据，但这些数据对于table stream、materialized view和dynamic table来说是不可见的。
-4. 数据提交 ：新写入的数据会在大约一分钟后自动提交，提交后，table stream、materialized view和dynamic table都能够读取这部分数据。
-5. 混合表变成普通表 ：在数据提交后，后台进程会将混合表合并变成普通表，合并完成后用户可以执行更新操作（update\merge\delete）。
-## **适用场景**
-实时写入 Lakehouse 的 Python SDK 适用于以下场景：
-* 短间隔数据导入 ：如果您的应用场景要求在非常短的时间间隔内（如5分钟或更短）导入数据，实时写入SDK可以满足您的需求。
-* 频繁小量数据提交 ：对于需要频繁提交数据，但每次提交的数据量不大的情况，实时写入SDK提供了一个高效的解决方案。
-* 实时数据分析 ：实时写入SDK适合需要对数据进行即时分析和响应的应用，例如实时监控、事件追踪和实时报告等。
-## **注意事项**
-* 实时写入的数据可以秒级查询。
-* 实时写入数据目前只能通过内部提供的 Flink Connector 中支持 schema change 的 sink 算子（单并发）来实现实时的表结构变化感知。在其他场景下进行表结构更改时，需要先停止实时写入任务，然后在表结构变更后一段时间（大约90分钟）后，重新启动任务。
-* table stream、materialized view 和 dynamic table 只能显示已经提交的数据。实时任务写入的数据需要等待 1 分钟才能确认，因此 table stream 也需要等待 1 分钟才能看到。
-## **数据类型支持**
-Lakehouse Python SDK支持以下数据类型映射：
-| SQL数据类型               | Python内部数据结构                   |
-| --------------------- | ------------------------------ |
-| BOOLEAN               | bool                           |
-| STRING / JSON         | str                            |
-| CHAR(n) / VARCHAR(n)  | str(超限写入将截断)                   |
-| BINARY                | bytes                          |
-| DECIMAL               | Decimal                        |
-| INT8                  | int                            |
-| INT16                 | int                            |
-| INT32                 | int                            |
-| INT64                 | int                            |
-| FLOAT                 | float                          |
-| DOUBLE                | float                          |
-| DATE                  | date                           |
-| TIMESTAMP\_LTZ        | datetime(tz=timezone)          |
-| TIMESTAMP\_NTZ        | datetime                       |
-| INTERVAL\_DAY\_TIME   | interval\_day\_time            |
-| INTERVAL\_YEAR\_MONTH | -                              |
-| ARRAY                 | list                           |
-| MAP                   | map                            |
-| STRUCT                | json or collections.namedtuple |
-## **通过客户端创建实时数据流**
-要创建实时数据流，首先需要使用 Lakehouse 客户端连接：
-```Python
-from clickzetta.connector.v0.connection import connect
-from clickzetta.connector.v0.enums import RealtimeOperation
-from clickzetta_ingestion.realtime.realtime_options import RealtimeOptionsBuilder, FlushMode
-from clickzetta_ingestion.realtime.arrow_stream import RowOperator
-# 创建连接
-with connect(username='your_username',
-             password='your_password',
-             service='your_service_endpoint',
-             instance='your_instance',
-             workspace='your_workspace',
-             schema='your_schema',
-             vcluster='your_vcluster') as conn:
-    # 创建实时数据流
-    stream = conn.get_realtime_stream(
-        schema="your_schema",
-        table="your_table",
-        operate=RealtimeOperation.APPEND_ONLY,  # 普通表使用APPEND_ONLY
-        options=RealtimeOptionsBuilder().with_flush_mode(FlushMode.AUTO_FLUSH_BACKGROUND).build()
-    )
-    # 使用完毕后关闭流
-    stream.close()
-```
-参数说明：
-* operate : 传入一个枚举值，实时接口支持 RealtimeOperation.APPEND\_ONLY 和 RealtimeOperation.CDC
-  * 普通表使用 RealtimeOperation.APPEND\_ONLY
-  * 主键表必须使用 RealtimeOperation.CDC
-* options : 用于传入实时写入流的参数，详见下文的选项说明
-## **选项（Options**）
-在Python SDK中，可以通过`RealtimeOptionsBuilder`类来配置实时写入流的参数。这些参数均为选填，推荐使用默认参数。
-```Python
-from clickzetta.ingestion.realtime.realtime_options import RealtimeOptionsBuilder, FlushMode, RetryStatus
-options = RealtimeOptionsBuilder()\
-        .with_flush_mode(FlushMode.AUTO_FLUSH_BACKGROUND) \
-        .with_mutation_buffer_lines_num(50000) \
-        .with_mutation_buffer_max_num(50) \
-        .with_mutation_buffer_space(20 * 1024 * 1024) \
-        .with_flush_interval(10 * 1000) \
-        .with_request_failed_retry_enable(True) \
-        .with_request_failed_retry_times(5) \
-        .with_request_failed_retry_internal_ms(5 * 1000) \
-        .with_request_failed_retry_log_debug_enable(True) \
-        .with_request_failed_retry_status([
-        RetryStatus.THROTTLED,
-        RetryStatus.INTERNAL_ERROR,
-        RetryStatus.FAILED,
-        RetryStatus.PRECHECK_FAILED]) \
-        .build()
-```
-**刷写控制**
-| 参数名               | 默认值                     | 说明                                                                                                                                           |
-| ----------------- | ----------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
-| with\_flush\_mode | AUTO\_FLUSH\_BACKGROUND | 数据刷写策略，可选： - AUTO\_FLUSH\_SYNC：同步刷写（阻塞式，保证顺序） - AUTO\_FLUSH\_BACKGROUND：异步刷写（高吞吐） - MANUAL\_FLUSH：手动触发刷写 ⚠️ 主键表限制：PK表强制使用AUTO\_FLUSH\_SYNC模式 |
-**缓冲区配置**
-| 参数名                                | 默认值               | 单位 | 说明                              |
-| ---------------------------------- | ----------------- | -- | ------------------------------- |
-| with\_mutation\_buffer\_lines\_num | 1000              | 条  | 行数阈值：单个缓冲区最大行数，达到后触发刷写          |
-| with\_mutation\_buffer\_space      | 10MB (1010241024) | 字节 | 空间阈值：单个缓冲区最大内存占用，与行数阈值任一达到即触发刷写 |
-| with\_mutation\_buffer\_max\_num   | 50                | 个  | 缓冲池容量：允许同时存在的缓冲区数量（类似连接池机制）     |
-**定时刷写**
-| 参数名                   | 默认值 | 说明                   |
-| --------------------- | --- | -------------------- |
-| with\_flush\_interval | 10秒 | 最大延迟：缓冲区未满时强制刷写的等待时间 |
-**重试机制参数组**
-| 参数名                                        | 默认值    | 说明         |
-| ------------------------------------------ | ------ | ---------- |
-| with\_request\_failed\_retry\_enable       | TRUE   | 是否启用失败重试机制 |
-| with\_request\_failed\_retry\_times        | 5      | 单次操作最大重试次数 |
-| with\_request\_failed\_retry\_internal\_ms | 5000ms | 重试间隔时间（毫秒） |
-**高级配置**
-| 参数名                                              | 默认值                                               | 说明                                                                                   |
-| ------------------------------------------------ | ------------------------------------------------- | ------------------------------------------------------------------------------------ |
-| with\_request\_failed\_retry\_status             | THROTTLED,INTERNAL\_ERROR,FAILED,PRECHECK\_FAILED | 重试触发条件： - THROTTLED：流控 - INTERNAL\_ERROR：服务端错误 - FAILED：常规失败 - PRECHECK\_FAILED：预检失败 |
-| with\_request\_failed\_retry\_log\_debug\_enable | TRUE                                              | 是否打印详细重试日志（DEBUG级别）                                                                  |
-## 写入数据（Row）
-通过`stream.create_row`方法创建具体的数据对象（Row），并通过`row.set_value`方法将数据封装到Row对象中。
-```Python
-# 创建一行数据
-row = stream.create_row(RowOperator.INSERT)  # 普通表使用INSERT
-# 设置字段值
-row.set_value("id", 1)
-row.set_value("name", "test_name")
-# 应用行数据到流中
-stream.apply(row)
-```
-**Row类型说明**：
-* 当Stream创建为`RealtimeOperation.APPEND_ONLY`时，仅能创建`RowOperator.INSERT`类型的Row。
-* 当Stream创建为`RealtimeOperation.CDC`时，可以使用以下Row类型：
-  * `RowOperator.UPSERT`：插入行，如果目标行已存在则更新该行。
-  * `RowOperator.DELETE_IGNORE`：删除行，如果目标行不存在则自动忽略。
-**注意**：主键表(PK表)必须使用CDC模式，且只能使用UPSERT和DELETE\_IGNORE操作类型。
-## 数据提交到服务端
-通过调用`stream.flush()`方法，数据会立即提交到服务端。如果没有显式调用此方法，数据会根据以下条件之一被自动提交：
-1. 达到`with_mutation_buffer_space`设置的缓冲区大小
-2. 达到`with_mutation_buffer_lines_num`设置的行数
-3. 达到`with_flush_interval`设置的时间间隔
-## 具体案例
-### 主键表（PK表）写入完整示例
-```Python
-from clickzetta.connector.v0.connection import connect
-from clickzetta.connector.v0.enums import RealtimeOperation
-from clickzetta_ingestion.realtime.arrow_stream import RowOperator
-from clickzetta_ingestion.realtime.realtime_options import RealtimeOptionsBuilder, FlushMode
-with connect(username='your_username',
-             password='your_password',
-             service='your_service_endpoint',
-             instance='your_instance',
-             workspace='your_workspace',
-             schema='your_schema',
-             vcluster='default') as conn:
-    # 创建主键表
-    cursor = conn.cursor()
-    cursor.execute("""
-    CREATE TABLE test_pk (
-        id STRING NOT NULL PRIMARY KEY,
-        name STRING,
-        age INT
-    )
-    """)
-    # 创建实时数据流 - 主键表必须使用CDC
-    stream = conn.get_realtime_stream(
-        schema=conn.get_schema(),
-        table="test_pk",
-        operate=RealtimeOperation.CDC,
-        options=RealtimeOptionsBuilder().with_flush_mode(FlushMode.AUTO_FLUSH_SYNC).build()
-    )
-    # 写入数据 - 主键表使用UPSERT
-    for i in range(10):
-        row = stream.create_row(RowOperator.UPSERT)
-        row.set_value('id', f"id_{i}")
-        row.set_value('name', f"user_{i}")
-        row.set_value('age', 20 + i)
-        stream.apply(row)
-    # 更新数据 - 主键表使用UPSERT
-    for i in range(5):
-        row = stream.create_row(RowOperator.UPSERT)
-        row.set_value('id', f"id_{i}")
-        row.set_value('name', f"updated_user_{i}")
-        row.set_value('age', 30 + i)
-        stream.apply(row)
-    # 删除数据 - 主键表使用DELETE_IGNORE
-    for i in range(2):
-        row = stream.create_row(RowOperator.DELETE_IGNORE)
-        row.set_value('id', f"id_{i}")
-        stream.apply(row)
-    # 关闭流
-    stream.close()
-    # 验证结果
-    cursor.execute("SELECT COUNT(*) FROM test_pk")
-    count = cursor.fetchone()[0]
-    print(f"剩余记录数: {count}")  # 应该是8条记录(10-2)
-```
-## 常见问题与解决方案
-### 1. 主键表写入失败
-**问题**: 向主键表写入数据时出现错误。
-**解决方案**:
-* 确保使用了正确的操作类型：主键表必须使用`RealtimeOperation.CDC`模式，且只能使用`RowOperator.UPSERT`和`RowOperator.DELETE_IGNORE`操作。
-* 确保主键字段已正确设置值。
-* 主键表不支持`FlushMode.AUTO_FLUSH_BACKGROUND`，会自动重置为`FlushMode.AUTO_FLUSH_SYNC`。
-* 分区列要求是primary key的子集。
-### **2. 内存占用过高**
-**问题**: 写入大量数据时内存占用过高。
-**解决方案**:
-* 减小`with_mutation_buffer_lines_num`和`with_mutation_buffer_space`参数值。
-* 定期调用`stream.flush()`手动刷新数据，并尽量避免 flush 过于频繁，会导致大量小文件产生。
-* 考虑分批写入数据而不是一次性写入大量数据。
-## 总结
-ClickZetta Python SDK的实时写入功能提供了高效、灵活的数据写入方式，支持各种数据类型和操作模式。通过合理配置参数，可以根据不同场景优化写入性能。
-对于主键表和普通表，需要使用不同的操作模式和行操作类型。主键表必须使用CDC模式，且只能使用UPSERT和DELETE\_IGNORE操作；普通表通常使用APPEND\_ONLY模式和INSERT操作。

package/bin/skills/lakehouse-doc/references/python_package_install_import_guide.md DELETED Viewed

@@ -1,53 +0,0 @@
-# Python任务安装分发包与导入使用指南
-本文用于指导在 Python 任务中，从官方源或清华源安装分发包，并在后续代码中稳定导入使用。
-## 适用场景
-* 需要在任务运行时临时安装第三方包。
-* 需要从公网官方源（PyPI）或国内镜像（清华源等）安装包。
-* 需要将包安装到自定义目录（如 `/home/system_normal`）后再 `import`。
-## 运行时安装说明
-* Python 任务运行在临时 Pod 中，任务结束后环境会销毁。所以每次运行都需要重新安装该依赖，不要依赖“上一次安装结果”。
-* 必须使用 `--target` 安装，且必须把该目录加入 `sys.path` 后再导入。因为当前python运行时环境无 Root 权限，无法安装到全局 site-packages 目录，只能安装到用户目录下（如 `/home/system_normal`）。
-* 清华源（网络受限时可选）：`https://pypi.tuna.tsinghua.edu.cn/simple`
-## 标准模板（推荐直接复用）
-```python
-import subprocess
-import sys
-TARGET_DIR = "/home/system_normal"
-subprocess.check_call([
-    sys.executable, "-m", "pip", "install",
-    "config",
-    "--target", TARGET_DIR,
-    "-i", "https://pypi.tuna.tsinghua.edu.cn/simple"
-])
-sys.path.append(TARGET_DIR)
-from config import *
-```
-## 快速切换到清华源
-仅需把模板中的 `INDEX_URL` 改为：
-```python
-INDEX_URL = "https://pypi.tuna.tsinghua.edu.cn/simple"
-```
-## 常见错误与排查
-### 报错：`ModuleNotFoundError: No module named 'xxx'`
-按顺序检查：
-* 是否使用了 `--target`，但没有把该目录加入 `sys.path`。
-* 是否在 `import` 之后才追加路径（顺序错误）。
-* 是否把路径用 `append` 加到了末尾，导致被其他路径遮蔽。
-* 包名与模块名是否一致（有些包 `pip install A`，但 `import B`）。

package/bin/skills/lakehouse-doc/references/python_reference/connector.md DELETED Viewed

@@ -1,281 +0,0 @@
-# ClickZetta Connector 官方 Python SDK
-`clickzetta-connector` 是云器 ClickZetta Lakehouse 的官方 Python SDK，遵循 PEP-249 规范，提供了一个符合 Python Database API 风格的 SQL 调用接口。通过使用该接口，您可以轻松地在 Python 应用程序中执行 SQL 查询、插入、更新和删除操作。
-它还支持批量数据上传（bulkload）功能，可以大幅提高数据导入速度，这对于处理大量数据的场景尤为有用。
-### 使用示例
-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
-```
-1. 安装 clickzetta-connector，Python 版本要求 (>= 3.7)：
-```shell
-pip install clickzetta-connector
-```
-## 快速开始
-### 执行 SQL 查询
-以下是一个简单的示例，展示了如何使用 `clickzetta-connector` 执行 SQL 查询：
-```python
-from clickzetta import connect
-### 建立连接
-conn = connect(
-    username='your_username',
-    password='your_password',
-    service='region_id.api.clickzetta.com',
-    instance='your_instance',
-    workspace='your_workspace',
-    schema='public',
-    vcluster='default'
-)
-```
-| **参数**    | **是否必填** | **描述**                                                                                                                              |
-|-----------|----------| ----------------------------------------------------------------------------------------------------------------------------------- |
-| username  | Y        | 用户名                                                                                                                                 |
-| password  | Y        | 密码                                                                                                                                  |
-| service   | Y        | 连接 Lakehouse 的地址，region\_id.api.clickzetta.com。可以在 Lakehouse Studio 管理 -> 工作空间中看到 JDBC 连接串![](../.topwrite/assets/image_1728887857029.png) |
-| instance  | Y        | 可以在 Lakehouse Studio 管理 -> 工作空间中查看 JDBC 连接串获取![](../.topwrite/assets/image_1729051500396.png)                                            |
-| workspace | Y        | 使用的工作空间                                                                                                                             |
-| vcluster  | Y        | 使用的 VC                                                                                                                               |
-| schema    | Y        | 访问的 schema 名                                                                                                                          |
-| protocol  | N        | 默认值为 'https'，支持 'http' 和 'https'                                                                                                     |
-### 简单查询案例
-```python
-#创建游标对象
-cursor = conn.cursor()
-#执行 SQL 查询
-cursor.execute('SELECT * FROM clickzetta_sample_data.ecommerce_events_history.ecommerce_events_multicategorystore_live LIMIT 10;')
-#获取查询结果
-results = cursor.fetchall()
-for row in results:
-print(row)
-```
-### 使用 SQL hints
-在 JDBC 中通过 set 命令设置的 SQL hints 可以通过 `parameters` 参数传递，支持的参数请参考 [参数管理](../sql-parmaters.md)。以下是一个示例：
-```python
-#设置作业运行超时时间为 30 秒
-my_param = {
-    'hints': {
-        'sdk.job.timeout': 30
-    }
-}
-cursor.execute('YOUR_SQL_QUERY', parameters=my_param)
-```
-### 使用
-## 更多示例
-### 1. 处理查询结果
-以下示例展示了如何处理查询结果，例如将结果保存到 CSV 文件中：
-```python
-import csv
-# 执行查询
-cursor.execute('SELECT * FROM clickzetta_sample_data.ecommerce_events_history.ecommerce_events_multicategorystore_live LIMIT 10;')
-# 获取查询结果
-results = cursor.fetchall()
-# 将结果保存到 CSV 文件
-with open('output.csv', 'w', newline='', encoding='utf-8') as csvfile:
-    csv_writer = csv.writer(csvfile)
-    csv_writer.writerow([column[0] for column in cursor.description])
-    csv_writer.writerows(results)
-# 关闭连接
-cursor.close()
-conn.close()
-```
-### 高级功能
-> 注意：以下高级功能需要使用 `clickzetta-connector-python >= 0.8.82` 版本，或者 clickzetta-connector 版本 >= 1.0.11。
-#### 参数绑定
-clickzetta-connector 支持两种参数绑定风格，遵循 [PEP-249](https://peps.python.org/pep-0249/#paramstyle) 规范：
-| paramstyle | 描述                             | 示例                                    |
-| ---------- | ------------------------------ | ------------------------------------- |
-| qmark      | 使用问号 (?) 作为参数占位符                | `INSERT INTO test VALUES (?)`         |
-| pyformat   | 使用 Python 扩展格式代码，例如 `%(name)s` | `INSERT INTO test VALUES (%(value)s)` |
-##### 使用问号风格 (qmark)
-```python
-# 简单示例
-cursor.execute('INSERT INTO test (id, name) VALUES (?, ?)', binding_params=[1, 'test'])
-# JSON 类型示例
-json_data = "JSON '" + '{"id": 2, "value": "100", "comment": "JSON Sample data"}' + "'"
-my_param = {
-    'hints': {
-        'sdk.job.timeout': 30
-    }
-}
-cursor.execute('INSERT INTO test (id, json_col) VALUES (?, ?)', my_param, binding_params=[1, json_data])
-```
-##### 使用 qmark 风格批量插入
-使用 `executemany()` 方法支持高效地使用 qmark 风格执行批量插入操作：
-```python
-# 准备数据
-data = [
-    (1, 'test1'),
-    (2, 'test2'),
-    (3, 'test3')
-]
-# 执行批量插入
-cursor.executemany('INSERT INTO test (id, name) VALUES (?, ?)', data)
-```
-如需对输入的数据根据表结构进行自动转换，请开启 `tolerant` 参数并指定类型：
-```python
-# 准备数据
-data = [
-    (1, 'test1'),
-    (2, 0),
-    (3, 0.1)
-]
-hints = {'hints': {
-    "cz.sql.type.conversion": "tolerant"
-}}
-# 执行批量插入
-cursor.executemany('INSERT INTO test (id, name) VALUES (int(?), string(?))', data, hints)
-```
-##### 使用 Python 格式风格 (pyformat)
-```python
-# 使用命名参数
-data = {'id': 1, 'name': 'test'}
-cursor.execute('INSERT INTO test (id, name) VALUES (%(id)s, "%(name)s")', data)
-```
-> 注意：在 pyformat 风格中，参数值为字符串时插入需要加引号。
-##### 完整示例：复杂数据类型的批量插入
-以下示例展示了如何使用 `executemany` 插入包含各种数据类型的数据：
-```python
-table = 'test_table'
-cursor.execute(f'''
-    CREATE TABLE {table} (
-        c_bigint BIGINT,
-        c_boolean BOOLEAN,
-        c_binary BINARY,
-        c_char CHAR,
-        c_date DATE,
-        c_decimal DECIMAL(20, 6),
-        c_double DOUBLE,
-        c_float FLOAT,
-        c_int INT,
-        c_interval INTERVAL DAY,
-        c_smallint SMALLINT,
-        c_string STRING,
-        c_timestamp TIMESTAMP,
-        c_tinyint TINYINT,
-        c_array ARRAY<STRUCT<a: INT, b: STRING>>,
-        c_map MAP<STRING, STRING>,
-        c_struct STRUCT<a: INT, b: STRING, c: DOUBLE>,
-        c_varchar VARCHAR(1024),
-        c_json JSON
-    )
-''')
-data = [
-    (
-        1,
-        True,
-        b'\x01',
-        'a',
-        datetime.date(2022, 2, 1),
-        1000.123456,
-        2.0,
-        1.5,
-        42,
-        'INTERVAL 1 DAY',
-        103,
-        'test string 1',
-        datetime.datetime.now(),
-        11,
-        [(1, 'A')],
-        {'key1': 'value1'},
-        (1, 'A', 2.0),
-        'varchar example 1',
-        ("JSON '" + '{"id": 2, "value": "100", "comment": "JSON Sample data"}' + "'")
-    )
-]
-sql = f'''
-    INSERT INTO {table} (
-        c_bigint, c_boolean, c_binary, c_char, c_date, c_decimal, c_double,
-        c_float, c_int, c_interval, c_smallint, c_string, c_timestamp,
-        c_tinyint, c_array, c_map, c_struct, c_varchar, c_json
-    ) VALUES (
-        ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
-    )
-'''
-cursor.executemany(sql, data)
-my_param = {'hints': {}}
-# 获取结果
-cursor.execute(f'SELECT * FROM {table}', my_param)
-result = cursor.fetchall()
-```
-#### 异步执行 (execute\_async)
-`execute_async()` 方法支持异步执行 SQL 查询，特别适用于长时间运行的查询：
-```python
-# 异步执行查询
-cursor.execute_async('SELECT * FROM large_table')
-# 检查查询是否完成
-while not cursor.is_job_finished():
-    print("查询执行中...")
-    time.sleep(1)
-# 获取结果
-results = cursor.fetchall()
-```
-#### 注意事项
-* 不支持 commit 和 rollback 接口
-^

package/bin/skills/lakehouse-doc/references/python_reference/python-sdk-summary.md DELETED Viewed

@@ -1,13 +0,0 @@
-# Lakehouse Python SDK
-ClickZetta Lakehouse Python SDK 是为 Python 开发者提供的一套工具包，旨在简化与 ClickZetta Lakehouse 交互的过程。本 SDK 的 Python 包为 clickzetta-connector。您可以在 https://pypi.org/project/clickzetta-connector/#history 查看其发布历史。
-- ClickZetta Connector 遵循 PEP 249 规范，提供了一个符合 Python Database API 风格的 SQL 调用接口。通过该接口，您可以轻松地在 Python 应用程序中执行 SQL 查询、插入、更新和删除操作。
-- 支持批量数据上传（bulkload）功能，可以大幅提高数据导入速度。这对于处理大量数据的场景尤为有用。
-- 支持实时上传功能，允许用户将数据逐行发送到 Lakehouse，适用于对数据新鲜度要求较高的场景。
-通过该 Python SDK，您可以轻松地在 Python 应用程序中与 ClickZetta Lakehouse 进行交互，满足各种数据处理需求。