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

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

@@ -1,16 +1,18 @@
 # Web Search
 
+> \[Preview Release] This feature is currently in an invite-only preview release. Contact technical support if you need access.
+
 ## Feature Overview
 
-Web Search adds internet search capability to Analytics Agent, enabling the agent to automatically invoke external search engines during data analysis to obtain real-time information, achieving combined analysis of "internal data + external knowledge." This is suitable for scenarios requiring correlation analysis between internal data and external events (such as weather, sports events, news, etc.).
+Web Search adds internet search capability to Analytics Agent, enabling the Agent to automatically invoke external search engines during data analysis to obtain real-time information, achieving combined analysis of "internal data + external knowledge." This is suitable for scenarios requiring data attribution analysis in conjunction with external events (such as weather, sports events, news, etc.).
 
-## How to Use
+## Usage
 
 Simply ask questions directly in the conversation window; there is no need to manually select a tool. The Agent will automatically determine whether an internet search is needed based on the question content.
 
 ### Example
 
-\> *Question: What caused the change in order volume between March 28-30, 2025?*
+\> *Question: What caused the change in order volume between March 28–30, 2025*?
 
 The Agent will automatically perform the following steps:
 
@@ -20,11 +22,18 @@ The Agent will automatically perform the following steps:
 
 3\. Conduct multi-dimensional attribution analysis and output conclusions along with visualization charts
 
-\:-:
-![](/.topwrite/assets/image_1776137592328.png =427)
+![](/.topwrite/assets/image_1780907641261.png)
 
 **Notes**
 
-1\. Web search results are influenced by the content returned by the search engine; it is recommended to manually verify key conclusions
+1\. Web search results are influenced by the content returned by the search engine; it is recommended to manually verify key conclusions.
+
+2\. **The Web Search feature is currently in beta. To enable internet search capability, please contact the Singdata team**.
+
+## Related Documentation
+
+* [Improve Answer Accuracy](answer-accuracy-improve.md) — Further improve answer quality with a knowledge base and semantic layer
+* [Scheduled Task](scheduled_task.md) — Automatically run data analysis on a schedule and push results
+* [Conversational Data Analytics (Analytics Agent)](datagpt_introduction.md) — Return to the feature overview
 
-2\. **The Web Search feature is currently in beta. To enable internet search capability, please contact the Singdata team**
+^

package/bin/skills/lakehouse-doc-en/references/zettapark-data-engineering-demo.md

@@ -85,7 +85,7 @@ XSMALL VCLUSTER ready
 
 > ⚠️ **Note**: The vcluster\_size parameter for compute clusters supports both T-shirt sizes (XSMALL, SMALL, Large, etc.) and numeric values (1, 2, 4, 16, etc.) to provide a richer range of compute cluster specifications for different scenarios. For more information, see: [VCluster Size Specification Change Description](vcluster_size_description.md)
 
-`config.json` file sample ([parameter description](https://doc.clickzetta.com/JDBC-Driver)):
+`config.json` file sample ([parameter description](jdbc-driver.md)):
 
 ```json
 {

package/bin/skills/lakehouse-doc-en/references/zettapark-dataframe-guide.md

@@ -7,7 +7,7 @@ Zettapark is the Python DataFrame API for Singdata Lakehouse, providing a pandas
 > 💡 **When to use what**:
 > - Need DataFrame operations (pandas/PySpark-like) → Use Zettapark (this guide)
 > - Need standard SQL execution or script automation → Use [Python Connector](python_reference/connector.md)
-> - Need high-speed bulk writes (millions of rows) → Use [BulkLoad](java_reference/bulkload-upload.md)
+> - Need high-speed bulk writes (millions of rows) → Use [BulkLoad](java_reference/bulkload.md)
 
 ---
 
@@ -27,11 +27,11 @@ from clickzetta.zettapark.session import Session
 session = Session.builder.configs({
     "username": "your_username",
     "password": "your_password",
-    "service":  "cn-shanghai-alicloud.api.singdata.com",
+    "service":  "cn-shanghai-alicloud.api.clickzetta.com",
     "instance": "your_instance",
     "workspace": "your_workspace",
     "schema":   "public",
-    "vcluster": "default"
+    "vcluster": "DEFAULT"
 }).create()
 ```
 
@@ -53,13 +53,16 @@ from clickzetta.zettapark.session import Session
 data = [(1, "Alice", 1000.0), (2, "Bob", 2000.0), (3, "Carol", 500.0)]
 df = session.create_dataframe(data, schema=["id", "name", "amount"])
 df.show()
-# +---+-----+------+
-# | id| name|amount|
-# +---+-----+------+
-# |  1|Alice|  1000|
-# |  2|  Bob|  2000|
-# |  3|Carol|   500|
-# +---+-----+------+
+```
+
+```Plain
++---+-----+------+
+| id| name|amount|
++---+-----+------+
+|  1|Alice|  1000|
+|  2|  Bob|  2000|
+|  3|Carol|   500|
++---+-----+------+
 ```
 
 ### From an Existing Table
@@ -104,26 +107,47 @@ from clickzetta.zettapark import functions as F
 
 data = [(1,"A",100.0),(2,"A",200.0),(3,"B",300.0),(4,"B",150.0)]
 df = session.create_dataframe(data, schema=["id","category","amount"])
+```
 
-# filter — filter rows
+filter — filter rows
+
+```python
 df.filter(F.col("amount") > 150).show()
+```
+
+select — select columns
 
-# select — select columns
+```python
 df.select("category", "amount").show()
+```
 
-# sort — sort rows
+sort — sort rows
+
+```python
 df.sort("amount", ascending=False).show()
+```
+
+with\_column — add or replace a column
 
-# with_column — add or replace a column
+```python
 df.with_column("amount_tax", F.col("amount") * 1.13).show()
+```
 
-# with_column_renamed — rename a column
+with\_column\_renamed — rename a column
+
+```python
 df.with_column_renamed("amount", "price").show()
+```
+
+drop — drop a column
 
-# drop — drop a column
+```python
 df.drop("id").show()
+```
+
+limit
 
-# limit
+```python
 df.limit(2).show()
 ```
 
@@ -131,8 +155,9 @@ df.limit(2).show()
 
 ## Aggregations
 
+group\_by + agg
+
 ```python
-# group_by + agg
 result = df.group_by("category").agg(
     F.sum("amount").alias("total"),
     F.count("id").alias("cnt"),
@@ -141,12 +166,15 @@ result = df.group_by("category").agg(
     F.min("amount").alias("min_amount")
 )
 result.show()
-# +--------+-----+---+----------+---------+---------+
-# |category|total|cnt|avg_amount|max_amount|min_amount|
-# +--------+-----+---+----------+---------+---------+
-# |       A|  300|  2|       150|      200|      100|
-# |       B|  450|  2|       225|      300|      150|
-# +--------+-----+---+----------+---------+---------+
+```
+
+```Plain
++--------+-----+---+----------+---------+---------+
+|category|total|cnt|avg_amount|max_amount|min_amount|
++--------+-----+---+----------+---------+---------+
+|       A|  300|  2|       150|      200|      100|
+|       B|  450|  2|       225|      300|      150|
++--------+-----+---+----------+---------+---------+
 ```
 
 ---
@@ -156,22 +184,34 @@ result.show()
 ```python
 users  = session.create_dataframe([(1,"Alice"),(2,"Bob"),(3,"Carol")], schema=["id","name"])
 orders = session.create_dataframe([(1,500.0),(1,300.0),(2,800.0)],    schema=["user_id","amount"])
+```
+
+inner join (default)
 
-# inner join (default)
+```python
 users.join(orders, users["id"] == orders["user_id"]).show()
+```
 
-# left join
+left join
+
+```python
 users.join(orders, users["id"] == orders["user_id"], "left").show()
-# +---+-----+-------+------+
-# | id| name|user_id|amount|
-# +---+-----+-------+------+
-# |  1|Alice|      1|   300|
-# |  1|Alice|      1|   500|
-# |  2|  Bob|      2|   800|
-# |  3|Carol|   NULL|  NULL|  ← Carol has no orders, NULL filled
-# +---+-----+-------+------+
-
-# cross join
+```
+
+```Plain
++---+-----+-------+------+
+| id| name|user_id|amount|
++---+-----+-------+------+
+|  1|Alice|      1|   300|
+|  1|Alice|      1|   500|
+|  2|  Bob|      2|   800|
+|  3|Carol|   NULL|  NULL|
++---+-----+-------+------+
+```
+
+cross join
+
+```python
 users.cross_join(orders).show()
 ```
 
@@ -195,24 +235,36 @@ df1.except_(df2).show()     # difference (in df1 but not df2)
 ```python
 data = [(1,"Alice",100.0),(2,None,200.0),(3,"Carol",None)]
 df = session.create_dataframe(data, schema=["id","name","amount"])
+```
 
-# Drop rows containing NULL
+Drop rows containing NULL
+
+```python
 df.dropna().show()
-# +---+-----+------+
-# | id| name|amount|
-# +---+-----+------+
-# |  1|Alice|   100|
-# +---+-----+------+
+```
 
-# Fill NULL values
+```Plain
++---+-----+------+
+| id| name|amount|
++---+-----+------+
+|  1|Alice|   100|
++---+-----+------+
+```
+
+Fill NULL values
+
+```python
 df.fillna({"name": "Unknown", "amount": 0.0}).show()
-# +---+-------+------+
-# | id|   name|amount|
-# +---+-------+------+
-# |  1|  Alice|   100|
-# |  2|Unknown|   200|
-# |  3|  Carol|     0|
-# +---+-------+------+
+```
+
+```Plain
++---+-------+------+
+| id|   name|amount|
++---+-------+------+
+|  1|  Alice|   100|
+|  2|Unknown|   200|
+|  3|  Carol|     0|
++---+-------+------+
 ```
 
 ---
@@ -224,11 +276,17 @@ from clickzetta.zettapark.window import Window
 
 data = [(1,"A",100),(2,"A",200),(3,"B",300),(4,"B",150),(5,"A",50)]
 df = session.create_dataframe(data, schema=["id","category","amount"])
+```
 
-# Rank within group
+Rank within group
+
+```python
 w_rank = Window.partition_by("category").order_by(F.col("amount").desc())
+```
+
+Running sum within group
 
-# Running sum within group
+```python
 w_sum = Window.partition_by("category").order_by("amount")
 
 result = df \
@@ -236,15 +294,18 @@ result = df \
     .with_column("running_total", F.sum("amount").over(w_sum))
 
 result.show()
-# +---+--------+------+----+-------------+
-# | id|category|amount|rank|running_total|
-# +---+--------+------+----+-------------+
-# |  5|       A|    50|   3|           50|
-# |  1|       A|   100|   2|          150|
-# |  2|       A|   200|   1|          350|
-# |  4|       B|   150|   2|          150|
-# |  3|       B|   300|   1|          450|
-# +---+--------+------+----+-------------+
+```
+
+```Plain
++---+--------+------+----+-------------+
+| id|category|amount|rank|running_total|
++---+--------+------+----+-------------+
+|  5|       A|    50|   3|           50|
+|  1|       A|   100|   2|          150|
+|  2|       A|   200|   1|          350|
+|  4|       B|   150|   2|          150|
+|  3|       B|   300|   1|          450|
++---+--------+------+----+-------------+
 ```
 
 ---
@@ -255,11 +316,17 @@ result.show()
 
 ```python
 df = session.create_dataframe([(1,"Alice",100.0),(2,"Bob",200.0)], schema=["id","name","amount"])
+```
+
+Overwrite (creates the table if it doesn't exist)
 
-# Overwrite (creates the table if it doesn't exist)
+```python
 df.write.save_as_table("my_table", mode="overwrite")
+```
 
-# Append
+Append
+
+```python
 df.write.save_as_table("my_table", mode="append")
 ```
 
@@ -286,8 +353,11 @@ print(pdf.head())
 
 ```python
 df.filter(F.col("amount") > 100).create_or_replace_temp_view("high_value_orders")
+```
+
+Query the temporary view with SQL
 
-# Query the temporary view with SQL
+```python
 session.sql("SELECT * FROM high_value_orders").show()
 ```
 
@@ -299,8 +369,9 @@ df.filter(F.col("amount") > 100).create_or_replace_view("v_high_value_orders")
 
 ### Dynamic Table (auto incremental refresh)
 
+Define transformation logic on a source table; the system auto-refreshes incrementally
+
 ```python
-# Define transformation logic on a source table; the system auto-refreshes incrementally
 source_df = session.table("raw_orders").filter(F.col("status") == "paid")
 
 source_df.create_or_replace_dynamic_table(
@@ -323,11 +394,14 @@ df.filter(F.col("amount") > 150) \
   .group_by("category") \
   .agg(F.sum("amount").alias("total")) \
   .explain()
+```
+
+Output:
 
-# Output:
-# SELECT `category`, sum(`amount`) AS `total`
-# FROM ( SELECT ... WHERE (`amount` > CAST(150 AS bigint)))
-# GROUP BY `category`
+```Plain
+SELECT `category`, sum(`amount`) AS `total`
+FROM ( SELECT ... WHERE (`amount` > CAST(150 AS bigint)))
+GROUP BY `category`
 ```
 
 ---
@@ -339,4 +413,4 @@ df.filter(F.col("amount") > 150) \
 | [Zettapark Quick Start](zettapark-quick-start.md) | Installation and basic examples |
 | [Python Connector SDK](python_reference/connector.md) | Standard SQL execution interface |
 | [Dynamic Table](dynamic-table.md) | Auto-incrementally refreshed data pipelines |
-| [BulkLoad Batch Import](java_reference/bulkload-upload.md) | High-speed writes for millions of rows |
+| [BulkLoad Batch Import](java_reference/bulkload.md) | High-speed writes for millions of rows |

package/bin/skills/lakehouse-doc-en/references/zettapark-dynamic-table-guide.md

@@ -13,11 +13,11 @@ from clickzetta.zettapark import functions as F
 session = Session.builder.configs({
     "username": "your_username",
     "password": "your_password",
-    "service":  "cn-shanghai-alicloud.api.singdata.com",
+    "service":  "cn-shanghai-alicloud.api.clickzetta.com",
     "instance": "your_instance",
     "workspace": "your_workspace",
     "schema":   "public",
-    "vcluster": "default"
+    "vcluster": "DEFAULT"
 }).create()
 ```
 

package/bin/skills/lakehouse-doc-en/references/zettapark-etl-guide.md

@@ -14,11 +14,11 @@ from clickzetta.zettapark.window import Window
 session = Session.builder.configs({
     "username": "your_username",
     "password": "your_password",
-    "service":  "cn-shanghai-alicloud.api.singdata.com",
+    "service":  "cn-shanghai-alicloud.api.clickzetta.com",
     "instance": "your_instance",
     "workspace": "your_workspace",
     "schema":   "public",
-    "vcluster": "default"
+    "vcluster": "DEFAULT"
 }).create()
 ```
 
@@ -28,8 +28,9 @@ session = Session.builder.configs({
 
 All examples in this guide use the following two tables. Run this setup before proceeding:
 
+Create tables
+
 ```python
-# Create tables
 session.sql("""
     CREATE TABLE IF NOT EXISTS orders (
         order_id   BIGINT,
@@ -49,8 +50,11 @@ session.sql("""
         level   STRING
     )
 """).collect()
+```
+
+Insert test data
 
-# Insert test data
+```python
 session.sql("""
     INSERT INTO orders VALUES
     (1001, 101, 'iPhone',  7999.00, 'paid',      '2024-01-15'),
@@ -80,9 +84,11 @@ Join the orders and users tables, compute per-user spending summaries, and write
 ```python
 orders = session.table("orders")   # order_id, user_id, product, amount, status, order_date
 users  = session.table("users")    # user_id, name, city, level
+```
 
-# Note: when joining tables with a shared column name (user_id),
-# rename it before joining to avoid ambiguity
+Note: when joining tables with a shared column name (user_id), rename it before joining to avoid ambiguity
+
+```python
 paid = orders.filter(F.col("status") == "paid") \
     .select(
         F.col("order_id"),
@@ -101,15 +107,21 @@ result = paid.join(users, paid["o_user_id"] == users["user_id"]) \
     .sort(F.col("total_amount").desc())
 
 result.show()
-# +-------+-----+---------+------+-----------+------------+---------------+
-# |user_id| name|     city| level|order_count|total_amount|last_order_date|
-# +-------+-----+---------+------+-----------+------------+---------------+
-# |    101|Alice|  Beijing|  gold|          2|    22998.00|     2024-01-17|
-# |    102|  Bob| Shanghai|silver|          1|    14999.00|     2024-01-15|
-# |    103|Carol|Guangzhou|bronze|          1|     8999.00|     2024-01-16|
-# +-------+-----+---------+------+-----------+------------+---------------+
-
-# Write to result table
+```
+
+```Plain
++-------+-----+---------+------+-----------+------------+---------------+
+|user_id| name|     city| level|order_count|total_amount|last_order_date|
++-------+-----+---------+------+-----------+------------+---------------+
+|    101|Alice|  Beijing|  gold|          2|    22998.00|     2024-01-17|
+|    102|  Bob| Shanghai|silver|          1|    14999.00|     2024-01-15|
+|    103|Carol|Guangzhou|bronze|          1|     8999.00|     2024-01-16|
++-------+-----+---------+------+-----------+------------+---------------+
+```
+
+Write to result table
+
+```python
 result.write.save_as_table("user_order_summary", mode="overwrite")
 ```
 
@@ -121,11 +133,17 @@ result.write.save_as_table("user_order_summary", mode="overwrite")
 
 ```python
 summary = session.table("user_order_summary")
+```
+
+Rank by spending amount descending
 
-# Rank by spending amount descending
+```python
 w_rank = Window.order_by(F.col("total_amount").desc())
+```
+
+Running total by city
 
-# Running total by city
+```python
 w_city = Window.partition_by("city").order_by(F.col("total_amount").desc())
 
 result = summary \
@@ -134,21 +152,25 @@ result = summary \
     .with_column("running_total",  F.sum("total_amount").over(w_city))
 
 result.show()
-# +-------+-----+------+-----------+------------+----+---------+-------------+
-# |user_id| name| level|order_count|total_amount|rank|city_rank|running_total|
-# +-------+-----+------+-----------+------------+----+---------+-------------+
-# |    101|Alice|  gold|          2|    22998.00|   1|        1|     22998.00|
-# |    102|  Bob|silver|          1|    14999.00|   2|        1|     14999.00|
-# |    103|Carol|bronze|          1|     8999.00|   3|        1|      8999.00|
-# +-------+-----+------+-----------+------------+----+---------+-------------+
+```
+
+```Plain
++-------+-----+------+-----------+------------+----+---------+-------------+
+|user_id| name| level|order_count|total_amount|rank|city_rank|running_total|
++-------+-----+------+-----------+------------+----+---------+-------------+
+|    101|Alice|  gold|          2|    22998.00|   1|        1|     22998.00|
+|    102|  Bob|silver|          1|    14999.00|   2|        1|     14999.00|
+|    103|Carol|bronze|          1|     8999.00|   3|        1|      8999.00|
++-------+-----+------+-----------+------------+----+---------+-------------+
 ```
 
 ---
 
 ## Scenario 3: Create a View for BI
 
+Create a paid orders view with year/month dimensions for BI analysis
+
 ```python
-# Create a paid orders view with year/month dimensions for BI analysis
 orders.filter(F.col("status") == "paid") \
     .select(
         F.col("order_id"),
@@ -159,8 +181,11 @@ orders.filter(F.col("status") == "paid") \
         F.year(F.to_date(F.col("order_date"))).alias("year"),
         F.month(F.to_date(F.col("order_date"))).alias("month"),
     ).create_or_replace_view("v_paid_orders")
+```
 
-# BI tools can query the view directly
+BI tools can query the view directly
+
+```python
 session.table("v_paid_orders").show()
 ```
 
@@ -170,15 +195,19 @@ session.table("v_paid_orders").show()
 
 Process only new data after a given point in time — suitable for scheduled incremental ETL:
 
+Process only new orders from 2024-01-16 onwards
+
 ```python
-# Process only new orders from 2024-01-16 onwards
 cutoff = "2024-01-16"
 new_orders = orders.filter(F.col("order_date") >= cutoff)
 
 print(f"New orders: {new_orders.count()}")
 new_orders.show()
+```
+
+Append new paid orders to the archive table (append mode)
 
-# Append new paid orders to the archive table
+```python
 new_orders.filter(F.col("status") == "paid") \
     .write.save_as_table("paid_orders_archive", mode="append")
 ```
@@ -189,21 +218,28 @@ new_orders.filter(F.col("status") == "paid") \
 
 Check data quality before writing:
 
+Check for NULL values
+
 ```python
-# Check for NULL values
 null_counts = orders.select(
     F.count(F.lit(1)).alias("total"),
     F.sum(F.iff(F.is_null(F.col("amount")), F.lit(1), F.lit(0))).alias("null_amount"),
     F.sum(F.iff(F.is_null(F.col("user_id")), F.lit(1), F.lit(0))).alias("null_user_id"),
 )
 null_counts.show()
+```
+
+Check status distribution
 
-# Check status distribution
+```python
 orders.group_by("status").agg(
     F.count(F.lit(1)).alias("cnt")
 ).sort("cnt", ascending=False).show()
+```
+
+Check for anomalous amounts (negative or excessively large)
 
-# Check for anomalous amounts (negative or excessively large)
+```python
 anomalies = orders.filter(
     (F.col("amount") <= 0) | (F.col("amount") > 100000)
 )
@@ -216,8 +252,9 @@ print(f"Anomalous orders: {anomalies.count()}")
 
 Complex logic can be executed directly with `session.sql()`. The result is still a DataFrame and can continue to be chained:
 
+Execute a complex query with SQL, return a DataFrame for further processing
+
 ```python
-# Execute a complex query with SQL, return a DataFrame for further processing
 df = session.sql("""
     SELECT
         user_id,
@@ -227,8 +264,11 @@ df = session.sql("""
     WHERE status = 'paid'
     GROUP BY user_id, DATE_TRUNC('month', TO_DATE(order_date))
 """)
+```
 
-# Continue processing with the DataFrame API
+Continue processing with the DataFrame API
+
+```python
 w = Window.partition_by("user_id").order_by("month")
 df.with_column("cumulative", F.sum("monthly_amount").over(w)).show()
 ```

package/bin/skills/lakehouse-doc-en/references/zettapark-feature-engineering.md

@@ -14,11 +14,11 @@ from clickzetta.zettapark.window import Window
 session = Session.builder.configs({
     "username": "your_username",
     "password": "your_password",
-    "service":  "cn-shanghai-alicloud.api.singdata.com",
+    "service":  "cn-shanghai-alicloud.api.clickzetta.com",
     "instance": "your_instance",
     "workspace": "your_workspace",
     "schema":   "public",
-    "vcluster": "default"
+    "vcluster": "DEFAULT"
 }).create()
 ```