@clickzetta/cz-cli-linux-x64 0.3.2 → 0.3.5

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

@@ -1,160 +0,0 @@
----
-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

@@ -1,155 +0,0 @@
-# 向量检索参考
-
-> 来源：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

@@ -1,153 +0,0 @@
----
-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

@@ -1,196 +0,0 @@
-# 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()` | 提交，数据可见（只能调用一次） |