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

package/bin/skills/{clickzetta-sql-syntax-guide → clickzetta-sql-migration}/references/dql-reference.md

@@ -1,10 +1,10 @@
-# DQL 完整语法参考
+# DQL Complete Syntax Reference
 
-> 基于 ClickZetta Lakehouse 产品文档整理，含与 Snowflake / Spark SQL 的差异标注
+> Based on ClickZetta Lakehouse product documentation, with Snowflake / Spark SQL difference annotations
 
 ---
 
-## SELECT 基本语法
+## SELECT Basic Syntax
 
 ```sql
 [WITH cte_name AS (SELECT ...) [, ...]]
@@ -23,12 +23,12 @@ FROM table_reference
 
 ---
 
-## SELECT 扩展
+## SELECT Extensions
 
-### EXCEPT（排除列）
+### EXCEPT (Exclude Columns)
 
 ```sql
--- 排除指定列（ClickZetta 特有，Snowflake/Spark 也支持）
+-- Exclude specified columns (ClickZetta-specific, Snowflake/Spark also support)
 SELECT * EXCEPT(password, secret_key) FROM users;
 SELECT * EXCEPT(meta, tags) FROM orders;
 ```
@@ -37,23 +37,23 @@ SELECT * EXCEPT(meta, tags) FROM orders;
 
 ```sql
 SELECT DISTINCT customer_id FROM orders;
-SELECT ALL customer_id FROM orders;    -- 默认，保留重复
+SELECT ALL customer_id FROM orders;    -- default, keeps duplicates
 ```
 
 ### LIMIT / OFFSET
 
 ```sql
 SELECT * FROM orders LIMIT 100;
-SELECT * FROM orders LIMIT 100 OFFSET 200;   -- 跳过前200行
+SELECT * FROM orders LIMIT 100 OFFSET 200;   -- skip first 200 rows
 
--- ⚠️ ClickZetta 不支持 Snowflake 的 TOP N 语法
+-- ⚠️ ClickZetta does not support Snowflake's TOP N syntax
 -- Snowflake: SELECT TOP 10 * FROM orders;
 -- ClickZetta: SELECT * FROM orders LIMIT 10;
 ```
 
 ---
 
-## FROM 子句
+## FROM Clause
 
 ### JOIN
 
@@ -72,97 +72,97 @@ SELECT * FROM a CROSS JOIN b;
 -- SELF JOIN
 SELECT a.id, b.id FROM orders a JOIN orders b ON a.customer_id = b.customer_id;
 
--- USING 语法
+-- USING syntax
 SELECT * FROM orders JOIN customers USING (customer_id);
 
 -- NATURAL JOIN
 SELECT * FROM orders NATURAL JOIN customers;
 
--- SEMI JOIN（用 EXISTS 或 IN 实现）
+-- SEMI JOIN (implemented with EXISTS or IN)
 SELECT * FROM orders WHERE EXISTS (
     SELECT 1 FROM customers WHERE customers.id = orders.customer_id
 );
 
--- ANTI JOIN（用 NOT EXISTS 或 NOT IN 实现）
+-- ANTI JOIN (implemented with NOT EXISTS or NOT IN)
 SELECT * FROM orders WHERE NOT EXISTS (
     SELECT 1 FROM customers WHERE customers.id = orders.customer_id
 );
 ```
 
-**与 Snowflake 差异：**
-- Snowflake 支持 `ASOF JOIN`（时序连接）；ClickZetta 不支持
-- Snowflake 支持 `MATCH_RECOGNIZE`；ClickZetta 不支持
+**Differences from Snowflake:**
+- Snowflake supports `ASOF JOIN` (time-series join); ClickZetta does not
+- Snowflake supports `MATCH_RECOGNIZE`; ClickZetta does not
 
-### LATERAL VIEW（展开数组/MAP）
+### LATERAL VIEW (Expand Arrays/MAPs)
 
 ```sql
--- EXPLODE 展开数组
+-- EXPLODE to expand array
 SELECT e.id, s.skill
 FROM employees e
 LATERAL VIEW EXPLODE(e.skills) s AS skill;
 
--- POSEXPLODE 带位置索引
+-- POSEXPLODE with position index
 SELECT e.id, ps.pos, ps.skill
 FROM employees e
 LATERAL VIEW POSEXPLODE(e.skills) ps AS pos, skill;
 
--- OUTER（空数组也保留行）
+-- OUTER (preserves rows even for empty arrays)
 SELECT e.id, s.skill
 FROM employees e
 LATERAL VIEW OUTER EXPLODE(e.skills) s AS skill;
 
--- 展开 MAP
+-- Expand MAP
 SELECT id, k, v
 FROM t
 LATERAL VIEW EXPLODE(meta_map) m AS k, v;
 ```
 
-**与 Snowflake 差异：**
-- Snowflake 用 `LATERAL FLATTEN(input => arr)`；ClickZetta 用 `LATERAL VIEW EXPLODE(arr)`
-- Snowflake `f.value::STRING`；ClickZetta 直接用列别名
+**Differences from Snowflake:**
+- Snowflake uses `LATERAL FLATTEN(input => arr)`; ClickZetta uses `LATERAL VIEW EXPLODE(arr)`
+- Snowflake `f.value::STRING`; ClickZetta uses column alias directly
 
-**与 Spark SQL 差异：**
-- 语法完全相同（ClickZetta 兼容 Hive/Spark 风格）
+**Differences from Spark SQL:**
+- Syntax is identical (ClickZetta is compatible with Hive/Spark style)
 
 ### TABLESAMPLE
 
 ```sql
--- SYSTEM 模式：按百分比采样（文件级）
+-- SYSTEM mode: sample by percentage (file-level)
 SELECT * FROM orders TABLESAMPLE (10 PERCENT);
 
--- ROW 模式：按行数采样
+-- ROW mode: sample by row count
 SELECT * FROM orders TABLESAMPLE (100 ROWS);
 ```
 
-### SEQUENCE（生成序列）
+### SEQUENCE (Generate Sequences)
 
 ```sql
--- 生成整数序列（返回 ARRAY）
+-- Generate integer sequence (returns ARRAY)
 SELECT SEQUENCE(1, 5);                -- [1,2,3,4,5]
 SELECT SEQUENCE(0, 10, 2);            -- [0,2,4,6,8,10]
 
--- 展开为行（ClickZetta 用 EXPLODE(SEQUENCE(...))，无 GENERATE_SERIES）
-SELECT EXPLODE(SEQUENCE(1, 5)) AS n;  -- 5行：1,2,3,4,5
+-- Expand to rows (ClickZetta uses EXPLODE(SEQUENCE(...)), no GENERATE_SERIES)
+SELECT EXPLODE(SEQUENCE(1, 5)) AS n;  -- 5 rows: 1,2,3,4,5
 ```
 
-### EXPLODE 直接在 SELECT 中使用
+### EXPLODE Directly in SELECT
 
 ```sql
--- Spark 风格：EXPLODE 直接在 SELECT 中
+-- Spark style: EXPLODE directly in SELECT
 SELECT EXPLODE(ARRAY(1, 2, 3)) AS val;
 SELECT POSEXPLODE(ARRAY('a', 'b', 'c')) AS (pos, val);
 
--- 等价的 LATERAL VIEW 写法
+-- Equivalent LATERAL VIEW syntax
 SELECT val FROM (SELECT ARRAY(1,2,3) AS arr) t
 LATERAL VIEW EXPLODE(arr) lv AS val;
 ```
 
 
 
-## WHERE 子句
+## WHERE Clause
 
 ```sql
--- 基本条件
+-- Basic conditions
 WHERE amount > 100 AND status = 'completed'
 WHERE status IN ('pending', 'processing')
 WHERE status NOT IN ('cancelled', 'refunded')
@@ -172,43 +172,43 @@ WHERE name NOT LIKE '%test%'
 WHERE tags IS NULL
 WHERE tags IS NOT NULL
 
--- 正则匹配
+-- Regex matching
 WHERE name RLIKE '^[A-Z].*'
-WHERE name REGEXP '^[A-Z].*'    -- 同 RLIKE
+WHERE name REGEXP '^[A-Z].*'    -- same as RLIKE
 
--- 子查询
+-- Subquery
 WHERE customer_id IN (SELECT id FROM customers WHERE tier = 'VIP')
 WHERE EXISTS (SELECT 1 FROM orders WHERE orders.customer_id = customers.id)
 ```
 
-**与 Snowflake 差异：**
-- Snowflake `ILIKE`（不区分大小写 LIKE）→ ClickZetta `ILIKE` ✅ 同样支持
-- Snowflake `RLIKE` → ClickZetta 同样支持 `RLIKE` / `REGEXP`
+**Differences from Snowflake:**
+- Snowflake `ILIKE` (case-insensitive LIKE) → ClickZetta `ILIKE` ✅ also supported
+- Snowflake `RLIKE` → ClickZetta also supports `RLIKE` / `REGEXP`
 
 ---
 
-## GROUP BY 扩展
+## GROUP BY Extensions
 
 ```sql
--- 基本分组
+-- Basic grouping
 SELECT region, SUM(amount) FROM orders GROUP BY region;
-SELECT region, SUM(amount) FROM orders GROUP BY 1;    -- 按位置
+SELECT region, SUM(amount) FROM orders GROUP BY 1;    -- by position
 
--- GROUP BY ALL（自动推断所有非聚合列）
+-- GROUP BY ALL (auto-infer all non-aggregate columns)
 SELECT year, month, region, SUM(amount) FROM orders GROUP BY ALL;
 
--- GROUPING SETS（多维分组）
+-- GROUPING SETS (multi-dimensional grouping)
 SELECT region, product, SUM(sales)
 FROM orders
 GROUP BY GROUPING SETS ((region, product), (region), (product), ());
 
--- ROLLUP（层级汇总）
+-- ROLLUP (hierarchical subtotals)
 SELECT region, city, SUM(amount)
 FROM orders
 GROUP BY ROLLUP (region, city);
--- 等价于 GROUPING SETS ((region, city), (region), ())
+-- equivalent to GROUPING SETS ((region, city), (region), ())
 
--- CUBE（全组合汇总）
+-- CUBE (all-combination subtotals)
 SELECT region, product, channel, SUM(amount)
 FROM orders
 GROUP BY CUBE (region, product, channel);
@@ -220,9 +220,9 @@ GROUP BY customer_id
 HAVING total > 10000;
 ```
 
-**与 Snowflake 差异：**
-- `GROUP BY ALL` 两者都支持
-- `GROUPING SETS / ROLLUP / CUBE` 两者都支持
+**Differences from Snowflake:**
+- `GROUP BY ALL` both support
+- `GROUPING SETS / ROLLUP / CUBE` both support
 
 ---
 
@@ -232,15 +232,15 @@ HAVING total > 10000;
 SELECT * FROM orders ORDER BY amount DESC;
 SELECT * FROM orders ORDER BY amount DESC NULLS LAST;
 SELECT * FROM orders ORDER BY amount ASC NULLS FIRST;
-SELECT * FROM orders ORDER BY 1 DESC, 2 ASC;    -- 按位置
+SELECT * FROM orders ORDER BY 1 DESC, 2 ASC;    -- by position
 ```
 
 ---
 
-## CTE（公用表表达式）
+## CTE (Common Table Expressions)
 
 ```sql
--- 基本 CTE
+-- Basic CTE
 WITH
     monthly AS (
         SELECT DATE_TRUNC('month', created_at) AS month, SUM(amount) AS total
@@ -251,8 +251,8 @@ WITH
     )
 SELECT * FROM ranked WHERE rnk <= 5;
 
--- ⚠️ 递归 CTE（ClickZetta 不支持）
--- Snowflake/Databricks/Spark SQL 支持：
+-- ⚠️ Recursive CTE (ClickZetta does NOT support)
+-- Snowflake/Databricks/Spark SQL support:
 WITH RECURSIVE org_tree AS (
     SELECT id, name, parent_id, 0 AS level
     FROM employees WHERE parent_id IS NULL
@@ -262,8 +262,8 @@ WITH RECURSIVE org_tree AS (
 )
 SELECT * FROM org_tree ORDER BY level, id;
 
--- ClickZetta 替代方案：用 Python/ZettaPark 迭代实现
--- 或用多层 CTE 模拟有限深度的递归
+-- ClickZetta alternative: use Python/ZettaPark for iteration
+-- Or use multi-level CTEs to simulate limited-depth recursion
 WITH
     level0 AS (SELECT id, name, parent_id, 0 AS level FROM employees WHERE parent_id IS NULL),
     level1 AS (SELECT e.id, e.name, e.parent_id, 1 AS level FROM employees e JOIN level0 t ON e.parent_id = t.id),
@@ -271,24 +271,24 @@ WITH
 SELECT * FROM level0 UNION ALL SELECT * FROM level1 UNION ALL SELECT * FROM level2;
 ```
 
-**与 Snowflake 差异：**
-- Snowflake 支持 `WITH RECURSIVE`；ClickZetta ❌ 不支持递归 CTE
-- ClickZetta 仅支持非递归 CTE（普通 WITH 子句）
-- 递归场景需用 Python/ZettaPark 迭代实现，或用多层 CTE 模拟有限深度
+**Differences from Snowflake:**
+- Snowflake supports `WITH RECURSIVE`; ClickZetta ❌ does not support recursive CTE
+- ClickZetta only supports non-recursive CTE (regular WITH clause)
+- For recursive scenarios, use Python/ZettaPark iteration, or multi-level CTEs to simulate limited depth
 
 ---
 
-## 窗口函数
+## Window Functions
 
 ```sql
--- 基本语法
+-- Basic syntax
 function_name() OVER (
     [PARTITION BY col1, col2]
     [ORDER BY col3 [ASC|DESC]]
     [ROWS|RANGE BETWEEN start AND end]
 )
 
--- 排名函数
+-- Ranking functions
 ROW_NUMBER() OVER (PARTITION BY dept ORDER BY salary DESC)
 RANK() OVER (ORDER BY score DESC)
 DENSE_RANK() OVER (ORDER BY score DESC)
@@ -296,34 +296,34 @@ NTILE(4) OVER (ORDER BY amount)
 PERCENT_RANK() OVER (ORDER BY amount)
 CUME_DIST() OVER (ORDER BY amount)
 
--- 聚合窗口
+-- Aggregate windows
 SUM(amount) OVER (PARTITION BY customer_id)
 AVG(amount) OVER (PARTITION BY dept ORDER BY date
                   ROWS BETWEEN 6 PRECEDING AND CURRENT ROW)
 COUNT(*) OVER (PARTITION BY region)
 MAX(amount) OVER (ORDER BY date ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
 
--- 分析函数
-LAG(amount, 1, 0) OVER (ORDER BY date)          -- 前1行，默认0
-LEAD(amount, 1) OVER (ORDER BY date)             -- 后1行
+-- Analytic functions
+LAG(amount, 1, 0) OVER (ORDER BY date)          -- 1 row before, default 0
+LEAD(amount, 1) OVER (ORDER BY date)             -- 1 row after
 FIRST_VALUE(amount) OVER (ORDER BY date)
 LAST_VALUE(amount) OVER (ORDER BY date
     ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)
 NTH_VALUE(amount, 3) OVER (ORDER BY date)
 
 -- Window Frame
-ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW    -- 从头到当前行
-ROWS BETWEEN 3 PRECEDING AND 3 FOLLOWING            -- 前后3行
-RANGE BETWEEN INTERVAL 7 DAY PRECEDING AND CURRENT ROW  -- 7天内
-ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING    -- 当前行到末尾
+ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW    -- from start to current row
+ROWS BETWEEN 3 PRECEDING AND 3 FOLLOWING            -- 3 rows before and after
+RANGE BETWEEN INTERVAL 7 DAY PRECEDING AND CURRENT ROW  -- within 7 days
+ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING    -- current row to end
 ```
 
-**与 Snowflake 差异：**
-- ClickZetta 同样支持 `QUALIFY` 直接过滤窗口函数结果：
+**Differences from Snowflake:**
+- ClickZetta also supports `QUALIFY` to directly filter window function results:
   ```sql
-  -- 两者都支持
+  -- Both support
   SELECT * FROM orders QUALIFY ROW_NUMBER() OVER (PARTITION BY cust ORDER BY dt DESC) = 1;
-  -- 子查询写法也可以
+  -- Subquery approach also works
   SELECT * FROM (
       SELECT *, ROW_NUMBER() OVER (PARTITION BY cust ORDER BY dt DESC) AS rn FROM orders
   ) t WHERE rn = 1;
@@ -331,24 +331,24 @@ ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING    -- 当前行到末尾
 
 ---
 
-## 子查询
+## Subqueries
 
 ```sql
--- 标量子查询
+-- Scalar subquery
 SELECT id, (SELECT MAX(amount) FROM orders) AS max_amount FROM orders;
 
--- IN 子查询
+-- IN subquery
 SELECT * FROM orders WHERE customer_id IN (SELECT id FROM customers WHERE tier = 'VIP');
 
--- EXISTS 子查询
+-- EXISTS subquery
 SELECT * FROM customers c
 WHERE EXISTS (SELECT 1 FROM orders o WHERE o.customer_id = c.id);
 
--- 相关子查询
+-- Correlated subquery
 SELECT * FROM orders o
 WHERE amount > (SELECT AVG(amount) FROM orders WHERE customer_id = o.customer_id);
 
--- FROM 子查询（派生表）
+-- FROM subquery (derived table)
 SELECT t.region, t.total FROM (
     SELECT region, SUM(amount) AS total FROM orders GROUP BY region
 ) t WHERE t.total > 100000;
@@ -356,75 +356,75 @@ SELECT t.region, t.total FROM (
 
 ---
 
-## JSON 查询
+## JSON Queries
 
 ```sql
--- 访问 JSON 字段（用 [] 而非 Snowflake 的 :）
+-- Access JSON fields (use [] instead of Snowflake's :)
 SELECT data['address']['city'] AS city FROM users;
 SELECT data['phoneNumbers'][0]['number'] AS phone FROM users;
 SELECT data['scores'][2] AS third_score FROM users;
 
--- 构建 JSON
+-- Build JSON
 SELECT PARSE_JSON('{"name":"Alice","age":30}') AS info;
 SELECT TO_JSON(STRUCT(name, age)) AS json_str FROM users;
 
--- 类型转换
+-- Type conversion
 SELECT CAST(data['age'] AS INT) AS age FROM users;
-SELECT data['amount']::DOUBLE AS amount FROM orders;    -- :: 语法也支持
+SELECT data['amount']::DOUBLE AS amount FROM orders;    -- :: syntax also supported
 
--- JSON 聚合
+-- JSON aggregation
 SELECT customer_id, TO_JSON(COLLECT_LIST(STRUCT(id, amount))) AS orders_json
 FROM orders GROUP BY customer_id;
 ```
 
-**与 Snowflake 差异：**
-- Snowflake `data:key` 冒号语法 → ClickZetta `data['key']` 方括号语法
-- Snowflake `data:key::STRING` → ClickZetta `CAST(data['key'] AS STRING)` 或 `data['key']::STRING`
-- Snowflake `OBJECT_CONSTRUCT(k, v)` → ClickZetta `MAP_AGG(k, v)` 或 `STRUCT(...)` + `TO_JSON`
-- Snowflake `PARSE_JSON` → ClickZetta 相同
+**Differences from Snowflake:**
+- Snowflake `data:key` colon syntax → ClickZetta `data['key']` bracket syntax
+- Snowflake `data:key::STRING` → ClickZetta `CAST(data['key'] AS STRING)` or `data['key']::STRING`
+- Snowflake `OBJECT_CONSTRUCT(k, v)` → ClickZetta `MAP_AGG(k, v)` or `STRUCT(...)` + `TO_JSON`
+- Snowflake `PARSE_JSON` → ClickZetta same
 
 ---
 
-## STRUCT / ARRAY / MAP 操作
+## STRUCT / ARRAY / MAP Operations
 
 ```sql
--- 构建 STRUCT
-SELECT STRUCT(name, age, email) AS user_info FROM users;              -- ✅ 支持（无字段名，默认 col1, col2...）
-SELECT named_struct('name', name, 'age', age, 'email', email) AS user_info FROM users;  -- ✅ 支持（有字段名）
--- ⚠️ SELECT STRUCT(name AS n, age AS a) 不支持 AS 语法（Snowflake/Spark 支持）
+-- Build STRUCT
+SELECT STRUCT(name, age, email) AS user_info FROM users;              -- ✅ supported (no field names, defaults to col1, col2...)
+SELECT named_struct('name', name, 'age', age, 'email', email) AS user_info FROM users;  -- ✅ supported (with field names)
+-- ⚠️ SELECT STRUCT(name AS n, age AS a) does not support AS syntax (Snowflake/Spark support it)
 
--- 构建 ARRAY / MAP
+-- Build ARRAY / MAP
 SELECT ARRAY(1, 2, 3) AS nums;
 SELECT MAP('k1', 1, 'k2', 2) AS m;
 
--- 访问
-SELECT address.city FROM users;                    -- STRUCT 字段
-SELECT skills[0] FROM employees;                   -- ARRAY 索引（0-based）
-SELECT meta_map['key'] FROM t;                     -- MAP 访问
+-- Access
+SELECT address.city FROM users;                    -- STRUCT field
+SELECT skills[0] FROM employees;                   -- ARRAY index (0-based)
+SELECT meta_map['key'] FROM t;                     -- MAP access
 
--- 数组函数
+-- Array functions
 SELECT SIZE(skills) AS cnt FROM employees;
 SELECT ARRAY_CONTAINS(skills, 'Python') FROM employees;
 SELECT ARRAY_AGG(order_id) FROM orders GROUP BY customer_id;
-SELECT COLLECT_LIST(order_id) FROM orders GROUP BY customer_id;   -- 同 ARRAY_AGG
-SELECT COLLECT_SET(status) FROM orders GROUP BY customer_id;      -- 去重
+SELECT COLLECT_LIST(order_id) FROM orders GROUP BY customer_id;   -- same as ARRAY_AGG
+SELECT COLLECT_SET(status) FROM orders GROUP BY customer_id;      -- deduplicated
 SELECT SORT_ARRAY(skills) FROM employees;
 SELECT ARRAY_DISTINCT(tags) FROM articles;
 SELECT ARRAY_UNION(a, b) FROM t;
 SELECT ARRAY_INTERSECT(a, b) FROM t;
 SELECT ARRAY_EXCEPT(a, b) FROM t;
-SELECT FLATTEN(nested_array) FROM t;               -- 展平嵌套数组
+SELECT FLATTEN(nested_array) FROM t;               -- flatten nested array
 
--- 高阶函数
+-- Higher-order functions
 SELECT TRANSFORM(skills, x -> UPPER(x)) FROM employees;
 SELECT FILTER(scores, x -> x > 90) FROM students;
--- ⚠️ AGGREGATE(arr, init, (acc,x)->...) 不支持，用 ARRAY_AGG + SUM 替代
--- ⚠️ REDUCE(arr, init, (acc,x)->...) 不支持（Spark 名称）
+-- ⚠️ AGGREGATE(arr, init, (acc,x)->...) not supported, use ARRAY_AGG + SUM instead
+-- ⚠️ REDUCE(arr, init, (acc,x)->...) not supported (Spark name)
 SELECT EXISTS(scores, x -> x > 100) FROM students;
 SELECT FORALL(scores, x -> x >= 0) FROM students;
 SELECT ZIP_WITH(a, b, (x, y) -> x + y) FROM t;
 
--- MAP 函数
+-- MAP functions
 SELECT MAP_KEYS(meta) FROM t;
 SELECT MAP_VALUES(meta) FROM t;
 SELECT MAP_ENTRIES(meta) FROM t;
@@ -433,19 +433,19 @@ SELECT MAP_FILTER(meta, (k, v) -> v > 0) FROM t;
 SELECT MAP_TRANSFORM_VALUES(meta, (k, v) -> v * 2) FROM t;
 ```
 
-**与 Snowflake 差异：**
+**Differences from Snowflake:**
 - Snowflake `ARRAY_SIZE` → ClickZetta `SIZE`
-- Snowflake `ARRAY_CONTAINS(val, arr)` 参数顺序相反 → ClickZetta `ARRAY_CONTAINS(arr, val)`
+- Snowflake `ARRAY_CONTAINS(val, arr)` parameter order reversed → ClickZetta `ARRAY_CONTAINS(arr, val)`
 - Snowflake `OBJECT_KEYS(obj)` → ClickZetta `MAP_KEYS(map)`
-- Snowflake 无高阶函数（TRANSFORM/FILTER）；ClickZetta 支持
+- Snowflake has no higher-order functions (TRANSFORM/FILTER); ClickZetta supports them
 
 ---
 
 ## PIVOT / UNPIVOT
 
 ```sql
--- ClickZetta 不支持原生 PIVOT 语法
--- 用 CASE WHEN 实现行转列
+-- ClickZetta does not support native PIVOT syntax
+-- Use CASE WHEN for row-to-column transformation
 SELECT
     product,
     SUM(CASE WHEN month = 'Jan' THEN amount ELSE 0 END) AS Jan,
@@ -454,7 +454,7 @@ SELECT
 FROM sales
 GROUP BY product;
 
--- UNPIVOT 用 LATERAL VIEW + STACK 实现
+-- UNPIVOT implemented with LATERAL VIEW + STACK
 SELECT id, month, amount
 FROM sales
 LATERAL VIEW STACK(3,
@@ -464,15 +464,15 @@ LATERAL VIEW STACK(3,
 ) t AS month, amount;
 ```
 
-**与 Snowflake 差异：**
-- Snowflake 原生支持 `PIVOT` / `UNPIVOT` 语法；ClickZetta 不支持，需手动实现
+**Differences from Snowflake:**
+- Snowflake natively supports `PIVOT` / `UNPIVOT` syntax; ClickZetta does not, requires manual implementation
 
 ---
 
-## SET 操作
+## SET Operations
 
 ```sql
--- ClickZetta 支持 UNION / UNION ALL / INTERSECT / EXCEPT 集合操作
+-- ClickZetta supports UNION / UNION ALL / INTERSECT / EXCEPT set operations
 SELECT id FROM orders_2023
 UNION ALL
 SELECT id FROM orders_2024;
@@ -492,13 +492,13 @@ SELECT id FROM orders_2024;
 
 ---
 
-## HINTS（查询提示）
+## HINTS (Query Hints)
 
 ```sql
--- MAPJOIN（强制广播小表）
+-- MAPJOIN (force broadcast small table)
 SELECT /*+ MAPJOIN(small_table) */ *
 FROM large_table l JOIN small_table s ON l.id = s.id;
 
--- 向量索引探索因子
+-- Vector index search factor
 SET cz.vector.index.search.ef = 128;
 ```