@clickzetta/cz-cli-darwin-x64 0.5.16 → 0.5.18

package/bin/skills/lakehouse-doc-en/references/use-models.md

@@ -0,0 +1,128 @@
+# Use Models
+
+After selecting a model in the Model Marketplace, you can view the model's endpoint information and usage examples, and copy the code directly to start calling.
+
+## Finding Model Endpoints
+
+Go to the **Model Marketplace**, click on any model to enter its detail page, where you can see:
+
+- **Endpoint Management**: Lists the available endpoint names, service providers, status, and billing information for that model
+- **Model Usage Examples**: Provides curl and Python code examples that can be copied and used directly
+
+The endpoint name format is `{provider}@{model_name}@{interface_type}`, for example:
+
+- `aliyun_bailian_bj@qwen/qwen3.7-max@open_ai` — Alibaba Cloud Bailian-Beijing, OpenAI-compatible interface
+- `aws_bedrock_us_east_1@anthropic/claude-opus-4.6@anthropic` — AWS Bedrock US-East-1, Anthropic interface
+
+## Two Interface Formats
+
+AI Gateway supports two calling interfaces, depending on the protocol type of the model:
+
+| Interface Type | Path | Applicable Models |
+|----------|------|----------|
+| OpenAI-compatible | `/gateway/v1/chat/completions` | Qwen, DeepSeek, GLM, Kimi, Doubao, GPT, etc. |
+| Anthropic-compatible | `/gateway/v1/messages` | Claude series |
+
+## curl Calls
+
+### OpenAI-Compatible Interface (Qwen, etc.)
+
+```bash
+curl -X POST https://cn-shanghai-alicloud-aimesh.api.clickzetta.com/gateway/v1/chat/completions \
+  -H "Authorization: Bearer $API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "qwen/qwen3.7-max",
+    "messages": [{"role": "user", "content": "hello"}]
+  }'
+```
+
+### Anthropic-Compatible Interface (Claude)
+
+```bash
+curl -X POST https://cn-shanghai-alicloud-aimesh.api.clickzetta.com/gateway/v1/messages \
+  -H "x-api-key: $API_KEY" \
+  -H "anthropic-version: 2023-06-01" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "anthropic/claude-opus-4.6",
+    "messages": [{"role": "user", "content": "hello"}],
+    "max_tokens": 256
+  }'
+```
+
+## Python Calls
+
+### OpenAI-Compatible Interface (Recommended)
+
+Use the `openai` library, pointing `base_url` to the AI Gateway endpoint:
+
+```python
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="https://cn-shanghai-alicloud-aimesh.api.clickzetta.com/gateway/v1",
+    api_key="<your-api-key>",
+)
+
+response = client.chat.completions.create(
+    model="qwen/qwen3.7-max",
+    messages=[{"role": "user", "content": "hello"}],
+)
+print(response.choices[0].message.content)
+```
+
+### Anthropic-Compatible Interface (Claude)
+
+Use the `requests` library to call the Anthropic Messages interface directly:
+
+```python
+import requests
+
+url = "https://cn-shanghai-alicloud-aimesh.api.clickzetta.com/gateway/v1/messages"
+headers = {
+    "x-api-key": "${API_KEY}",
+    "anthropic-version": "2023-06-01",
+    "Content-Type": "application/json",
+}
+payload = {
+    "model": "anthropic/claude-opus-4.6",
+    "messages": [{"role": "user", "content": "hello"}],
+    "max_tokens": 256,
+}
+
+resp = requests.post(url, headers=headers, json=payload, timeout=60)
+print(resp.status_code)
+print(resp.text)
+```
+
+You can also use the official `anthropic` SDK, replacing `base_url` with the AI Gateway address:
+
+```python
+import anthropic
+
+client = anthropic.Anthropic(
+    base_url="https://cn-shanghai-alicloud-aimesh.api.clickzetta.com/gateway/v1",
+    api_key="<your-api-key>",
+)
+
+message = client.messages.create(
+    model="anthropic/claude-opus-4.6",
+    max_tokens=256,
+    messages=[{"role": "user", "content": "hello"}],
+)
+print(message.content)
+```
+
+## Notes
+
+- Endpoint addresses differ by deployment region; use the actual example code in the Model Marketplace as the reference
+- OpenAI-compatible interface uses `Authorization: Bearer <key>`; Anthropic interface uses `x-api-key: <key>`
+- Model names must exactly match the model identifier in the endpoint; copy from the Model Marketplace detail page
+- API Keys must be created in advance in **API KEY Management** with calling permissions enabled for the corresponding model
+
+## Related Documents
+
+- [Quick Start](quickstart.md) — Create API Key and configure routing
+- [Model Pricing](pricing-ai-gateway.md) — Billing standards for each model
+- [Call LLMs in SQL](lakehouse-ai-sql-analysis.md) — Calling via AI_COMPLETE in Lakehouse SQL

package/bin/skills/lakehouse-doc-en/references/use-mysql-client.md

@@ -1,6 +1,5 @@
-# Introduction
+# Connect Using MySQL Protocol
 
-\[**Preview Release] This feature is currently in public preview**.
 
 | Cloud Provider | Region    | Compatible MySQL Protocol Version |
 | -------------- | --------- | --------------------------------- |
@@ -12,75 +11,75 @@
 | Amazon         | Beijing   | MySQL8.x                          |
 |                | Singapore | MySQL8.x                          |
 
-Lakehouse supports the MySQL client-server communication protocol, so you can use MySQL drivers to connect to Lakehouse. However, Lakehouse does not implement MySQL syntax and data types. When connecting to Lakehouse via a MySQL client, the SQL statements executed should use Lakehouse syntax, not MySQL syntax. For example, the `mysqldump` command is not available in Lakehouse.
+Lakehouse supports the MySQL client-server communication protocol, so you can use MySQL drivers to connect to Lakehouse. However, Lakehouse does not implement MySQL syntax and data types. When connecting to Lakehouse via a MySQL client, SQL statements should use Lakehouse syntax, not MySQL syntax. For example, the `mysqldump` command is not available in Lakehouse.
 
-To accommodate some BI reports, Lakehouse has implemented some commonly used MySQL functions, such as `str_to_date` and `date_format`. Currently, Lakehouse supports the following protocols:
-The default authentication method used when a MySQL8.x client connects to the server is caching\_sha2\_password. For more information on MySQL authentication methods, please refer to the [official documentation](https://dev.mysql.com/doc/refman/8.0/en/authentication-plugins.html). SSL must be enabled to connect to Lakehouse. The connection method is as follows, for example, connecting to Alibaba Cloud in Shanghai.
+To accommodate some BI reports, Lakehouse has implemented some commonly used MySQL functions, such as `str_to_date` and `date_format`.
+
+When a MySQL 8.x client connects to the server, the default authentication method is `caching_sha2_password`. For more information on MySQL authentication methods, refer to the [official documentation](https://dev.mysql.com/doc/refman/8.0/en/authentication-plugins.html). Connection example for Alibaba Cloud Shanghai:
 
 ```
-jdbc:mysql://ap-southeast-1-aws-mysql.api.singdata.com/public?useSSL=true
---Add port, optional
-jdbc:mysql://ap-southeast-1-aws-mysql.api.singdata.com:3306/public?useSSL=true
+jdbc:mysql://cn-shanghai-alicloud-mysql.api.singdata.com/public
+-- Add port, optional
+jdbc:mysql://cn-shanghai-alicloud-mysql.api.singdata.com:3306/public
+-- Use SSL, optional
+jdbc:mysql://cn-shanghai-alicloud-mysql.api.singdata.com/public?useSSL=true
 ```
 
-```markdown
-When the MySQL 5.x version client connects to the server, it uses the mysql_native_password authentication method by default. For more information on MySQL authentication methods, please refer to the [official documentation](https://dev.mysql.com/doc/refman/8.0/en/authentication-plugins.html). Connecting to Lakehouse does not require SSL to be enabled. The connection method is as follows, for example, connecting to Shanghai Alibaba Cloud.
+When a MySQL 5.x client connects to the server, the default authentication method is `mysql_native_password`. For more information, refer to the [official documentation](https://dev.mysql.com/doc/refman/8.0/en/authentication-plugins.html). SSL is not required when connecting to Lakehouse. Connection example for Alibaba Cloud Shanghai:
 
-* Currently, you need to reset the password, even for newly created accounts. This is because the MySQL 5.x version uses the `mysql_native_password` key, and Lakehouse needs to store MySQL's encryption algorithm. Currently, Lakehouse will only store MySQL key's encryption algorithm when the password is changed. You can keep the same password when modifying it to avoid affecting other task connections.
-```
+* Currently, you need to reset the password even for newly created accounts. This is because MySQL 5.x uses the `mysql_native_password` key, and Lakehouse needs to store MySQL's encryption algorithm. Lakehouse only stores MySQL key encryption algorithms when the password is changed. You can keep the same password when modifying it to avoid affecting other task connections.
 
 ```
-jdbc:mysql://cap-southeast-1-aws-mysql.api.singdata.com/public?useSSL=false
---Add port, optional
-jdbc:mysql://ap-southeast-1-aws-mysql.api.singdata.com:3306/public?useSSL=false
+jdbc:mysql://cn-shanghai-alicloud-mysql.api.singdata.com/public?useSSL=false
+-- Add port, optional
+jdbc:mysql://cn-shanghai-alicloud-mysql.api.singdata.com:3306/public?useSSL=false
 ```
 
-Port: 3306 Optional
+Port: 3306 (optional)
 
 ## Usage Scenarios
 
-* Unable to use Lakehouse driver scenarios, such as some report scenarios that do not support custom JDBC drivers or do not support Lakehouse native JDBC drivers. If the Lakehouse native driver can be used, use it as much as possible.
+* Scenarios where the Lakehouse driver cannot be used — for example, when some BI report tools do not support custom JDBC drivers or the Lakehouse native JDBC driver. If possible, use the Lakehouse native driver.
 
 ## Usage Restrictions
 
-* Currently unable to fully support MySQL functions and syntax, some MySQL-specific syntax and functions in some reports will cause errors when sent to Lakehouse (please contact Lakehouse support).
+* Full compatibility with MySQL functions and syntax is not currently available. Some MySQL-specific syntax and functions used in certain reports will produce errors when sent to Lakehouse (contact Lakehouse support).
 * Data type restrictions
-  * Using the MySQL driver does not support MySQL types such as mediumint, numeric, bit, time, year, datetime, varbinary, text, blob, enum, set, spatial data types. If the SQL sent contains these keywords, an error will occur, for example, cast(xxxx as datetime).
-  * Using the MySQL driver does not support complex types such as array, struct, map, json, binary, etc., which are unique to Lakehouse. This is because the MySQL client cannot handle Lakehouse-specific types.
+  * When using the Lakehouse MySQL protocol, if SQL statements contain MySQL-specific types (such as mediumint, numeric, bit, time, year, datetime, varbinary, text, blob, enum, set, or spatial data types), the system will report an error. For example, `CREATE TABLE mysql_table(col numeric)` or `SELECT CAST(xxxx AS text)` — any SQL containing these types will trigger an error. To avoid this, use Lakehouse types as replacements for MySQL data types.
 * Syntax restrictions
-  * Does not support MySQL-specific syntax such as MySQL dump command, Load command, etc.
+  * MySQL-specific syntax such as MySQL dump commands and LOAD commands are not supported.
 * Function restrictions
-  * Lakehouse implements some commonly used MySQL functions, such as `str_to_date` and `date_format`. If you need more, please contact Lakehouse support.
+  * Lakehouse implements some commonly used MySQL functions. Contact Lakehouse support if you need more.
 * Data import restrictions
-  * Does not support MySQL bulk data import, such as the MySQL load command.
-  * Using the MySQL driver does not support Lakehouse local commands ([COPY LOCAL file](copy.md), [PUT](put.md), [REMOVE](remove-volume.md), [GET](get.md), etc.), and does not support using the MySQL driver to call Lakehouse's Java SDK for bulk upload and real-time upload of data.
-* When MySQL lists the table structure, it needs to query the information schema. Currently, there is a 15-minute delay for newly created tables in the information schema in Lakehouse, so newly created tables cannot be seen immediately.
+  * MySQL bulk data import (e.g., MySQL LOAD command) is not supported.
+  * Using the MySQL driver does not support Lakehouse local commands ([PUT](put.md), [REMOVE](remove-volume.md), [GET](get.md), etc.), and does not support using the MySQL driver to call Lakehouse's Java SDK for bulk upload and real-time upload.
+* When MySQL lists table structures, it needs to query the information schema. There is currently a 15-minute delay in Lakehouse for newly created tables appearing in the information schema, so newly created tables cannot be seen immediately.
 
 ## Connection Method
 
-## 1. Set up the computing cluster
+## Set Up the Virtual Cluster
 
-Since there is no way to set the cluster in the MySQL protocol, users can use SQL commands to add a default computing cluster for the user. This way, the cluster will be used when connecting to MySQL. It should be noted that BI scenarios often have performance requirements for analysis, so it is recommended to choose an appropriate specification of the analytical computing cluster for the BI tool connection user to provide the best query performance.
+Since the MySQL protocol has no way to pass in a cluster setting, users can use SQL commands to add a default Virtual Cluster for the user. This cluster will be used when connecting via MySQL. Note that BI scenarios often have performance requirements for analysis, so it is recommended to choose an appropriate specification of analytical Virtual Cluster for the BI tool connecting user to provide the best query performance.
 
 ```sql
-ALTER USER user_name SET DEFAULT_VCLUSTER = default;
+ALTER USER user_name SET DEFAULT_VCLUSTER = DEFAULT;
 
--- Check if the cluster settings have taken effect
+-- Check if the cluster setting has taken effect
 SHOW USERS;
 ```
 
-## 2. Set Username and Password
+## Set Username and Password
 
 Since the MySQL protocol does not include workspace name and instance name, you need to concatenate the instance name and workspace name into the username.
 
-The username format requirements are as follows:
+The username format requirement is:
 
 ```
-The account name used to log in@instance_name.workspace_name
+account_name@instance_name.workspace_name
 ```
 
-* **instance\_name Retrieval**: Obtain the JDBC connection string from the [workspace](workspace-introduction.md) page. For example, in `jdbc:clickzetta://jnsxwfyr.api.singdata.com/quick_start?virtualCluster=default`, `jnsxwfyr` is the instance\_name.
-* **workspace\_name Retrieval**: The name of the workspace.
+* **instance_name**: Obtain from the JDBC connection string on the [Workspace](workspace-introduction.md) page. For example, in `jdbc:clickzetta://jnsxwfyr.api.singdata.com/quick_start?virtualCluster=DEFAULT`, `jnsxwfyr` is the instance_name.
+* **workspace_name**: The name of the workspace.
 
 Example:
 
@@ -88,97 +87,98 @@ Example:
 user@jnsxwfyr.quick_start
 ```
 
-## 3. Set Connection Address:
+## Set Connection Address
 
 Port: 3306
 
-| Cloud Service Provider | Region    | Connection Address                                 |
-| ---------------------- | --------- | -------------------------------------------------- |
-|  Alibaba Cloud                      | Singapore | ap-southeast-1-alicloud-mysql.api.singdata.com     |
-|     Amazon                   | Singapore | ap-southeast-1-aws-mysql.api.singdata.com          |
+| Cloud Provider | Region    | Connection Address                                         |
+| -------------- | --------- | ---------------------------------------------------------- |
+| Alibaba Cloud  | Shanghai  | cn-shanghai-alicloud-mysql.api.singdata.com              |
+| Tencent Cloud  | Shanghai  | ap-shanghai-tencentcloud-mysql.api.singdata.com          |
+|                | Beijing   | ap-beijing-tencentcloud-mysql.api.singdata.com           |
+|                | Guangzhou | ap-guangzhou-tencentcloud-mysql.api.singdata.com         |
+| Amazon         | Beijing   | cn-north-1-aws-mysql.api.singdata.com                    |
 
-## 4. Other Parameters:
+## Other Parameters
 
-* useSSL=true: Lakehouse uses caching\_sha2\_password for MySQL 8.x clients, so when connecting with MySQL 8.x drivers, you must set useSSL=true. If using MySQL 5.x versions, set useSSL=false.
-* Database Name: The schema name of Lakehouse
-* Port: 3306 optional
+* `useSSL=true`: Lakehouse uses `caching_sha2_password` for MySQL 8.x clients, so when connecting with MySQL 8.x drivers, you must set `useSSL=true`. If using MySQL 5.x, set `useSSL=false`.
+* Database name: The schema name in Lakehouse
+* Port: 3306 (optional)
 
-## General BI Report Configuration Parameters
+## BI Report Configuration Parameters
 
 **Connection Tool**
 
-It is recommended to use the MySQL Java 8.0 driver to run SQL. However, some reports may initialize with MySQL-specific syntax. If you encounter errors, please contact Lakehouse technical support.
+MySQL Java 8.0 driver is recommended. However, some reports may initialize with MySQL-specific syntax — if you encounter errors, contact Lakehouse technical support.
 
 **Set vcluster**:
-You need to specify the default vcluster for the connecting user in Lakehouse. This way, the specified cluster will be used when connecting via MySQL. Note that BI scenarios often have performance requirements for analysis, so it is recommended to choose an appropriate specification of the analytical computing cluster for the BI tool connecting user to provide the best query performance.
+You need to assign a default Virtual Cluster for the connecting user in Lakehouse. This cluster will be used when connecting via MySQL. Note that BI scenarios often have performance requirements for analysis, so it is recommended to choose an appropriate specification of analytical Virtual Cluster for the BI tool connecting user to provide the best query performance.
 
 ```SQL
-ALTER USER user_name SET DEFAULT_VCLUSTER= default_ap;
---Check if the vcluster setting is effective
-show users;
+ALTER USER user_name SET DEFAULT_VCLUSTER = default_ap;
+-- Check if the vcluster setting has taken effect
+SHOW USERS;
 ```
 
-**Driver Requirements**: MySQL 8.0 or above is recommended
+**Driver requirements**: MySQL 8.0 or above is recommended
 
-**Connection Address (must be configured**)
+**Connection address (required)**
 
-**Username Format (must be configured**)
+**Username format (required)**
 
-* Format: <<<username@instance_name.workspace_name>>>, for example, <<<test@jnsxwfyr.ql_ws>>>
+* Format: username@instance_name.workspace_name, for example, test@jnsxwfyr.ql_ws
 
-**Database Name (must be configured**)
+**Database name (required)**
 
 * Format: schema name, such as public
 
-**Port: 3306. Some reports need to be configured**
+**Port: 3306. Required for some reports**
 
-**Additional Parameters (must be configured**):
+**Additional parameters (required)**:
 
-If using the 8.x driver, some reports can directly fill in the configuration parameters by entering the following string
+If using the 8.x driver, some reports can directly fill in the following string in the configuration parameters:
 
 * useSSL=true
 
-If the report does not support filling in parameters
+If the report does not support filling in parameters:
 
-* The useSSL option can be selected in the report interface if SSL needs to be used
-  If using the 5.x version driver, it does not need to be selected
+* In the report interface, there is usually an option to enable SSL — check it.
+  If using the 5.x driver, this does not need to be checked.
 
 ## Common Issues
 
 * Unable to specify computing resources
 
-  * The user connected needs to be assigned a default vcluster, which can be specified in Lakehouse for the user's default vcluster
-* ```SQL
-    alter user UAT_TEST set DEFAULT_VCLUSTER= default;
-    -- Check if the vcluster setting is effective
-    show users;
-  ```
+  * You need to assign a default Virtual Cluster for the connecting user in Lakehouse
+  * ```SQL
+    ALTER USER UAT_TEST SET DEFAULT_VCLUSTER = DEFAULT;
+    -- Check if the vcluster setting has taken effect
+    SHOW USERS;
+    ```
 
 ## Troubleshooting
 
-Troubleshoot issues through lakehouse job history. After connecting via the MySQL protocol, the MySQL connection to Lakehouse usually sends some SQL, and the job history will record the sent SQL. At this point, we can view the sent SQL through the job history to see the error information. Quickly locate through filtering, with the following three filtering conditions:
+Troubleshoot issues through the Lakehouse job history. After connecting via the MySQL protocol, MySQL connections to Lakehouse typically send some SQL, and job history records all submitted SQL. You can view the sent SQL through job history to see error information. Filter quickly using these three conditions:
 
-* Compute Cluster: The compute cluster specified in the BI report
-* Submitter: The username connected in the BI report, for example, if it is <<<<<test@jnsxwfyr.ql_ws>>>>>, then filter here as test
+* Virtual Cluster: The Virtual Cluster specified in the BI report
+* Submitter: The username connected in the BI report — for example, if it is `test@jnsxwfyr.ql_ws`, filter by `test`
 * Schema: The schema name specified in the BI report
-* Monitor the SQL sent by the BI report by clicking the refresh button in the upper right corner
+* Click the refresh button in the upper right corner to monitor SQL sent by the BI report
 
-  ![](.topwrite/assets/image_1739867274817.png)
+![](.topwrite/assets/image_1722596643860.png)
 
-## Case
+## Examples
 
-* Using MySQL client connection
+* Using mysql client to connect
 
-MySQL client connects to Lakehouse:
+mysql client connection to Lakehouse:
 
 ```
--- Add the -A option to avoid sending some verification SQL when connecting to mysql
-mysql -h cn-shanghai-alicloud-mysql.api.clickzetta.com -u user_name@instance_name.worksapace_name -D  public -p -A
+-- Add the -A option to avoid sending some validation SQL when connecting to mysql
+mysql -h cn-shanghai-alicloud-mysql.api.singdata.com -u user_name@instance_name.workspace_name -D public -p -A
 
--- When using the mysql client to connect, if the error message is: ERROR 2059 (HY000): Authentication plugin 'mysql_clear_password' cannot be loaded: plugin not enabled, you can add parameters and use the following command to connect
-mysql -h cn-shanghai-alicloud-mysql.api.clickzetta.com -u user_name@instance_name.worksapace_name -Dpublic -p -A --enable-cleartext-plugin --default-auth=mysql_native_password
+-- When connecting with the mysql client, if you get the error: ERROR 2059 (HY000): Authentication plugin 'mysql_clear_password' cannot be loaded: plugin not enabled, add parameters and use the following command to connect
+mysql -h cn-shanghai-alicloud-mysql.api.singdata.com -u user_name@instance_name.workspace_name -Dpublic -p -A --enable-cleartext-plugin --default-auth=mysql_native_password
 ```
 
-* Use [Power BI to connect to Lakehouse](<power_bi.md>)
-
-^
+* Use [Power BI to connect to Lakehouse](PowerBI.md)

package/bin/skills/lakehouse-doc-en/references/use-python-sdk-upload-data.md

@@ -1,6 +1,6 @@
 # Batch Upload Data Using Python SDK
 
-This document details how to use the BulkloadStream in the Python SDK to batch load data into Lakehouse. This method is suitable for importing large amounts of data at once, supports custom data sources, and provides flexibility for data import. This example uses a local CSV file as an example. If the data source is within the object storage or the data integration range supported by Lakehouse Studio, it is recommended to use the COPY command or data integration.
+This document details how to use the BulkloadStream in the Python SDK to batch load data into Lakehouse. This method is suitable for importing large amounts of data at once, supports custom data sources, and provides flexibility for data import. This example uses a local CSV file. If the data source is in object storage or within the data integration scope supported by Lakehouse Studio, it is recommended to use the COPY command or the data integration feature instead.
 
 # Reference Documentation
 
@@ -9,18 +9,18 @@ This document details how to use the BulkloadStream in the Python SDK to batch l
 ## Application Scenarios
 
 * Suitable for business scenarios that require batch data uploads.
-* Suitable for developers familiar with Python and needing to customize data import logic.
+* Suitable for developers familiar with Python who need to customize data import logic.
 
 ## Usage Restrictions
 
 * BulkloadStream does not support writing to primary key (pk) tables.
 * Not suitable for frequent data upload scenarios with intervals of less than five minutes.
 
-## Use Case
+# Use Case
 
 This example uses the `olist_order_payments_dataset` from the [Brazilian E-commerce](https://www.kaggle.com/datasets/olistbr/brazilian-ecommerce?select=olist_order_items_dataset.csv) public dataset.
 
-### Prerequisites
+## Prerequisites
 
 * Create the target table `bulk_order_payments`:
 
@@ -41,15 +41,15 @@ CREATE TABLE bulk_order_payments (
 | ------------- | ------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | username      | Y            | Username                                                                                                                                                                                           |
 | password      | Y            | Password                                                                                                                                                                                           |
-| service       | Y            | Address to connect to the lakehouse, region_id.api.singdata.com. You can see the JDBC connection string in Lakehouse Studio management -> workspace![](.topwrite/assets/image_1728887857029.png) |
-| instance      | Y            | You can see the JDBC connection string in Lakehouse Studio management -> workspace![](.topwrite/assets/image_1729051500396.png)                                                                 |
+| service       | Y            | Address to connect to the Lakehouse, region\_id.api.clickzetta.com. You can view the JDBC connection string in Lakehouse Studio under Administration -> Workspace ![](../.topwrite/assets/image_1728887857029.png) |
+| instance      | Y            | You can view the JDBC connection string in Lakehouse Studio under Administration -> Workspace ![](../.topwrite/assets/image_1729051500396.png)                                                     |
 | workspace     | Y            | Workspace in use                                                                                                                                                                                   |
-| vcluster      | Y            | VC in use                                                                                                                                                                                          |
+| vcluster      | Y            | Virtual Cluster in use                                                                                                                                                                             |
 | schema        | Y            | Name of the schema to access                                                                                                                                                                       |
 
 ## Develop with Python Code
 
-Use pip to install the Python package dependencies for Lakehouse. Python version 3.6 or above is required:
+Use pip to install the Python package dependencies for Lakehouse. Python version 3.10 or above is required:
 
 ```SQL
 pip install clickzetta-connector
@@ -65,11 +65,11 @@ def get_lakehouse_connect():
     conn = connect(
         username='',
         password='',
-        service='api.singdata.com',
+        service='api.clickzetta.com',
         instance='',
         workspace='',
         schema='public',
-        vcluster='default_ap')
+        vcluster='DEFAULT_AP')
     return conn
 
 conn = get_lakehouse_connect()
@@ -99,5 +99,3 @@ Commit data import completion:
 ```SQL
 bulkload_stream.commit()
 ```
-
-^

package/bin/skills/lakehouse-doc-en/references/user-identification.md

@@ -13,7 +13,7 @@ This documentation covers the following topics in detail:
 
 Users in Singdata can be divided into two levels based on their scope: **global account users** and **Lakehouse service instance users**. These two levels help enterprises manage all users under an account globally across multi-cloud and multi-region service instances, while also differentiating permission scopes for different users based on the service instance.
 
-:-: ![User Hierarchy](.topwrite/assets/用户层级.png =740)
+
 
 ^
 
@@ -21,7 +21,7 @@ Users in Singdata can be divided into two levels based on their scope: **global
 
 Global users are users who perform global management and configuration on the Singdata platform. Each user has an independent identity in the system, with a unique username and password. Within an account, the username (user_name) must be unique to distinguish different user identities. Phone numbers, email addresses, and other information can be duplicated across different users.
 
-:-: ![](.topwrite/assets/image_1735044530952.png =800)
+
 
 ^
 
@@ -31,7 +31,6 @@ Service instance users are users within a specific service instance (instance) s
 
 Service instance users are granted the "instance_user" role by default, which has no data or functional permissions. They need to be further granted permissions within the instance or workspace before they can perform operations.
 
-:-: ![](.topwrite/assets/image_1735044611663.png =800)
 
 ***
 

package/bin/skills/lakehouse-doc-en/references/user_permission_grand_guide.md

@@ -8,7 +8,7 @@ This guide also validates the process through a hands-on experiment.
 
 ^
 
-:-: ![](.topwrite/assets/image_1747735632210.png =796)
+
 
 ^
 

package/bin/skills/lakehouse-doc-en/references/using-udf-in-dynamic-table.md

@@ -1,5 +1,5 @@
 # Using UDF in Dynamic Tables
-> ⚠️ **Note**: This feature is currently in public preview.
+
 
 
 Dynamic tables extend support for user-defined functions. You can use custom functions created with External Function (including UDF, UDAF, and UDTF) in the SELECT clause of a dynamic table DDL. The system will automatically apply incremental computation optimization during refresh.

package/bin/skills/lakehouse-doc-en/references/vc_cache.md

@@ -14,49 +14,47 @@ Among them:
 
 Metadata Cache and Query Result Cache services belong to the service layer and can be shared within the workspace.
 
-Compute Cluster Local Disk Cache is stored on the local nodes of the cluster and can only be used when using the specified virtual cluster.
+Compute Cluster Local Disk Cache is stored on the local nodes of the cluster and can only be used when using the specified Virtual Cluster.
 
 In the storage-compute separation architecture of Lakehouse, data is stored in object storage. To address network request latency and improve response speed in analytical scenarios, we adopt caching strategies. Compute Cluster Cache stores frequently accessed data on local nodes, thereby accelerating queries.
 
 Compute Cluster Cache is divided into two types:
 
-1. **Active Cache**: Manually cache tables to the compute cluster through commands. Each time the compute cluster starts, these pre-cached tables will be automatically loaded. Currently, only AP type clusters are supported. Suitable scenarios include BI report queries, which can significantly reduce query latency and improve data processing speed.
+1. **Active Cache**: Manually cache tables to the compute cluster through commands. Each time the compute cluster starts, the latest data or partitions of these pre-cached tables are automatically loaded. Currently, only AP type clusters are supported. Suitable scenarios include BI report queries, which can significantly reduce query latency and improve data processing speed.
 2. **Passive Cache**: During the first query, Lakehouse automatically caches the read files to the compute cluster. Subsequent queries involving the same table files will directly utilize the cache, speeding up the query process. Supports both GP and AP type clusters. For the second and subsequent queries, if they involve the initially cached tables, the cache will be directly hit.
 
 ## Usage
 
-1. **Proactive Caching Table Method**:
+1. **Active Caching Method**:
 
-    ```SQL
-    ALTER VCLUSTER default SET PRELOAD_TABLES="schema1.table1,schema2.table2";
-    ```
+```SQL
+ALTER VCLUSTER DEFAULT SET PRELOAD_TABLES="schema1.table1,schema2.table2";
+```
 
-    If you need to add a new table to the cache:
+If you need to add a new table to the cache, you must include all previously configured tables, otherwise the original ones will be overwritten:
 
-    ```SQL
-    ALTER VCLUSTER default SET PRELOAD_TABLES="schema1.table1,schema2.table2,schema3.table3";
-    ```
+```SQL
+ALTER VCLUSTER DEFAULT SET PRELOAD_TABLES="schema1.table1,schema2.table2,schema3.table3";
+```
 
-`PRELOAD_TABLES` supports wildcards. Use `schema_name.*` to cache all tables in a Schema:
+`PRELOAD_TABLES` supports wildcards. Use `schema_name.*` to cache all tables under a Schema:
 
 ```SQL
--- Cache all tables in the sales Schema, plus dim_date from the public Schema
+-- Cache all tables in the sales Schema, plus the dim_date table in the public Schema
 ALTER VCLUSTER bi_vc SET PRELOAD_TABLES="sales.*,public.dim_date";
 ```
 
 ## **Viewing Cache Status**:
+When tables are loaded into the compute cluster using the `ALTER..PRELOAD_TABLES` command, there may be a delay in the cache status update displayed by `SHOW PRELOAD`. However, the cached tables are actually already effective. Under normal circumstances, this delay is approximately 10 minutes.
 
-When tables are loaded into the compute cluster using the `ALTER..PRELOAD_TABLES` command, there may be a delay in the update of the cache status displayed by `SHOW PRELOAD`. However, the cached tables are actually effective. Under normal circumstances, this delay is about 10 minutes.
-
-1. **Active Cache Table Method**:
 
-* Display the preload table/partition status of the current virtual cluster:
+* Display the preload table/partition status of the current Virtual Cluster:
 
 ```SQL
 SHOW PRELOAD CACHED STATUS;
 ```
 
-* Display the preload table/partition status of the specified virtual cluster:
+* Display the preload table/partition status of the specified Virtual Cluster:
 
 ```SQL
 SHOW VCLUSTER preload_ap_vc_test PRELOAD CACHED STATUS;
@@ -68,18 +66,16 @@ SHOW VCLUSTER preload_ap_vc_test PRELOAD CACHED STATUS;
 SHOW VCLUSTER preload_ap_vc_test PRELOAD CACHED STATUS WHERE table LIKE '%x_test';
 ```
 
-* Display the preloaded cache summary information of the virtual cluster:
+* Display the preloaded cache summary information of the Virtual Cluster:
 
 ```SQL
 SHOW EXTENDED PRELOAD CACHED STATUS;
 ```
 
-## Precautions
+## Notes
 
 * Active caching (PRELOAD_TABLES) is only supported on **Analytics (AP)** clusters. General Purpose (GP) clusters do not support this feature.
 * `PRELOAD_TABLES` is an **overwrite** operation. When adding a new table, you must include all previously configured tables, otherwise they will be removed from preloading.
-* The cluster supports automatic start and stop. When the cluster stops, the local cache is automatically released. In AP clusters, only the most recently written data or partitions are cached on restart.
+* The cluster supports automatic start and stop. When the cluster stops, the local cache is automatically released. When an AP cluster restarts, only the most recently written data or partitions are cached.
 * After executing the cache command, only newly written data will be cached.
 * `SHOW PRELOAD` status updates may have approximately a 10-minute delay, but the cache is already effective.
-
-^