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

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

@@ -16,25 +16,25 @@ Singdata Lakehouse Studio's real-time multi-table synchronization supports multi
 
 Navigate to Development -> Tasks, click "+", select "Real-time Multi-table Synchronization", and create a new real-time multi-table synchronization task.
 
-:-: ![](.topwrite/assets/image_1736147975347.png =494)
+
 
 Task Name: 06\_multi\_table\_rt\_sync\_from\_pg
 
 ##### Select "PostgreSQL" as the Source Data
 
-:-: ![](.topwrite/assets/image_1736147983573.png =502)
+
 
 ##### Select Synchronization Objects
 
 Singdata Lakehouse Studio will automatically synchronize the source database structure for selection:
 
-:-: ![](.topwrite/assets/image_1736147992225.png =467)
+
 
 ##### Database CDC Configuration
 
 Create a Slot
 
-:-: ![](.topwrite/assets/image_1736148001087.png =459)
+
 
 Plugin Type: pgoutput
 
@@ -44,49 +44,45 @@ Slot Name: slot\_for\_multi\_table\_ingest\_demo
 
 Rule Expression: multitable\_sync\_{SOURCE\_TABLE}. Add the prefix multitable\_sync\_{SOURCE\_TABLE} to the target table to distinguish it from tables synchronized by other methods.
 
-Check field mapping to ensure all mappings are successful:
+Check field mapping to ensure all mappings are successful.
 
-:-: ![](.topwrite/assets/image_1736148015509.png =445)
 
 ##### Configure Synchronization Rules
 
-:-: ![](.topwrite/assets/image_1736148027202.png =443)
+
 
 ##### Submit
 
-Submit the real-time multi-table synchronization task after configuration:
+Submit the real-time multi-table synchronization task after configuration.
 
-:-: ![](.topwrite/assets/image_1736148034594.png =427)
 
 ##### Operations and Maintenance
 
 Maintain the real-time multi-table synchronization task:
 
-:-: ![](.topwrite/assets/image_1736148045501.png =425)
+
 
 ##### Start
 
 Start the real-time multi-table synchronization task:
 
-:-: ![](.topwrite/assets/image_1736148052375.png =426)
 
-For the first start of this real-time multi-table synchronization task, select "Stateless Start" and "Full Data Synchronization":
 
-:-: ![](.topwrite/assets/image_1736148058726.png =426)
+For the first start of this real-time multi-table synchronization task, select "Stateless Start" and "Full Data Synchronization".
+
+
 
 After starting, you can view the detailed status of the task. Once the full synchronization is complete, the system will automatically begin incremental real-time synchronization.
 
 ##### Progress Monitoring
 
-Full synchronization in progress:
+Full synchronization in progress.
 
-:-: ![](.topwrite/assets/image_1736148083158.png =446)
 
 Full synchronization complete.
 
-Real-time synchronization begins:
+Real-time synchronization begins.
 
-:-: ![](.topwrite/assets/image_1736148107686.png =430)
 
 ##### Incremental Real-time Synchronization
 
@@ -236,7 +232,6 @@ python rt_data_generate_insert_into_pg.py 100000 100 10
 
 In Singdata Lakehouse Studio, view the real-time synchronization progress:
 
-:-: ![](.topwrite/assets/image_1736148122833.png =484)
 
 #### Next Steps
 

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

@@ -16,7 +16,6 @@ Suitable for manually importing small amounts of data, user debugging, and testi
 
 Navigate to Development -> Tasks, and click "+" to create a new SQL task (both methods below are implemented in the same task).
 
-:-: ![](.topwrite/assets/image_1736148597217.png =470)
 
 You can use the `INSERT INTO VALUES` statement to directly insert data. Multiple records are separated by commas.
 ```SQL

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

@@ -191,7 +191,7 @@ Massive device data continuously written via Kafka; Dynamic Tables aggregate dev
 
 ## Ecosystem Compatibility
 
-Singdata Lakehouse natively supports Apache Iceberg format and supports direct read/write of Delta Lake, Hudi, and Paimon as external tables — existing data lake assets can be onboarded without migration. On the compute ecosystem side, [Spark Connector](spark-connector-summary.md), [Flink Connector](flink-write-connector.md), and Trino Connector are provided for smooth integration with existing big data pipelines. On the BI side, FineBI, Tableau, Superset, Metabase, and PowerBI have all completed integration certification.
+Singdata Lakehouse natively supports Apache Iceberg format and supports direct read/write of Delta Lake, Hudi, and Paimon as external tables — existing data lake assets can be onboarded without migration. On the compute ecosystem side, [Spark Connector](spark-connector-summary.md) and [Flink Connector](flink-write-connector.md) are provided for smooth integration with existing big data pipelines. On the BI side, FineBI, Tableau, Superset, Metabase, and PowerBI have all completed integration certification.
 
 ## Start Here
 

package/bin/skills/lakehouse-doc-en/references/config-datasource.md

@@ -10,20 +10,19 @@ This document aims to guide users on how to configure and manage data sources to
 
    First, log in to the Lakehouse product console. On the console homepage, select the "Management" module and click to enter the "Data Source" page. You will see a list of data sources showing all currently configured data sources.
 
-   ![](.topwrite/assets/image_1740137071389.png =640)
+   :-: ![](.topwrite/assets/image_1740137071389.png =640)
 
 2. **Create a New Data Source**
 
    On the data source list page, click the "New Data Source" button in the upper right corner. At this point, you need to select the data source type. Lakehouse supports multiple data source types, including but not limited to MySQL, Oracle, SQL Server, etc.
 
-   ![](.topwrite/assets/image_1740137096346.png =640)
-
+   :-: ![](.topwrite/assets/image_1740137096346.png =640)
 
 3. **Fill in the Data Source Definition and Test Connectivity**
 
    Based on the data source type you selected, fill in the corresponding connection information. For example, for a MySQL data source, you need to provide the database address, port, username, password, etc. After filling in, click the "Test Connection" button to ensure the information provided is correct.
 
-   ![](.topwrite/assets/image_1740137122891.png =640)
+   :-: ![](.topwrite/assets/image_1740137122891.png =640)
 
 ## Connect to Data Sources within a VPC via SSH Tunnel
 
@@ -50,8 +49,7 @@ On the new data source page, enable the "Connect via SSH Tunnel" option. Fill in
 * **SSH Username**: Enter the username for SSH login.
 * **SSH Password**: Enter the corresponding SSH login password.
 
-  ![](.topwrite/assets/image_1740137146102.png =640)
-
+  :-: ![](.topwrite/assets/image_1740137146102.png =640)
 
 After completing the above configuration, click the "Test Connection" button. If the connection is successful, you will see a green checkmark prompt. This means that the data synchronization service can establish a network connection with the data source within the VPC via SSH Tunnel when the task starts.
 
@@ -79,4 +77,4 @@ After completing the above configuration, click the "Test Connection" button. If
 3. Enable the "Connect via SSH Tunnel" option and fill in the relevant information of the ECS server within the VPC.
 4. Click "Test Connection". After confirming the connection is successful, click the "Save" button to complete the data source configuration.
 
-^
+^

package/bin/skills/lakehouse-doc-en/references/connect-with-cli.md

@@ -1,127 +1,171 @@
-# Singdata Lakehouse Command Line Client User Guide
+# Connect to Lakehouse Using the Command Line Client
 
-This document aims to help you understand how to install, configure, and use the Singdata Lakehouse command line client. Through this guide, you will be able to smoothly connect to the Singdata Lakehouse service instance and execute various SQL commands.
+This article describes how to install, configure, and use the sqlline-based Lakehouse command line client.
+
+> 💡 **cz-cli is recommended**: cz-cli is the upgraded replacement for this tool (sqlline), offering a more modern terminal experience—Profile management (configure once, reuse globally), structured JSON output, task operations commands, AI Agent integration, and more. The sqlline client is no longer actively updated; new users are advised to use cz-cli directly.
+>
+> → [Connect using the cz-cli command line tool](connect-with-cz-cli.md)
+
+---
 
 ## Prerequisites
 
-Before using the client, please ensure the following conditions are met:
+Before using the client, ensure the following conditions are met:
 
-1. Your device has Java 8 or a higher version installed.
-2. You have registered an account on the Singdata official website and created a Lakehouse service instance.
-3. You have created a workspace for connection access.
-4. The user identity using the client has been added to the workspace and authorized for access.
+1. Your device has Java 8 or a higher version installed
+2. You have registered an account on the Singdata platform and created a Lakehouse service instance
+3. You have created a workspace for connection access
+4. The user identity using the client has been added to the workspace and authorized for access
+
+---
 
 ## Installing the Client
 
-The Singdata Lakehouse command line client is developed based on the open-source SQL Line project. Please follow the steps below to install and configure the client:
+The Lakehouse command line client is a secondary development of the open-source SQL Line project. Follow these steps to install and configure the client:
+
+1. Download the client installation package [sqlline_cz.tar.gz](https://autolake-dev-beijing.oss-cn-beijing.aliyuncs.com/clickzetta-tool/release/sqlline_cz.tar.gz) from the public network or obtain it from Singdata staff
+2. Unzip the installation package file to get the client tool's executable and configuration files:
+
+```bash
+tar -zxvf sqlline_cz.tar.gz
+```
+
+Extracted contents:
 
-1. Download the client installation package [sqlline\_cz.tar.gz](https://autolake-dev-beijing.oss-cn-beijing.aliyuncs.com/clickzetta-tool/release/sqlline_cz.tar.gz) from the public network or obtain it from Singdata staff.
-2. Unzip the installation package file, and you will get the executable file and configuration file of the client tool.
 ```
-% tar -zxvf sqlline_cz.tar.gz
-x sqlline_cz/
-x sqlline_cz/example.properties
-x sqlline_cz/log4j.properties
-x sqlline_cz/setup.sh
-x sqlline_cz/sqlline
-x sqlline_cz/sqlline-2.13.0-SNAPSHOT-jar-with-dependencies.jar
+sqlline_cz/
+├── example.properties
+├── log4j.properties
+├── setup.sh
+├── sqlline
+└── sqlline-2.13.0-SNAPSHOT-jar-with-dependencies.jar
 ```
+
+---
+
 ## Initialize Connection Environment
 
 1. Enter the working directory:
-```
+
+```bash
 cd sqlline_cz
 ```
-2. Initialize Connection Environment:
-   The main purpose is to download the latest JDBC package and place it in the sqlline\_cz directory. You can also download the latest JDBC package from the links below and place it in the sqlline\_cz directory.
 
-* [Download Link One](https://mvnrepository.com/artifact/com.clickzetta/clickzetta-java)
-* [Download Link Two](https://central.sonatype.com/artifact/com.clickzetta/clickzetta-java/versions)
-```
+2. Initialize the connection environment, downloading the latest JDBC driver:
+
+```bash
 sh setup.sh
 ```
+
+If the setup script fails to download, manually download the JDBC driver and place it in the `sqlline_cz` directory:
+
+- [Maven Central](https://central.sonatype.com/artifact/com.clickzetta/clickzetta-java/versions)
+- [MVN Repository](https://mvnrepository.com/artifact/com.clickzetta/clickzetta-java)
+
+---
+
 ## Configure Client Connection
 
 ### Method 1: Specify Connection Parameters via Command Line
 
-Command parameters for connecting via specified method:
-```
-sh sqlline -d com.clickzetta.client.jdbc.ClickZettaDriver -u "<JDBC URL>" -n <user_name> -p <password>
+```bash
+sh sqlline -d com.clickzetta.client.jdbc.ClickZettaDriver \
+  -u "jdbc:clickzetta://<instance>.<region>.api.clickzetta.com/<workspace>?schema=<schema>&vcluster=<vcluster>" \
+  -n <user_name> \
+  -p <password>
 ```
-JDBC URL format:
+
+**JDBC URL format:**
+
 ```
-jdbc:clickzetta://<Lakehouse service instance name>.api.singdata.com/<workspace name>?schema=<default schema name>&virtualCluster=<compute cluster name>
+jdbc:clickzetta://<instance_name>.<region_id>.api.clickzetta.com/<workspace_name>?schema=<schema_name>&vcluster=<vcluster_name>
 ```
-Parameter Description:
 
-* `<JDBC URL>`: The JDBC connection string for the current service instance. For the detailed format, see [JDBC Driver](jdbc-driver.md).
-* `<user_name>`: The username of the workspace member in the target workspace.
-* `<password>`: The password of the workspace member in the target workspace.
-* `schema`: The schema to be linked must be specified.
-* `virtualCluster`: The computing resources to be used must be specified.
+**Parameter descriptions:**
 
-Example:
-```
-sh sqlline -d com.clickzetta.client.jdbc.ClickZettaDriver -u "jdbc:clickzetta://<lakehouse_instance_name>.api.singdata.com/<workspace_name>?schema=<target_schema_name>&vcluster=<your_virtualcluster_name>" -n <user_name> -p <your_password>
+| Parameter | Description |
+|------|------|
+| `-d` | JDBC driver class name, fixed as `com.clickzetta.client.jdbc.ClickZettaDriver` |
+| `-u` | JDBC connection URL, see [JDBC Driver](JDBC-Driver.md) for full format |
+| `-n` | Workspace member username |
+| `-p` | Workspace member password |
+| `schema` | Specifies the Schema to connect to, required |
+| `vcluster` | Virtual Cluster to use, required |
+
+**Example:**
+
+```bash
+sh sqlline -d com.clickzetta.client.jdbc.ClickZettaDriver \
+  -u "jdbc:clickzetta://my_instance.cn-shanghai-alicloud.api.clickzetta.com/my_workspace?schema=public&vcluster=DEFAULT" \
+  -n data_user \
+  -p your_password
 ```
+
 ### Method 2: Specify Configuration File via Command Line
 
-The command line tool provides a configuration file template, which you can modify and then specify the configuration file in the command line to achieve service connection. The sample configuration file format is as follows:
-```
-url=jdbc:clickzetta://<Lakehouse_instance_name>.api.singdata.com/<workspace_name>?schema=<schma_name>&virtualCluster=<vcluster_name>
+1. Modify the configuration file template `example.properties`:
+
+```properties
+url=jdbc:clickzetta://<instance>.<region>.api.clickzetta.com/<workspace>?schema=<schema>&vcluster=<vcluster>
 driver=com.clickzetta.client.jdbc.ClickZettaDriver
 user=<your_user_name>
 password=<your_password>
 ```
-After modifying the template configuration file according to your service information and saving it, connect to the service by specifying the configuration file name through command parameters.
-```
-$ sh sqlline properties <configuration file name>
-```
-Example:
-```
-$ sh sqlline properties test.properties
-sqlline version 1.13.0-SNAPSHOT
-0: jdbc:clickzetta://xxxx.api.singdata.com>show tables;
+
+2. Connect using the configuration file:
+
+```bash
+sh sqlline properties test.properties
 ```
-Singdata Lakehouse command line tool can create multiple different service connection configuration files at once. During use, you can quickly switch between service connections corresponding to different configuration files using the `!properties` command. The following example demonstrates switching from the configuration file test.properties to test.properties.1:
+
+After connecting, use the `!properties` command to quickly switch to another configuration file within the session:
+
 ```
-sqlline> !properties test.properties
-Transaction isolation level TRANSACTION_REPEATABLE_READ is not supported. Default (TRANSACTION_READ_COMMITTED) will be used instead.
-0: jdbc:clickzetta://xxxx.api.singdata.com> !properties test.properties.1
-Transaction isolation level TRANSACTION_REPEATABLE_READ is not supported. Default (TRANSACTION_READ_COMMITTED) will be used instead.
-1: jdbc:clickzetta://yyyyy.api.singdata.com> !go 0
-0: jdbc:clickzetta://xxxx.api.singdata.com>
+0: jdbc:clickzetta://xxxx.api.clickzetta.com> !properties test.properties.1
+1: jdbc:clickzetta://yyyy.api.clickzetta.com>
 ```
+
+---
+
 ## Running SQL Commands
 
-After a successful connection, you can execute Lakehouse SQL commands in the command line client. Here are some examples of SQL commands:
+After a successful connection, you can execute Lakehouse SQL commands in the command line client:
 
-Switch the vcluster and schema to use:
-```
-use vcluster default;
+```sql
+-- Switch Virtual Cluster and Schema
+use vcluster DEFAULT;
 use schema nyc_taxi_data;
-```
 
-View the tables in the current schema:
-```
+-- View tables in the current Schema
 show tables;
-```
-![](.topwrite/assets/image_1699879449976.png)
 
-Query data:
-```
-select  * from fhv_trips_staging limit 10;
+-- Query data
+select * from fhv_trips_staging limit 10;
 ```
-![](.topwrite/assets/image_1699879794959.png)
+
+---
 
 ## Exit Client
+
 ```
 !quit
 ```
-## Notes
 
-By setting the following environment variables in the current environment, you can enable debug mode, output log files, and facilitate troubleshooting.
-```
+---
+
+## Enable Debug Logging
+
+Enable debug mode by setting an environment variable to output log files for troubleshooting:
+
+```bash
 export SQLLINE_DEBUG_ENABLE=TRUE
 ```
 
+---
+
+## Related Documents
+
+- [Connect using the cz-cli command line tool](connect-with-cz-cli.md) — Recommended alternative
+- [JDBC Driver Connection](JDBC-Driver.md) — Full JDBC URL format and parameters
+- [Connect to Lakehouse Tutorial](tutorial_connect_to_lakehouse.md) — Comparison of all connection methods
+

package/bin/skills/lakehouse-doc-en/references/connect-with-cz-cli.md

@@ -0,0 +1,151 @@
+# Connecting to Lakehouse with cz-cli
+
+cz-cli is the command-line tool for Singdata Lakehouse. It provides connection profile management, SQL execution, job operations, and more. Compared to JDBC clients, cz-cli uses **Profiles to manage connection information** — configure once, and all subsequent operations automatically use the same connection parameters without needing to re-enter a JDBC URL, username, or password every time.
+
+---
+
+## Prerequisites
+
+1. cz-cli is installed (see [cz-cli Installation and Setup Guide](setup_cz_cli.md))
+2. A Lakehouse instance exists and a workspace has been created
+3. Your user account has been added to the target workspace with appropriate permissions
+
+---
+
+## Configuring a Connection Profile
+
+A Profile is a local configuration where cz-cli stores connection information. One Profile corresponds to one Lakehouse connection environment (instance + workspace + schema + Virtual Cluster). It is recommended to create a separate Profile for each environment such as production, test, and UAT.
+
+### Option 1: Create a Profile with Parameters (Recommended)
+
+```bash
+cz-cli profile create <profile_name> \
+  --service    <service> \
+  --instance   <instance> \
+  --workspace  <workspace> \
+  --schema     <schema> \
+  --vcluster   <vcluster> \
+  --username   <username> \
+  --password   '<password>'
+```
+
+**Parameter descriptions:**
+
+| Parameter | Description | How to obtain |
+|------|------|---------|
+| `--service` | Service endpoint address | See the cloud region table below |
+| `--instance` | Instance ID | Instance name in the top-left of Studio homepage, or the `instanceId` parameter in the URL |
+| `--workspace` | Workspace name | Dropdown at the top of Studio |
+| `--schema` | Default schema | Run `SELECT CURRENT_SCHEMA()` after connecting |
+| `--vcluster` | Default Virtual Cluster | Typically `DEFAULT` (general-purpose GP cluster) |
+| `--username` | Login username | Your platform account |
+| `--password` | Login password | Your platform password |
+
+**Example: Configure Alibaba Cloud Shanghai production environment**
+
+```bash
+cz-cli profile create prod_sh \
+  --service   https://cn-shanghai-alicloud.api.clickzetta.com \
+  --instance  f8866243 \
+  --workspace quick_start \
+  --schema    semantic_model_test \
+  --vcluster  DEFAULT \
+  --username  qiliang \
+  --password  'your_password'
+```
+
+### Option 2: Create from a Connection String Generated in Studio
+
+In Studio → Personal Settings → Developer Tools → CLI tab, select PAT or password authentication, click "Generate Connection String", copy it, and run it in the terminal.
+
+### Option 3: Create with a JDBC URL
+
+```bash
+cz-cli profile create prod \
+  --jdbc "jdbc:clickzetta://<instance_name>.<service_endpoint>/<workspace_name>?username=<username>&password=<password>&schema=<schema>&virtualCluster=<vcluster>"
+```
+
+---
+
+## Verifying the Connection
+
+```bash
+# View the list of created Profiles
+cz-cli profile list
+
+# Run a query using a specific Profile to verify the connection
+cz-cli sql "SELECT 1" --profile prod_sh
+
+# Set a commonly used Profile as default to omit --profile in future commands
+cz-cli profile use prod_sh
+```
+
+---
+
+## Basic Operations After Connecting
+
+### Executing SQL
+
+```bash
+# Query
+cz-cli sql "SELECT * FROM silver.dim_player LIMIT 5" --sync
+
+# DDL/DML (requires --write)
+cz-cli sql "CREATE TABLE test (id INT)" --sync --write
+
+# Execute a SQL file
+cz-cli sql -f deploy.sql --write
+```
+
+### Switching Environments
+
+```bash
+# View all Profiles
+cz-cli profile list
+
+# Switch to a different environment
+cz-cli profile use prod_sh    # production
+cz-cli profile use uat        # UAT
+cz-cli profile use tencent_sh # Tencent Cloud Shanghai
+```
+
+---
+
+## Common Service Endpoints by Cloud and Region
+
+| Cloud Platform | Region | Service Endpoint |
+|--------|------|-----------------|
+| Alibaba Cloud | Shanghai | `https://cn-shanghai-alicloud.api.clickzetta.com` |
+| Tencent Cloud | Shanghai | `https://ap-shanghai-tencentcloud.api.clickzetta.com` |
+| Tencent Cloud | Beijing | `https://ap-beijing-tencentcloud.api.clickzetta.com` |
+| Tencent Cloud | Guangzhou | `https://ap-guangzhou-tencentcloud.api.clickzetta.com` |
+| AWS | Beijing | `https://cn-north-1-aws.api.clickzetta.com` |
+| AWS | Singapore | `https://ap-southeast-1-aws.api.singdata.com` |
+
+> **Tip**: If you are unsure about the endpoint, go to Studio → Personal Settings → Developer Tools → CLI tab and copy the complete connection command, which includes the correct Service address.
+
+---
+
+## Troubleshooting
+
+### Connection Timeout or Refused
+
+Check whether the network can reach the Service endpoint (production environments typically require a proxy or bastion host). Verify that the instance ID and workspace name are correct.
+
+### Schema or Virtual Cluster Not Found
+
+Run `cz-cli sql "SHOW SCHEMAS"` to list available schemas, and `cz-cli sql "SHOW VCLUSTERS"` to list available Virtual Clusters. Confirm the spelling is correct, then recreate the Profile.
+
+### Authentication Failed
+
+Verify the username and password are correct. If using PAT authentication, check whether the PAT has expired (regenerate it if it has).
+
+---
+
+## Related Documentation
+
+- [cz-cli Installation and Setup Guide](setup_cz_cli.md) — Installation steps, PAT authentication, detailed Profile configuration
+- [cz-cli SQL Execution and Data Exploration](cz-cli-sql.md) — SQL execution parameters, output format control
+- [JDBC Driver Connection](JDBC-Driver.md) — Java application integration
+- [Connecting with the CLI Client](connect-with-cli.md) — sqlline Java client
+- [Connecting with SQLAlchemy](sqlalchemy.md) — Python SQLAlchemy integration

package/bin/skills/lakehouse-doc-en/references/continue-job.md

@@ -1,6 +1,6 @@
 # Streaming SQL
 
-> **[Preview Release]** This feature is currently in an invitation-only preview phase. If you need access, please contact our technical support team for assistance.
+> \[**Preview Release**] This feature is currently in an invitation-only preview phase. If you need access, please contact our technical support team for assistance.
 
 Streaming SQL is a new SQL scheduling mode introduced by the Singdata Lakehouse platform. It uses a micro-batch processing mechanism that supports second-level data refresh intervals, similar to Spark Streaming's micro-batch execution model. Compared to traditional scheduled tasks, Streaming SQL significantly reduces the overhead of SQL submission and compilation by converting the submitted SQL into a persistent process that automatically triggers data execution and processing each time the configured interval elapses. Streaming SQL is designed for scenarios that require higher data freshness, and currently supports dt refresh and SQL processing that includes a table stream.
 
@@ -65,7 +65,6 @@ Streaming SQL brings greater flexibility and real-time capability to data proces
 ## Developing a Streaming SQL Task
 
 1. Create a new Streaming SQL node in Data Development.
-   ![](.topwrite/assets/image_1727083278915.png)
 
 2. Write the SQL task.
 
@@ -80,32 +79,27 @@ Streaming SQL requirements:
 **Configure the Processing Interval**
 
 Click the configuration button to set the refresh interval — how often the data is processed. The minimum interval is currently 1 second.
-![](.topwrite/assets/image_1727083303138.png)
 
 ## Running a Streaming SQL Task
 
 * Click the Submit button to submit the Streaming SQL job to the Operations Center.
-
-![](.topwrite/assets/image_1727083345312.png)
-
 * Start the Streaming SQL job. Go to the Operations Center and click the Start button. The Streaming SQL job will begin running.
 
-![](.topwrite/assets/image_1727083377948.png)
+^
 
 ## Operations
 
 * In the Operations Center, you can see a list of all Streaming SQL jobs in the current workspace.
-  ![](.topwrite/assets/image_1727083398406.png)
 
 * You can monitor the running status of a Streaming SQL job using its job ID.
 
-![](.topwrite/assets/image_1727083425696.png)
+^
 
 ## Monitoring and Alerts
 
 Monitoring and alerts support failure alerts for Streaming SQL task execution.
 
-![](.topwrite/assets/image_1727083445006.png)
+^
 
 # Use Cases
 
@@ -156,12 +150,9 @@ AND source_stream.__change_type = 'INSERT' THEN
 INSERT VALUES (target.id, target.name, target.age);
 ```
 
-![](.topwrite/assets/image_1727083470402.png)
+^
 
 4. Submit the Streaming SQL job and click Start in the Operations Center.
-
-![](.topwrite/assets/image_1727083486439.png)
-
 5. After updating the source table data and waiting for the Streaming SQL job to complete, the SCD table will reflect the same changes.
 
 * Execute the following SQL in a regular SQL node:
@@ -185,7 +176,6 @@ SELECT "test_table_offset_consume",* FROM continuous_job.test_table_offset_consu
 6. Clean up the environment.
 
 * Stop the Streaming SQL job in the Operations Center.
-  ![](.topwrite/assets/image_1727083510506.png)
 
 * Drop the schema.
 
@@ -235,11 +225,11 @@ GROUP BY
 refresh dynamic table event_group_minute;
 ```
 
-![](.topwrite/assets/image_1727083531426.png)
+^
 
 * Start the Streaming SQL job to begin refreshing the dynamic table.
 
-![](.topwrite/assets/image_1727083554105.png)
+^
 
 * Create a new regular SQL node, insert some data into the source table, and verify that the dynamic table is refreshed successfully.
 
@@ -254,3 +244,5 @@ refresh dynamic table event_group_minute;
   --Wait 10s and observe the dynamic table changes
   select * from event_group_minute;  
 ```
+
+^