@clickzetta/cz-cli-darwin-x64 0.3.91 → 0.3.93

package/bin/skills/clickzetta-external-function/references/external-function-ddl.md

@@ -1,18 +1,20 @@
-# External Function DDL 参考
+# External Function DDL Reference
 
-> 来源：https://www.yunqi.tech/documents/CREATE_EXTERNATL_FUNCTION 等
+> Source: https://www.yunqi.tech/documents/CREATE_EXTERNATL_FUNCTION
 
-## 概念
+## Concepts
 
-External Function（外部函数）是通过 Python/Java 编写、在云函数服务（阿里云 FC / 腾讯云 SCF / AWS Lambda）上执行的自定义 UDF。可调用：
-- **在线服务**：LLM API、图像识别 API 等
-- **离线模型**：打包上传的 Hugging Face 模型等
+An External Function is a custom UDF written in Python or Java and executed on a cloud function service (Alibaba Cloud FC / Tencent Cloud SCF / AWS Lambda). It can call:
+- **Online services**: image recognition APIs, custom REST services, etc.
+- **Offline models**: Hugging Face models packaged and uploaded
 
-支持函数类型：UDF（标量）、UDAF（聚合，仅 Java）、UDTF（表函数，仅 Java）
+Supported function types: UDF (scalar), UDAF (aggregate, Java only), UDTF (table function, Java only)
+
+> For built-in LLM functions (AI_COMPLETE, AI_EMBEDDING), see the `clickzetta-ai-function` skill.
 
 ---
 
-## CREATE API CONNECTION（云函数连接）
+## CREATE API CONNECTION (Cloud Function)
 
 ```sql
 CREATE API CONNECTION IF NOT EXISTS my_fc_conn
@@ -20,17 +22,17 @@ CREATE API CONNECTION IF NOT EXISTS my_fc_conn
   PROVIDER = 'aliyun'           -- 'aliyun' | 'tencent' | 'aws'
   REGION = 'cn-shanghai'
   ROLE_ARN = 'acs:ram::1234567890:role/CzUDFRole'
-  NAMESPACE = 'default'         -- 腾讯云必填，其他填 'default'
+  NAMESPACE = 'default'         -- Required for Tencent Cloud; use 'default' for others
   CODE_BUCKET = 'my-oss-bucket';
 ```
 
-| 参数 | 说明 |
+| Parameter | Description |
 |---|---|
 | PROVIDER | `'aliyun'` / `'tencent'` / `'aws'` |
-| REGION | 阿里云：`cn-shanghai`；腾讯云：`ap-beijing`；AWS：`cn-northwest-1` |
-| ROLE_ARN | 授权给 Lakehouse 的 RAM 角色 ARN |
-| NAMESPACE | 腾讯云命名空间（必填）；其他填 `'default'` |
-| CODE_BUCKET | 存放函数代码包的 OSS/COS/S3 bucket 名称 |
+| REGION | Alibaba Cloud: `cn-shanghai`; Tencent Cloud: `ap-beijing`; AWS: `cn-northwest-1` |
+| ROLE_ARN | RAM role ARN granted to Lakehouse |
+| NAMESPACE | Tencent Cloud namespace (required); use `'default'` for others |
+| CODE_BUCKET | OSS/COS/S3 bucket name where the function code package is stored |
 
 ---
 
@@ -44,10 +46,10 @@ CREATE EXTERNAL FUNCTION IF NOT EXISTS my_schema.my_udf
   WITH PROPERTIES (
       'remote.udf.api' = 'python3.mc.v0'   -- Python: python3.mc.v0 | Java: java8.hive2.v0
   )
-  COMMENT '自定义函数说明';
+  COMMENT 'Custom function description';
 ```
 
-### 资源文件地址格式
+### Resource File Path Formats
 
 ```
 -- OSS/COS/S3
@@ -55,24 +57,24 @@ oss://bucket-name/path/to/code.zip
 cos://bucket-name/path/to/code.zip
 s3://bucket-name/path/to/code.zip
 
--- User Volume（无需开通对象存储）
+-- User Volume (no object storage required)
 volume:user://~/code.zip
 
 -- External Volume
 volume://workspace.schema.volume_name/code.zip
 ```
 
-### WITH PROPERTIES 参数
+### WITH PROPERTIES Parameters
 
-| 参数 | 值 | 说明 |
+| Parameter | Value | Description |
 |---|---|---|
-| `remote.udf.api` | `python3.mc.v0` | Python 3.10 运行时 |
-| `remote.udf.api` | `java8.hive2.v0` | Java 8 Hive 风格 UDF |
-| `remote.udf.protocol` | `http.arrow.v0` | 默认，访问云函数的协议 |
+| `remote.udf.api` | `python3.mc.v0` | Python 3.10 runtime |
+| `remote.udf.api` | `java8.hive2.v0` | Java 8 Hive-style UDF |
+| `remote.udf.protocol` | `http.arrow.v0` | Default protocol for accessing the cloud function |
 
 ---
 
-## Python UDF 代码结构
+## Python UDF Code Structure
 
 ```python
 #!/usr/bin/env python
@@ -81,7 +83,7 @@ try:
 except ImportError:
     annotate = lambda _: lambda _: _
 
-@annotate("string->string")   # 函数签名：输入类型->返回类型
+@annotate("string->string")   # Function signature: input_type->return_type
 class Upper(object):
     def evaluate(self, arg):
         if arg is None:
@@ -89,83 +91,43 @@ class Upper(object):
         return arg.upper()
 ```
 
-### 函数签名格式
+### Function Signature Format
 
 ```
 "input_type1,input_type2->return_type"
 
-# 示例
-"string->string"           # 字符串转字符串
-"string,int->double"       # 两个输入，返回 double
-"string->array<string>"    # 返回数组
+# Examples
+"string->string"           # String in, string out
+"string,int->double"       # Two inputs, returns double
+"string->array<string>"    # Returns an array
 ```
 
-支持类型：`string`、`int`、`bigint`、`double`、`float`、`boolean`、`array<T>`、`map<K,V>`
+Supported types: `string`, `int`, `bigint`, `double`, `float`, `boolean`, `array<T>`, `map<K,V>`
 
-### 打包上传
+### Packaging and Upload
 
 ```bash
-# 安装依赖到当前目录
+# Install dependencies into the current directory
 pip3 install httpx pydantic -t .
 
-# 打包（< 500MB）
+# Package (must be < 500 MB)
 zip -rq code.zip ./*
 ```
 
 ```sql
--- 上传到 User Volume（在 ClickZetta Studio 或 CLI 中执行，source_path 使用绝对路径）
+-- Upload to User Volume (run in ClickZetta Studio or CLI; source_path must be an absolute path)
 PUT '/path/to/code.zip' TO USER VOLUME;
 ```
 
 ---
 
-## 管理操作
+## Management
 
 ```sql
--- 查看外部函数列表
+-- List external functions
 SHOW EXTERNAL FUNCTIONS;
 SHOW EXTERNAL FUNCTIONS LIKE 'my_%';
 
--- 删除外部函数
+-- Drop an external function
 DROP FUNCTION IF EXISTS my_schema.my_udf;
 ```
-
----
-
-## 内置 AI 函数（无需部署云函数）
-
-### AI_COMPLETE（调用 LLM）
-
-```sql
--- 通过 API Connection 调用（需先创建连接）
-CREATE API CONNECTION conn_bailian
-    TYPE ai_function
-    PROVIDER = 'bailian'
-    BASE_URL = 'https://dashscope.aliyuncs.com/api/v1'
-    API_KEY = '<key>';
-
--- 调用 LLM 生成文本
-SELECT AI_COMPLETE('connection:conn_bailian', '请用一句话总结：' || content) AS summary
-FROM articles
-LIMIT 10;
-
--- 通过平台 Endpoint 调用（管理员预配置）
-SELECT AI_COMPLETE('endpoint:my_llm_endpoint', prompt_col) AS result
-FROM my_table;
-```
-
-### AI_EMBEDDING（文本向量化）
-
-```sql
--- 将文本转为向量（用于语义搜索）
-SELECT id, content,
-       AI_EMBEDDING('connection:conn_bailian', content) AS embedding
-FROM documents;
-
--- 结合向量索引做语义搜索
-SELECT id, content,
-       cosine_distance(embedding, AI_EMBEDDING('connection:conn_bailian', '查询文本')) AS dist
-FROM doc_embeddings
-ORDER BY dist
-LIMIT 10;
-```

package/bin/skills/clickzetta-java-sdk/SKILL.md

@@ -1,30 +1,31 @@
 ---
 name: clickzetta-java-sdk
 description: |
-  使用 ClickZetta Java SDK 将数据批量或实时写入 Lakehouse 表。
-  覆盖 BulkloadStream（本地文件/数据库批量上传）和 RealtimeStream（Kafka 实时消费写入）
-  两种接口的完整使用模式，包括 Maven 依赖、连接 URL 格式、行写入 API、
-  状态监控、Options 调优和常见错误处理。
-  当用户说"Java SDK"、"BulkloadStream"、"RealtimeStream"、
-  "Java 写入 Lakehouse"、"Java 批量上传"、"Kafka Java 写入"、
-  "clickzetta-java"、"Maven 依赖"、"Java 数据导入"时触发。
+  Use the ClickZetta Java SDK to write data to Lakehouse tables in batch or in real time.
+  Covers complete usage patterns for BulkloadStream (local file/database batch uploads)
+  and RealtimeStream (Kafka real-time consumption and writes), including Maven dependencies,
+  connection URL formats, row write APIs, status monitoring, Options tuning, and common error handling.
+  Trigger when users say "Java SDK", "BulkloadStream", "RealtimeStream",
+  "write to Lakehouse with Java", "Java batch upload", "Kafka Java write",
+  "clickzetta-java", "Maven dependency", "Java data import",
+  "Java 写入 Lakehouse", "Java 批量上传", or "Kafka Java 写入".
   Keywords: Java SDK, BulkloadStream, RealtimeStream, Kafka consumer, batch write, real-time write
 ---
 
 # ClickZetta Java SDK
 
-Java SDK 提供两种写入接口：
-- **BulkloadStream** — 批量写入，适合定时 ETL、本地文件导入（不支持主键表，不适合 5 分钟以内的高频写入）
-- **RealtimeStream** — 实时写入，适合 Kafka 消费、流式数据接入（秒级可查）
+The Java SDK provides two write interfaces:
+- **BulkloadStream** - batch writes for scheduled ETL and local file imports. It does not support primary-key tables and is not recommended for high-frequency writes under 5 minutes.
+- **RealtimeStream** - real-time writes for Kafka consumption and streaming ingestion. Data can be queried within seconds.
 
-阅读 [references/bulkload.md](references/bulkload.md) 了解批量写入，[references/realtime.md](references/realtime.md) 了解实时写入。
+Read [references/bulkload.md](references/bulkload.md) for batch writes and [references/realtime.md](references/realtime.md) for real-time writes.
 
 ---
 
-## Maven 依赖
+## Maven Dependency
 
 ```xml
-<!-- clickzetta-java 最新版本见 https://central.sonatype.com/artifact/com.clickzetta/clickzetta-java -->
+<!-- See https://central.sonatype.com/artifact/com.clickzetta/clickzetta-java for the latest clickzetta-java version. -->
 <dependency>
     <groupId>com.clickzetta</groupId>
     <artifactId>clickzetta-java</artifactId>
@@ -32,7 +33,7 @@ Java SDK 提供两种写入接口：
 </dependency>
 ```
 
-RealtimeStream + Kafka 还需要：
+RealtimeStream with Kafka also requires:
 
 ```xml
 <dependency>
@@ -44,10 +45,10 @@ RealtimeStream + Kafka 还需要：
 
 ---
 
-## 连接 URL 格式
+## Connection URL Format
 
 ```java
-// 推荐：显式参数方式（2.0.0+ 支持，不依赖 URL 解析）
+// Recommended: explicit parameters. Supported in 2.0.0+ and does not depend on URL parsing.
 ClickZettaClient client = ClickZettaClient.newBuilder()
     .service("cn-shanghai-alicloud.api.clickzetta.com")
     .instance("your_instance")
@@ -58,7 +59,7 @@ ClickZettaClient client = ClickZettaClient.newBuilder()
     .vcluster("default")
     .build();
 
-// 兼容：URL 方式（BulkloadStream 用 virtualcluster=，RealtimeStream 用 vcluster=）
+// Compatible URL-based mode. BulkloadStream uses virtualcluster=, while RealtimeStream uses vcluster=.
 String bulkUrl = MessageFormat.format(
     "jdbc:clickzetta://{0}.{1}/{2}?schema={3}&username={4}&password={5}&virtualcluster={6}",
     instance, region_endpoint, workspace, schema, username, password, vcluster
@@ -70,35 +71,35 @@ String rtUrl = MessageFormat.format(
 ClickZettaClient client = ClickZettaClient.newBuilder().url(url).build();
 ```
 
-JDBC 连接（DDL / 查询）：
+JDBC connection for DDL and queries:
 
 ```java
-// 2.0.0+ 驱动类：com.clickzetta.client.jdbc.ClickZettaDriver
-// 1.x 驱动类：com.clickzetta.jdbc.ClickZettaDriver
+// Driver class for 2.0.0+: com.clickzetta.client.jdbc.ClickZettaDriver
+// Driver class for 1.x: com.clickzetta.jdbc.ClickZettaDriver
 Class.forName("com.clickzetta.client.jdbc.ClickZettaDriver");
 Connection conn = DriverManager.getConnection(jdbcUrl);
 ```
 
 ---
 
-## BulkloadStream 快速示例
+## BulkloadStream Quick Example
 
 ```java
-// 创建 BulkloadStream
+// Create a BulkloadStream.
 BulkloadStream stream = client.newBulkloadStreamBuilder()
     .schema("public")
     .table("orders")
     .operate(RowStream.BulkLoadOperate.APPEND)
     .build();
 
-// 写入数据（列索引从 0 开始，顺序与建表 DDL 一致）
+// Write data. Column indexes start at 0 and must match the table DDL order.
 Row row = stream.createRow();
 row.setValue(0, "order-001");   // STRING
 row.setValue(1, 1);             // INT
 row.setValue(2, 299.99);        // DOUBLE
-stream.apply(row);              // ⚠️ 必须调用，否则数据不发送到服务端
+stream.apply(row);              // Required. Otherwise the row is not sent to the server.
 
-// 关闭并等待完成
+// Close and wait for completion.
 stream.close();
 while (stream.getState() == StreamState.RUNNING) {
     Thread.sleep(1000);
@@ -111,15 +112,15 @@ client.close();
 
 ---
 
-## RealtimeStream 快速示例
+## RealtimeStream Quick Example
 
 ```java
-// Options 调优
+// Options tuning.
 Options options = Options.builder()
-    .withMutationBufferLinesNum(10)  // 缓冲行数
+    .withMutationBufferLinesNum(10)  // Number of buffered rows.
     .build();
 
-// 创建 RealtimeStream（普通表，APPEND_ONLY）
+// Create a RealtimeStream for a regular table in APPEND_ONLY mode.
 RealtimeStream stream = client.newRealtimeStreamBuilder()
     .operate(RowStream.RealTimeOperate.APPEND_ONLY)
     .options(options)
@@ -127,7 +128,7 @@ RealtimeStream stream = client.newRealtimeStreamBuilder()
     .table("events")
     .build();
 
-// 写入数据（用列名，不用索引）
+// Write data by column name, not by index.
 Row row = stream.createRow(Stream.Operator.INSERT);
 row.setValue("id", 1);
 row.setValue("event", "{\"type\":\"click\"}");
@@ -135,26 +136,26 @@ stream.apply(row);
 stream.close();
 ```
 
-## RealtimeStream CDC 示例（主键表 UPSERT / DELETE）
+## RealtimeStream CDC Example for Primary-Key Tables
 
 ```java
-// 建表：CREATE TABLE orders (txid STRING NOT NULL PRIMARY KEY, amount DOUBLE, status STRING);
+// Table DDL: CREATE TABLE orders (txid STRING NOT NULL PRIMARY KEY, amount DOUBLE, status STRING);
 
 RealtimeStream stream = client.newRealtimeStreamBuilder()
-    .operate(RowStream.RealTimeOperate.CDC)   // 主键表必须用 CDC
+    .operate(RowStream.RealTimeOperate.CDC)   // Primary-key tables must use CDC.
     .options(options)
     .schema("public")
     .table("orders")
     .build();
 
-// UPSERT：存在则更新，不存在则插入
+// UPSERT: update an existing row or insert a new row.
 Row row = stream.createRow(Stream.Operator.UPSERT);
 row.setValue("txid", "order-001");
 row.setValue("amount", 299.99);
 row.setValue("status", "paid");
 stream.apply(row);
 
-// DELETE_IGNORE：删除，目标行不存在时自动忽略
+// DELETE_IGNORE: delete the row and ignore the operation if the target row does not exist.
 Row del = stream.createRow(Stream.Operator.DELETE_IGNORE);
 del.setValue("txid", "order-001");
 stream.apply(del);
@@ -164,23 +165,23 @@ stream.close();
 
 ---
 
-## 选择指南
+## Selection Guide
 
-| 场景 | 推荐接口 |
+| Scenario | Recommended interface |
 |---|---|
-| 定时批量 ETL（每小时/每天） | BulkloadStream |
-| Kafka 实时消费 | RealtimeStream |
-| 5 分钟以内高频写入 | RealtimeStream |
-| 主键表写入（UPSERT / DELETE） | RealtimeStream CDC 模式 |
+| Scheduled batch ETL, hourly or daily | BulkloadStream |
+| Kafka real-time consumption | RealtimeStream |
+| High-frequency writes under 5 minutes | RealtimeStream |
+| Primary-key table writes with UPSERT or DELETE | RealtimeStream CDC mode |
 
 ---
 
-## 使用限制
+## Usage Limits
 
-| 限制 | BulkloadStream | RealtimeStream |
+| Limit | BulkloadStream | RealtimeStream |
 |---|---|---|
-| 主键表 | ❌ 不支持 | ✅ CDC 模式支持 |
-| 高频写入（< 5 分钟） | ❌ 不适合 | ✅ 支持 |
-| 数据可见延迟 | 写完 close() 后可见 | ~1 分钟后可见 |
-| Table Stream/Dynamic Table 可见 | close() 后 | ~1 分钟后 |
-| 表结构变更 | 重建 Stream | 停止任务，变更后约 90 分钟重启 |
+| Primary-key tables | Not supported | Supported in CDC mode |
+| High-frequency writes under 5 minutes | Not recommended | Supported |
+| Data visibility latency | Visible after `close()` | Visible after about 1 minute |
+| Table Stream/Dynamic Table visibility | After `close()` | After about 1 minute |
+| Schema changes | Recreate the stream | Stop the task and restart about 90 minutes after the schema change |

package/bin/skills/clickzetta-java-sdk/eval_cases.jsonl

@@ -1,12 +1,12 @@
-{"case_id":"001","type":"should_call","user_input":"用 Java SDK BulkloadStream 批量写入数据到 Lakehouse","expected_skill":"clickzetta-java-sdk","expected_output_contains":["BulkloadStream"]}
-{"case_id":"002","type":"should_call","user_input":"Java 怎么消费 Kafka 实时写入 Lakehouse","expected_skill":"clickzetta-java-sdk","expected_output_contains":["RealtimeStream"]}
-{"case_id":"003","type":"should_call","user_input":"clickzetta-java 的 Maven 依赖怎么配","expected_skill":"clickzetta-java-sdk","expected_output_contains":["groupId","clickzetta-java"]}
-{"case_id":"004","type":"should_call","user_input":"BulkloadStream 和 RealtimeStream 有什么区别","expected_skill":"clickzetta-java-sdk","expected_output_contains":["BulkloadStream","RealtimeStream"]}
-{"case_id":"005","type":"should_call","user_input":"Java SDK 连接 URL 格式是什么","expected_skill":"clickzetta-java-sdk","expected_output_contains":["URL"]}
-{"case_id":"006","type":"should_call","user_input":"Java 批量上传本地文件到 Lakehouse","expected_skill":"clickzetta-java-sdk","expected_output_contains":["BulkloadStream"]}
-{"case_id":"007","type":"should_call","user_input":"RealtimeStream 的 setValue 怎么用","expected_skill":"clickzetta-java-sdk","expected_output_contains":["setValue"]}
-{"case_id":"008","type":"should_not_call","user_input":"Python SDK 怎么连接 Lakehouse","forbidden_skill":"clickzetta-java-sdk"}
-{"case_id":"009","type":"should_not_call","user_input":"帮我写一个 Spring Boot 应用","forbidden_skill":"clickzetta-java-sdk"}
-{"case_id":"010","type":"should_not_call","user_input":"Flink 怎么写入 Lakehouse","forbidden_skill":"clickzetta-java-sdk"}
-{"case_id":"011","type":"should_not_call","user_input":"怎么创建 VCluster","forbidden_skill":"clickzetta-java-sdk"}
-{"case_id":"012","type":"should_not_call","user_input":"MySQL JDBC 连接怎么配置","forbidden_skill":"clickzetta-java-sdk"}
+{"case_id":"001","type":"should_call","user_input":"Use Java SDK BulkloadStream to batch write data to Lakehouse","expected_skill":"clickzetta-java-sdk","expected_output_contains":["BulkloadStream"]}
+{"case_id":"002","type":"should_call","user_input":"How can Java consume Kafka and write to Lakehouse in real time","expected_skill":"clickzetta-java-sdk","expected_output_contains":["RealtimeStream"]}
+{"case_id":"003","type":"should_call","user_input":"How do I configure the Maven dependency for clickzetta-java","expected_skill":"clickzetta-java-sdk","expected_output_contains":["groupId","clickzetta-java"]}
+{"case_id":"004","type":"should_call","user_input":"What is the difference between BulkloadStream and RealtimeStream","expected_skill":"clickzetta-java-sdk","expected_output_contains":["BulkloadStream","RealtimeStream"]}
+{"case_id":"005","type":"should_call","user_input":"What is the Java SDK connection URL format","expected_skill":"clickzetta-java-sdk","expected_output_contains":["URL"]}
+{"case_id":"006","type":"should_call","user_input":"Batch upload a local file to Lakehouse with Java","expected_skill":"clickzetta-java-sdk","expected_output_contains":["BulkloadStream"]}
+{"case_id":"007","type":"should_call","user_input":"How do I use setValue with RealtimeStream","expected_skill":"clickzetta-java-sdk","expected_output_contains":["setValue"]}
+{"case_id":"008","type":"should_not_call","user_input":"How do I connect to Lakehouse with the Python SDK","forbidden_skill":"clickzetta-java-sdk"}
+{"case_id":"009","type":"should_not_call","user_input":"Help me write a Spring Boot application","forbidden_skill":"clickzetta-java-sdk"}
+{"case_id":"010","type":"should_not_call","user_input":"How does Flink write to Lakehouse","forbidden_skill":"clickzetta-java-sdk"}
+{"case_id":"011","type":"should_not_call","user_input":"How do I create a VCluster","forbidden_skill":"clickzetta-java-sdk"}
+{"case_id":"012","type":"should_not_call","user_input":"How do I configure a MySQL JDBC connection","forbidden_skill":"clickzetta-java-sdk"}

package/bin/skills/clickzetta-java-sdk/references/bulkload.md

@@ -1,12 +1,12 @@
-# BulkloadStream 详细参考
+# BulkloadStream Detailed Reference
 
-> 适合：定时 ETL、本地文件导入、数据库迁移
-> 不适合：主键表、5 分钟以内高频写入
+> Best for: scheduled ETL, local file imports, and database migration.
+> Not for: primary-key tables or high-frequency writes under 5 minutes.
 
-## Maven 依赖
+## Maven Dependency
 
 ```xml
-<!-- 最新版本见 https://central.sonatype.com/artifact/com.clickzetta/clickzetta-java -->
+<!-- See https://central.sonatype.com/artifact/com.clickzetta/clickzetta-java for the latest version. -->
 <dependency>
     <groupId>com.clickzetta</groupId>
     <artifactId>clickzetta-java</artifactId>
@@ -14,17 +14,17 @@
 </dependency>
 ```
 
-最新版本见 [Maven Central](https://central.sonatype.com/artifact/com.clickzetta/clickzetta-java)
+See [Maven Central](https://central.sonatype.com/artifact/com.clickzetta/clickzetta-java) for the latest version.
 
-## 使用限制
+## Usage Limits
 
-- **不支持主键（pk）表写入**
-- **不适合时间间隔小于 5 分钟的高频写入**
-- 写入完成 `close()` 后数据才可见
+- **Primary-key table writes are not supported.**
+- **High-frequency writes at intervals shorter than 5 minutes are not recommended.**
+- Data becomes visible only after writing is complete and `close()` has been called.
 
-## 完整示例：读取本地 CSV 写入 Lakehouse
+## Complete Example: Read a Local CSV and Write to Lakehouse
 
-### 建表
+### Create the Table
 
 ```sql
 CREATE TABLE bulk_order_items (
@@ -38,7 +38,7 @@ CREATE TABLE bulk_order_items (
 );
 ```
 
-### Java 代码（BulkloadFile 类）
+### Java Code: BulkloadFile Class
 
 ```java
 import com.clickzetta.client.BulkloadStream;
@@ -66,12 +66,12 @@ public class BulkloadFile {
         initialize();
         File csvFile = new File("olist_order_items_dataset.csv");
         BufferedReader reader = new BufferedReader(new FileReader(csvFile));
-        reader.readLine(); // 跳过 header 行
+        reader.readLine(); // Skip the header row.
 
         String line;
         while ((line = reader.readLine()) != null) {
             String[] values = line.split(",");
-            // 类型转换必须与建表 DDL 一致
+            // Type conversion must match the table DDL.
             String orderId = values[0];
             int orderItemId = Integer.parseInt(values[1]);
             String productId = values[2];
@@ -81,7 +81,7 @@ public class BulkloadFile {
             double freightValue = Double.parseDouble(values[6]);
 
             Row row = bulkloadStream.createRow();
-            // ⚠️ BulkloadStream 用列索引（从 0 开始），顺序与建表 DDL 一致
+            // BulkloadStream uses column indexes starting at 0. The order must match the table DDL.
             row.setValue(0, orderId);
             row.setValue(1, orderItemId);
             row.setValue(2, productId);
@@ -89,7 +89,7 @@ public class BulkloadFile {
             row.setValue(4, shippingLimitDate);
             row.setValue(5, price);
             row.setValue(6, freightValue);
-            // ⚠️ 必须调用 apply()，否则数据不发送到服务端
+            // apply() is required. Otherwise the row is not sent to the server.
             bulkloadStream.apply(row);
         }
 
@@ -101,7 +101,7 @@ public class BulkloadFile {
     }
 
     private static void initialize() throws Exception {
-        // 推荐：显式参数方式（2.0.0+ 支持）
+        // Recommended: explicit parameters. Supported in 2.0.0+.
         client = ClickZettaClient.newBuilder()
             .service("cn-shanghai-alicloud.api.clickzetta.com")
             .instance("your_instance")
@@ -129,20 +129,20 @@ public class BulkloadFile {
 }
 ```
 
-## 关键 API
+## Key APIs
 
-| API | 说明 |
+| API | Description |
 |---|---|
-| `bulkloadStream.createRow()` | 创建行对象（无参数） |
-| `row.setValue(int index, Object value)` | 按列索引设值（从 0 开始） |
-| `bulkloadStream.apply(row)` | 发送行到服务端（必须调用） |
-| `bulkloadStream.close()` | 关闭并触发提交 |
-| `bulkloadStream.getState()` | 获取状态：RUNNING / SUCCEEDED / FAILED |
-| `bulkloadStream.getErrorMessage()` | 获取失败原因 |
+| `bulkloadStream.createRow()` | Create a row object without arguments. |
+| `row.setValue(int index, Object value)` | Set a value by column index, starting at 0. |
+| `bulkloadStream.apply(row)` | Send the row to the server. This call is required. |
+| `bulkloadStream.close()` | Close the stream and trigger the commit. |
+| `bulkloadStream.getState()` | Get the state: RUNNING, SUCCEEDED, or FAILED. |
+| `bulkloadStream.getErrorMessage()` | Get the failure reason. |
 
-## 类型映射
+## Type Mapping
 
-| Java 类型 | Lakehouse 类型 |
+| Java type | Lakehouse type |
 |---|---|
 | `Long` / `long` | BIGINT |
 | `Integer` / `int` | INT |
@@ -153,11 +153,11 @@ public class BulkloadFile {
 | `java.sql.Date` | DATE |
 | `BigDecimal` | DECIMAL |
 
-## 常见问题
+## FAQ
 
-| 问题 | 原因 | 解决方案 |
+| Issue | Cause | Solution |
 |---|---|---|
-| 数据写入后查不到 | 未调用 `apply()` 或未等待 RUNNING 结束 | 确认每行都调用 `apply()`，等待状态变为 SUCCEEDED |
-| 主键表写入报错 | BulkloadStream 不支持主键表 | 改用 JDBC + MERGE 或 Flink igs-dynamic-table |
-| 列值类型不匹配 | Java 类型与建表 DDL 不一致 | 写入前做类型转换（parseInt、parseDouble 等） |
-| 连接失败 | URL 参数名错误 | BulkloadStream 用 `virtualcluster=`，不是 `vcluster=` |
+| Data cannot be queried after writing | `apply()` was not called or the RUNNING state has not finished | Call `apply()` for every row and wait until the state becomes SUCCEEDED. |
+| Primary-key table write fails | BulkloadStream does not support primary-key tables | Use JDBC with MERGE or Flink `igs-dynamic-table` instead. |
+| Column value type mismatch | Java types do not match the table DDL | Convert values before writing, for example with `parseInt` or `parseDouble`. |
+| Connection fails | Wrong URL parameter name | BulkloadStream uses `virtualcluster=`, not `vcluster=`. |