@clickzetta/cz-cli-linux-x64 0.3.0 → 0.3.1

package/bin/skills/clickzetta-ai-vector-search/SKILL.md

@@ -0,0 +1,160 @@
+---
+name: clickzetta-ai-vector-search
+description: |
+  在 ClickZetta Lakehouse 中实现向量存储、向量索引（HNSW）和向量检索，
+  构建 RAG、语义搜索、图像检索等 AI 应用。覆盖 VECTOR 数据类型定义、
+  向量索引创建（cosine/l2/hamming 距离）、向量数据插入与转换、
+  ANN 近似最近邻检索、向量+倒排索引融合检索等完整工作流。
+  当用户说"向量检索"、"向量索引"、"语义搜索"、"embedding 存储"、
+  "RAG"、"ANN 搜索"、"HNSW"、"cosine_distance"、"l2_distance"、
+  "VECTOR 类型"、"向量数据库"、"相似度搜索"、"向量 + 标量融合检索"、
+  "文本向量化"时触发。
+  Keywords: vector, HNSW, embedding, RAG, semantic search, similarity, VECTOR type
+---
+
+# ClickZetta 向量检索
+
+Lakehouse 原生支持 VECTOR 数据类型和 HNSW 向量索引，无需独立向量数据库即可在同一张表中实现向量检索、全文检索和标量过滤的融合查询。
+
+阅读 [references/vector-search.md](references/vector-search.md) 了解完整语法。
+
+---
+
+## 快速开始
+
+### 1. 建表（含向量索引）
+
+```sql
+CREATE TABLE doc_embeddings (
+    id      INT,
+    content STRING,
+    vec     VECTOR(FLOAT, 1024),
+    INDEX vec_idx (vec) USING VECTOR PROPERTIES (
+        "distance.function" = "cosine_distance",
+        "scalar.type"       = "f32"
+    )
+);
+```
+
+### 2. 插入向量数据
+
+```sql
+-- 直接插入
+INSERT INTO doc_embeddings VALUES
+    (1, '云器 Lakehouse 产品介绍', vector(0.12, 0.34, ...));
+
+-- 从字符串转换（适合 API 返回的 JSON 格式）
+INSERT INTO doc_embeddings (id, content, vec)
+SELECT id, content, CAST(embedding_str AS VECTOR(1024))
+FROM staging_table;
+```
+
+### 3. 向量检索
+
+```sql
+-- 设置探索因子（精度 vs 速度）
+SET cz.vector.index.search.ef = 64;
+
+-- 余弦距离 Top-10 相似文档
+SELECT id, content, cosine_distance(vec, CAST('[0.12, 0.34, ...]' AS VECTOR(1024))) AS dist
+FROM doc_embeddings
+ORDER BY dist
+LIMIT 10;
+```
+
+---
+
+## 向量 + 标量融合检索（RAG 场景）
+
+```sql
+-- 先用标量过滤缩小范围，再用向量排序
+SELECT id, content, cosine_distance(vec, :query_embedding) AS dist
+FROM doc_embeddings
+WHERE category = 'product'
+  AND created_at >= '2024-01-01'
+ORDER BY dist
+LIMIT 5;
+```
+
+---
+
+## 向量 + 全文检索融合
+
+```sql
+-- 建表：同时支持向量索引和倒排索引
+CREATE TABLE hybrid_docs (
+    id      INT,
+    title   STRING,
+    body    STRING,
+    vec     VECTOR(FLOAT, 1024),
+    INDEX body_inv_idx (body) USING INVERTED,
+    INDEX vec_idx (vec) USING VECTOR PROPERTIES (
+        "distance.function" = "cosine_distance"
+    )
+);
+
+-- 融合检索：关键词过滤 + 向量排序
+SELECT id, title, cosine_distance(vec, :query_vec) AS dist
+FROM hybrid_docs
+WHERE body LIKE '%向量检索%'
+ORDER BY dist
+LIMIT 10;
+```
+
+---
+
+## 外部系统写入向量（ARRAY → VECTOR 转换）
+
+外部系统（Python SDK、Kafka 等）不能直接写 VECTOR 类型，需先写 ARRAY 再转换：
+
+```sql
+-- 暂存表（ARRAY 类型）
+CREATE TABLE staging (id INT, vec_array ARRAY<FLOAT>);
+
+-- 转换写入目标表
+INSERT INTO doc_embeddings (id, vec)
+SELECT id, CAST(vec_array AS VECTOR(FLOAT, 1024))
+FROM staging;
+```
+
+---
+
+## 距离函数速查
+
+| 函数 | 适用场景 |
+|---|---|
+| `cosine_distance(v1, v2)` | 文本语义检索（最常用） |
+| `l2_distance(v1, v2)` | 图像/通用向量检索 |
+| `dot_product(v1, v2)` | 归一化向量的相似度 |
+| `hamming_distance(v1, v2)` | 二值向量（高效压缩） |
+| `binary_quantize(v)` | 将 float 向量压缩为二值向量 |
+
+---
+
+## 性能调优
+
+```sql
+-- 调整探索因子（默认 64，越大精度越高但越慢）
+SET cz.vector.index.search.ef = 128;
+
+-- 验证向量索引是否生效
+EXPLAIN SELECT id, cosine_distance(vec, vector(0.1, 0.2)) AS dist
+FROM doc_embeddings ORDER BY dist LIMIT 10;
+-- 查看执行计划中是否有 vector_index_search_type 字样
+```
+
+**最佳实践：**
+- 向量检索建议**单独占用 VCluster**，避免与其他查询争抢缓存
+- 大批量写入后执行 `BUILD INDEX vec_idx ON table_name` 为存量数据构建索引
+- 外部系统写入时先写 ARRAY，再批量 CAST 转换，避免频繁小文件
+
+---
+
+## 常见问题
+
+| 问题 | 原因 | 解决方案 |
+|---|---|---|
+| 向量索引未生效 | 存量数据未构建索引 | 执行 `BUILD INDEX idx ON table` |
+| 检索精度低 | ef 值太小 | 增大 `cz.vector.index.search.ef` |
+| 外部写入报错 | 不支持直接写 VECTOR | 先写 ARRAY，再 CAST 转换 |
+| 向量检索慢 | 与其他查询共用 VCluster | 为向量检索单独分配 VCluster |

package/bin/skills/clickzetta-ai-vector-search/references/vector-search.md

@@ -0,0 +1,155 @@
+# 向量检索参考
+
+> 来源：https://www.yunqi.tech/documents/vector-search 等
+
+## VECTOR 数据类型
+
+```sql
+-- 语法
+vector(scalar_type, dimension)
+vector(dimension)  -- 默认 float 类型
+
+-- 示例
+CREATE TABLE embeddings (
+    id       INT,
+    content  STRING,
+    vec      VECTOR(FLOAT, 1024),   -- 1024 维 float 向量
+    vec_bin  VECTOR(TINYINT, 128)   -- 128 维 tinyint 向量（二值化）
+);
+```
+
+支持的元素类型：`FLOAT`（f32）、`TINYINT`（i8/b1）
+
+---
+
+## 创建向量索引
+
+```sql
+-- 建表时内联创建
+CREATE TABLE doc_embeddings (
+    id      INT,
+    content STRING,
+    vec     VECTOR(FLOAT, 1024),
+    INDEX vec_idx (vec) USING VECTOR PROPERTIES (
+        "distance.function" = "cosine_distance",
+        "scalar.type"       = "f32",
+        "m"                 = "16",
+        "ef.construction"   = "128"
+    )
+);
+
+-- 在已有表上添加向量索引
+ALTER TABLE doc_embeddings ADD INDEX vec_idx (vec) USING VECTOR PROPERTIES (
+    "distance.function" = "cosine_distance",
+    "scalar.type"       = "f32"
+);
+
+-- 为存量数据构建索引
+BUILD INDEX vec_idx ON doc_embeddings;
+```
+
+### 关键参数
+
+| 参数 | 可选值 | 默认值 | 说明 |
+|---|---|---|---|
+| distance.function | l2_distance, cosine_distance, jaccard_distance, hamming_distance | cosine_distance | 距离函数 |
+| scalar.type | f32, f16, i8, b1 | f32 | 索引元素类型 |
+| m | 建议 ≤ 1000 | 16 | HNSW 最大邻居数 |
+| ef.construction | 建议 ≤ 5000 | 128 | 构建时候选集大小 |
+| compress.codec | uncompressed/zstd/lz4 | uncompressed | 压缩算法 |
+
+---
+
+## 插入向量数据
+
+```sql
+-- 直接插入
+INSERT INTO doc_embeddings (id, content, vec) VALUES
+    (1, 'hello world', vector(0.1, 0.2, 0.3, ...)),
+    (2, 'foo bar',     vector(0.4, 0.5, 0.6, ...));
+
+-- 从字符串转换
+INSERT INTO doc_embeddings (id, vec)
+SELECT id, CAST('[0.1, 0.2, 0.3]' AS VECTOR(3))
+FROM source_table;
+
+-- 从 ARRAY 列转换（外部系统写入场景）
+INSERT OVERWRITE doc_embeddings
+SELECT id, content, CAST(vec_array AS VECTOR(FLOAT, 1024))
+FROM staging_table;
+```
+
+---
+
+## 向量检索
+
+```sql
+-- 调整探索因子（精度 vs 速度权衡）
+SET cz.vector.index.search.ef = 64;
+
+-- L2 距离检索（欧几里得距离，越小越相似）
+SELECT id, content, l2_distance(vec, vector(0.1, 0.2, 0.3, ...)) AS dist
+FROM doc_embeddings
+ORDER BY dist
+LIMIT 10;
+
+-- 余弦距离检索（越小越相似）
+SELECT id, content, cosine_distance(vec, CAST('[0.1,0.2,0.3]' AS VECTOR(3))) AS dist
+FROM doc_embeddings
+ORDER BY dist
+LIMIT 10;
+
+-- 带过滤条件的向量检索（向量 + 标量融合）
+SELECT id, content, cosine_distance(vec, :query_vec) AS dist
+FROM doc_embeddings
+WHERE category = 'tech'
+  AND cosine_distance(vec, :query_vec) < 0.3
+ORDER BY dist
+LIMIT 10;
+```
+
+---
+
+## 距离函数速查
+
+| 函数 | 适用场景 | 说明 |
+|---|---|---|
+| `l2_distance(v1, v2)` | 通用语义检索 | 欧几里得距离，越小越相似 |
+| `cosine_distance(v1, v2)` | 文本语义检索 | 余弦距离，越小越相似 |
+| `dot_product(v1, v2)` | 归一化向量 | 点积，越大越相似 |
+| `hamming_distance(v1, v2)` | 二值向量 | 汉明距离，越小越相似 |
+| `jaccard_distance(v1, v2)` | 集合相似度 | 雅卡德距离 |
+| `binary_quantize(v)` | 向量压缩 | 将 float 向量二值化 |
+
+---
+
+## 向量 + 倒排索引融合检索
+
+```sql
+-- 建表：同时支持向量索引和倒排索引
+CREATE TABLE hybrid_search (
+    id      INT,
+    content STRING,
+    vec     VECTOR(FLOAT, 1024),
+    INDEX content_inv_idx (content) USING INVERTED,
+    INDEX vec_idx (vec) USING VECTOR PROPERTIES (
+        "distance.function" = "cosine_distance"
+    )
+);
+
+-- 融合检索：先用倒排过滤，再用向量排序
+SELECT id, content, cosine_distance(vec, :query_vec) AS dist
+FROM hybrid_search
+WHERE content LIKE '%关键词%'
+ORDER BY dist
+LIMIT 10;
+```
+
+---
+
+## 注意事项
+
+- 向量类型不支持 `ORDER BY` 或 `GROUP BY`（只能对距离函数结果排序）
+- 向量索引性能与内存/磁盘缓存直接相关，建议**单独占用 VCluster**
+- 外部系统写入时不能直接写 VECTOR 类型，需先写 ARRAY 再 CAST 转换
+- `ef` 值越大，检索精度越高但延迟越大；建议从 64 开始调优

package/bin/skills/clickzetta-app-python-sdk/SKILL.md

@@ -0,0 +1,153 @@
+---
+name: clickzetta-app-python-sdk
+description: |
+  在 Python 应用程序中集成 ClickZetta Lakehouse 的官方 SDK 用法。
+  覆盖 clickzetta-connector-python（SQL 查询、参数绑定、批量插入、异步执行）、
+  clickzetta-ingestion-python（BulkLoad 批量上传，单线程与分布式模式）、
+  clickzetta-ingestion-python-v2（IGS 实时写入，秒级可查，支持主键表 CDC）、
+  SQLAlchemy dialect 集成，以及连接参数说明。
+  当用户说"Python SDK"、"clickzetta-connector-python"、"clickzetta-ingestion-python"、
+  "Python 查询 Lakehouse"、"Python 写入 Lakehouse"、"Python 批量上传"、
+  "BulkLoad Python"、"SQLAlchemy Lakehouse"、"Python 连接 Lakehouse"、
+  "executemany"、"execute_async"、"参数绑定 Python"、
+  "IGS 实时写入"、"实时写入 Python"、"ingestion-python-v2"、
+  "主键表写入 Python"、"CDC 写入"、"UPSERT Python"时触发。
+  Keywords: Python SDK, clickzetta-connector-python, clickzetta-ingestion-python, bulk insert, async query, SQLAlchemy, IGS
+---
+
+# ClickZetta Lakehouse — Python SDK
+
+官方提供三个 Python 包：
+- **`clickzetta-connector-python`** — SQL 查询接口（PEP-249 规范），支持参数绑定、批量插入、异步执行、SQLAlchemy dialect
+- **`clickzetta-ingestion-python`** — 高吞吐批量上传（BulkLoad），数据直传对象存储，不消耗计算资源
+- **`clickzetta-ingestion-python-v2`** — IGS 实时写入，秒级可查，支持主键表 CDC（UPSERT/DELETE）
+
+阅读 [references/connector.md](references/connector.md) 了解 SQL 查询接口，[references/bulkload.md](references/bulkload.md) 了解批量上传，[references/realtime.md](references/realtime.md) 了解 IGS 实时写入。
+
+---
+
+## 安装
+
+```bash
+# SQL 查询接口
+pip install clickzetta-connector-python -U
+
+# 批量上传（按云环境选择）
+pip install "clickzetta-ingestion-python[oss]" -U   # 阿里云
+pip install "clickzetta-ingestion-python[s3]" -U    # AWS
+pip install "clickzetta-ingestion-python[all]" -U   # 全部（安装较慢）
+
+# IGS 实时写入
+pip install clickzetta-ingestion-python-v2
+```
+
+> 注意：旧版 `clickzetta-connector` 已停止维护，请迁移到 `clickzetta-connector-python`。
+
+---
+
+## 连接参数
+
+```python
+from clickzetta import connect
+
+conn = connect(
+    username='your_username',
+    password='your_password',
+    service='api.clickzetta.com',      # region.api.clickzetta.com
+    instance='your_instance',
+    workspace='your_workspace',
+    schema='public',
+    vcluster='default'
+)
+```
+
+| 参数 | 必填 | 说明 |
+|---|---|---|
+| `username` | ✅ | 用户名 |
+| `password` | ✅ | 密码 |
+| `service` | ✅ | 连接地址，格式 `region.api.clickzetta.com` |
+| `instance` | ✅ | 实例名，在 Studio 工作空间 JDBC 连接串中查看 |
+| `workspace` | ✅ | 工作空间名 |
+| `vcluster` | ✅ | 虚拟集群名 |
+| `schema` | ✅ | 默认 schema |
+
+---
+
+## 快速示例
+
+```python
+# 查询
+cursor = conn.cursor()
+cursor.execute('SELECT * FROM orders LIMIT 10')
+results = cursor.fetchall()
+cursor.close()
+conn.close()
+
+# 参数绑定（防 SQL 注入）
+cursor.execute('INSERT INTO test (id, name) VALUES (?, ?)', binding_params=[1, 'test'])
+
+# 批量插入
+data = [(1, 'a'), (2, 'b'), (3, 'c')]
+cursor.executemany('INSERT INTO test (id, name) VALUES (?, ?)', data)
+```
+
+## IGS 实时写入快速示例（ingestion-python-v2）
+
+普通表（APPEND_ONLY）：
+
+```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(**CONN_ARGS) as conn:
+    stream = conn.get_realtime_stream(
+        schema='your_schema',
+        table='your_table',
+        operate=RealtimeOperation.APPEND_ONLY,
+        options=RealtimeOptionsBuilder().with_flush_mode(FlushMode.AUTO_FLUSH_BACKGROUND).build()
+    )
+    row = stream.create_row(RowOperator.INSERT)
+    row.set_value('id', 1)
+    row.set_value('name', 'alice')
+    stream.apply(row)
+    stream.close()
+```
+
+主键表 CDC（UPSERT / DELETE）：
+
+```python
+# 建表：CREATE TABLE users (id STRING NOT NULL PRIMARY KEY, name STRING, age INT);
+
+with connect(**CONN_ARGS) as conn:
+    stream = conn.get_realtime_stream(
+        schema='your_schema',
+        table='users',
+        operate=RealtimeOperation.CDC,           # 主键表必须用 CDC
+        options=RealtimeOptionsBuilder().with_flush_mode(FlushMode.AUTO_FLUSH_SYNC).build()
+    )
+    # UPSERT
+    row = stream.create_row(RowOperator.UPSERT)
+    row.set_value('id', 'u1')
+    row.set_value('name', 'bob')
+    row.set_value('age', 25)
+    stream.apply(row)
+    # DELETE_IGNORE
+    row = stream.create_row(RowOperator.DELETE_IGNORE)
+    row.set_value('id', 'u1')
+    stream.apply(row)
+    stream.close()
+```
+
+---
+
+## 选择指南
+
+| 场景 | 推荐方案 |
+|---|---|
+| 查询 / 小批量写入 | `clickzetta-connector-python` |
+| 大批量数据导入（GB 级，间隔 ≥ 5 分钟） | `clickzetta-ingestion-python` BulkLoad |
+| 高频小批写入（间隔 < 5 分钟，秒级可查） | `clickzetta-ingestion-python-v2` 实时写入 |
+| 主键表写入（UPSERT / DELETE） | `clickzetta-ingestion-python-v2` CDC 模式 |
+| SQLAlchemy / ORM 集成 | `clickzetta-connector-python`（内置 dialect） |

package/bin/skills/clickzetta-app-python-sdk/references/bulkload.md

@@ -0,0 +1,196 @@
+# clickzetta-ingestion-python BulkLoad 详细参考
+
+## 安装
+
+```bash
+# 按云环境选择（推荐按需安装，all 安装较慢且可能冲突）
+pip install "clickzetta-ingestion-python[oss]" -U    # 阿里云
+pip install "clickzetta-ingestion-python[s3]" -U     # AWS
+pip install "clickzetta-ingestion-python[cos]" -U    # 腾讯云
+pip install "clickzetta-ingestion-python[gcp]" -U    # Google Cloud
+pip install "clickzetta-ingestion-python[all]" -U    # 全部
+```
+
+## 工作原理
+
+```
+[SDK 写入数据] → [对象存储] → [调用 commit()] → [触发 SQL 导入] → [Lakehouse 表]
+```
+
+- 数据上传阶段不消耗计算资源
+- `commit()` 触发从对象存储到 Lakehouse 表的导入，消耗少量计算资源
+- `commit()` 只能调用一次，commit 后数据可见
+
+## 使用限制
+
+- **不支持主键（pk）表写入**
+- **不适合时间间隔小于 5 分钟的高频写入**
+
+## 单线程写入
+
+### 建表
+
+```sql
+CREATE TABLE public.bulkload_test (
+    i BIGINT,
+    s STRING,
+    d DOUBLE
+);
+```
+
+### 完整示例
+
+```python
+from clickzetta import connect
+
+conn = connect(
+    username='your_username',
+    password='your_password',
+    service='api.clickzetta.com',
+    instance='your_instance',
+    workspace='your_workspace',
+    schema='public',
+    vcluster='default'
+)
+
+bulkload_stream = conn.create_bulkload_stream(schema='public', table='bulkload_test')
+
+writer = bulkload_stream.open_writer(0)  # 单线程传 0
+for index in range(1000000):
+    row = writer.create_row()
+    row.set_value('i', index)      # 按列名设值
+    row.set_value('s', 'Hello')
+    row.set_value('d', 123.456)
+    writer.write(row)
+writer.close()
+
+bulkload_stream.commit()           # 提交，数据可见
+```
+
+## 读取 CSV 写入示例
+
+```python
+from clickzetta import connect
+import csv
+
+conn = connect(
+    username='',
+    password='',
+    service='api.clickzetta.com',
+    instance='',
+    workspace='',
+    schema='public',
+    vcluster='default_ap'
+)
+
+bulkload_stream = conn.create_bulkload_stream(schema='public', table='bulk_order_payments')
+writer = bulkload_stream.open_writer(0)
+
+with open('olist_order_payments_dataset.csv', 'r') as csvfile:
+    reader = csv.reader(csvfile)
+    next(reader)  # 跳过 header
+    for record in reader:
+        row = writer.create_row()
+        row.set_value('order_id', record[0])
+        row.set_value('payment_sequence', int(record[1]))
+        row.set_value('payment_type', record[2])
+        row.set_value('payment_installments', int(record[3]))
+        row.set_value('payment_value', float(record[4]))
+        writer.write(row)  # ⚠️ 必须调用，否则数据不发送到服务端
+
+writer.close()
+bulkload_stream.commit()
+```
+
+## 写入模式
+
+```python
+from clickzetta.bulkload.bulkload_enums import BulkLoadOperation
+
+# APPEND 模式（默认）：新数据追加，不影响旧数据
+bulkload_stream = conn.create_bulkload_stream(schema='public', table='my_table')
+
+# OVERWRITE 模式：清空旧数据，写入新数据
+bulkload_stream = conn.create_bulkload_stream(
+    schema='public',
+    table='my_table',
+    operation=BulkLoadOperation.OVERWRITE
+)
+
+# 分区表 OVERWRITE（只覆盖指定分区）
+bulkload_stream = conn.create_bulkload_stream(
+    schema='public',
+    table='my_partitioned_table',
+    partition_spec='pt=2024-01-01',
+    operation=BulkLoadOperation.OVERWRITE
+)
+```
+
+## 分布式并发写入
+
+适合 GB 级以上数据，多进程并发写入同一 stream，最后统一 commit。
+
+### 控制进程
+
+```python
+import subprocess
+from clickzetta import connect
+
+conn = connect(username='username', password='password',
+               service='api.clickzetta.com', instance='instance',
+               workspace='quickstart_ws', schema='public', vcluster='default')
+
+bulkload_stream = conn.create_bulkload_stream(schema='public', table='bulkload_test')
+stream_id = bulkload_stream.get_stream_id()
+
+# 启动多个写入进程，每个进程用不同的 writer_id
+p1 = subprocess.Popen(['python', 'writer.py', stream_id, '1'])
+p2 = subprocess.Popen(['python', 'writer.py', stream_id, '2'])
+p1.wait()
+p2.wait()
+
+bulkload_stream.commit()  # 所有 writer 完成后统一 commit
+```
+
+### 写入进程
+
+```python
+import sys
+from clickzetta import connect
+
+conn = connect(username='username', password='password',
+               service='api.clickzetta.com', instance='instance',
+               workspace='quickstart_ws', schema='public', vcluster='default')
+
+stream_id = sys.argv[1]
+writer_id = int(sys.argv[2])
+
+# 通过 stream_id 获取已有 stream（不创建新的）
+bulkload_stream = conn.get_bulkload_stream(
+    schema='public', table='bulkload_test', stream_id=stream_id
+)
+
+writer = bulkload_stream.open_writer(writer_id)  # writer_id 必须唯一
+for index in range(1, 1000000):
+    row = writer.create_row()
+    row.set_value('i', index)
+    row.set_value('s', 'Hello')
+    row.set_value('d', 123.456)
+    writer.write(row)
+writer.close()
+# 写入进程不调用 commit，只有控制进程调用
+```
+
+## 关键 API
+
+| API | 说明 |
+|---|---|
+| `conn.create_bulkload_stream(schema, table)` | 创建新的 bulkload stream |
+| `conn.get_bulkload_stream(schema, table, stream_id)` | 获取已有 stream（分布式写入用） |
+| `bulkload_stream.get_stream_id()` | 获取 stream id（传给写入进程） |
+| `bulkload_stream.open_writer(writer_id)` | 创建 writer，id 必须唯一 |
+| `writer.create_row()` | 创建行对象 |
+| `row.set_value(column_name, value)` | 按列名设值 |
+| `writer.write(row)` | 写入行（必须调用） |
+| `writer.close()` | 关闭 writer（写完必须调用） |
+| `bulkload_stream.commit()` | 提交，数据可见（只能调用一次） |