@clickzetta/cz-cli-darwin-x64 0.3.1

package/bin/skills/lakehouse-doc/references/sql_functions/scalar_functions/hash_functions/murmurhash.md

@@ -0,0 +1,36 @@
+### MURMURHASH 哈希函数
+
+#### 功能描述
+`murmurhash3_32` 和 `murmurhash3_64` 函数使用 MurmurHash3 算法计算给定表达式的哈希值。MurmurHash3 是一种非加密哈希函数，适用于分布式系统中的哈希计算，具有良好的散列性和性能。
+
+#### 参数说明
+- `expr`：基础数据类型，可以是字符串、整数、浮点数等。
+
+#### 返回结果
+- `murmurhash3_32`：返回一个整数（int），表示 32 位哈希值。
+- `murmurhash3_64`：返回一个长整数（bigint），表示 64 位哈希值。
+
+#### 使用示例
+1. 计算字符串的 32 位哈希值：
+   ```sql
+   SELECT murmurhash3_32('hello');
+   -- 结果：613153351
+   ```
+2. 计算字符串的 64 位哈希值：
+   ```sql
+   SELECT murmurhash3_64('hello');
+   -- 结果：-8014657081559513573
+   ```
+3. 计算不同字符串的哈希值并比较：
+   ```sql
+   SELECT murmurhash3_32('world'), murmurhash3_64('world');
+   -- 结果：-74040069  -5394866185914414384
+   ```
+4. 计算数字类型的哈希值：
+   ```sql
+   SELECT murmurhash3_32(123), murmurhash3_64(123);
+   -- 结果：941089142 5808450433748234714
+   ```
+
+
+通过以上示例，您可以看到如何使用 MURMURHASH 哈希函数计算不同类型的数据。这些函数在数据分布、负载均衡等场景中非常有用，可以帮助您快速生成数据的哈希值。

package/bin/skills/lakehouse-doc/references/sql_functions/scalar_functions/high_order_functions/array_sort_by_key.md

@@ -0,0 +1,42 @@
+函数名称：ARRAY_SORT_BY_KEY
+
+功能描述：
+ARRAY_SORT_BY_KEY 函数用于对数组进行排序。根据提供的 lambda 表达式，该函数可以依据数组元素的某个属性进行排序。
+
+参数说明：
+* array：待排序的数组，类型为 `array<T>`，其中 T 可以是任意支持排序的数据类型。
+* `e -> key`：一个 lambda 表达式，用于从数组元素 `e` 中提取排序依据的键值。该表达式应当返回一个可排序的数据类型。
+
+返回值：
+返回一个新的、已根据指定键值排序的数组，类型为 `array<T>`。
+
+使用示例：
+```sql
+-- 示例 1: 对日期数组按照月份进行排序
+SELECT ARRAY_SORT_BY_KEY(
+  ARRAY(
+    DATE '2023-10-10',
+    DATE '2021-01-10',
+    DATE '2022-03-10',
+    DATE '2022-02-10',
+    DATE '2020-09-10',
+    DATE '2023-11-10'
+  ),
+  x -> MONTH(x)
+);
+-- 结果：[DATE '2021-01-10', DATE '2022-02-10', DATE '2022-03-10', DATE '2020-09-10', DATE '2023-10-10', DATE '2023-11-10']
+
+-- 示例 2: 对字符串数组按照字符串长度进行排序
+SELECT ARRAY_SORT_BY_KEY(
+  ARRAY(
+    'apple',
+    'banana',
+    'cherry',
+    'date'
+  ),
+  x -> LENGTH(x)
+);
+-- 结果：['date', 'apple', 'banana', 'cherry']
+
+
+

package/bin/skills/lakehouse-doc/references/sql_functions/scalar_functions/high_order_functions/element_at.md

@@ -0,0 +1,59 @@
+## ELEMENT_AT 函数
+
+### 功能描述
+
+`ELEMENT_AT` 函数用于从数组或映射（Map）中提取指定位置或键的元素。它支持两种用法：从数组中按索引提取元素，以及从映射中按键提取值。
+
+## 语法
+
+### 从数组中提取元素
+
+```sql
+ELEMENT_AT(arrayExpr, index)
+```
+
+### 从映射中提取值
+
+```sql
+ELEMENT_AT(mapExpr, key)
+```
+
+## 参数
+
+* `array`：一个数组表达式，表示需要从中提取元素的数组。
+* `index`：一个整数表达式，表示数组中元素的索引位置。索引从 1 开始，支持负数（从数组末尾向前计数）。
+* `map`：一个映射表达式，表示需要从中提取值的映射。
+* `key`：一个与映射键类型匹配的表达式，用于指定需要提取的键。
+
+## 返回值
+
+* **从数组中提取元素**：
+  * 返回值类型与数组元素的类型一致。
+  * 如果 `abs(index)` 超出数组长度范围，将引发错误（除非使用 `TRY_ELEMENT_AT` 函数）。
+  * 如果 `index` 为负数，则从数组末尾向前计数。
+* **从映射中提取值**：
+  * 如果键存在于映射中，返回对应的值；否则返回 `NULL`。
+
+## 示例
+
+### 示例 1：从数组中提取元素
+
+```sql
+SELECT ELEMENT_AT(ARRAY[1, 2, 3], 2);
++--------------------------+
+| ELEMENT_AT([1, 2, 3], 2) |
++--------------------------+
+| 2                        |
++--------------------------+
+```
+
+### 示例 2：使用负索引从数组中提取元素
+
+```sql
+SELECT ELEMENT_AT(ARRAY[1, 2, 3], -1);
++---------------------------+
+| ELEMENT_AT([1, 2, 3], -1) |
++---------------------------+
+| 3                         |
++---------------------------+
+```

package/bin/skills/lakehouse-doc/references/sql_functions/scalar_functions/high_order_functions/exists.md

@@ -0,0 +1,48 @@
+### EXISTS 函数
+
+#### 功能描述
+EXISTS 函数用于判断指定数组中是否存在满足给定条件的元素。通过传入一个 lambda 表达式，可以对数组中的每个元素进行判断。如果至少有一个元素满足条件，函数返回 `true`，否则返回 `false`。
+
+#### 参数说明
+* array: `array<T>` 类型，表示待判断的数组。
+* x -> expr: 单参数形式的 lambda 表达式，x 对应 array 中的元素；expr 需要返回 boolean 类型，表示判断条件。
+
+#### 返回类型
+返回一个 `boolean` 类型的值。
+
+#### 使用示例
+1. 判断数组中是否存在小于等于 3 的元素：
+<= 0);
+```
+结果：
+```
+false
+```
+
+4. 判断数组中是否存在至少一个空值（null）：
+```sql
+SELECT EXISTS(array(1, null, 3), x -> x is null);
+结果：
+```
+true
+```
+
+2. 判断数组中是否存在偶数：
+```sql
+SELECT EXISTS(array(1, 2, 3, 4), x -> x % 2 = 0);
+```
+结果：
+```
+true
+```
+
+3. 判断数组中是否存在负数：
+```sql
+SELECT EXISTS(array(1, 2, 3, 4), x -> x < 0);
+```
+结果：
+```
+false
+```
+
+通过以上示例，您可以看到 EXISTS 函数在不同场景下的应用。使用 EXISTS 函数可以方便地对数组中的元素进行条件判断，从而实现更灵活的数据处理。

package/bin/skills/lakehouse-doc/references/sql_functions/scalar_functions/high_order_functions/filter.md

@@ -0,0 +1,37 @@
+### FILTER 函数
+
+#### 功能描述
+FILTER 函数用于根据给定的 lambda 表达式筛选数组（array）中的元素。该函数支持两种形式的 lambda 表达式：单参数形式和双参数形式（包含元素下标）。
+
+#### 参数说明
+- `array`: 输入的数组，类型为 `array<T>`。
+- `x -> expr`: 单参数形式的 lambda 表达式，其中 `x` 代表数组中的元素，`expr` 需要返回布尔值（true 或 false）。
+- `(x, i) -> expr`: 双参数形式的 lambda 表达式，其中 `x` 代表数组中的元素，`i` 代表元素的下标（从 0 开始计数），`expr` 需要返回布尔值（true 或 false）。
+
+#### 返回类型
+返回一个新的数组，类型为 `array<T>`，包含满足 lambda 表达式的元素。
+
+#### 使用示例
+1. 筛选出数组中的奇数元素：
+   ```sql
+   SELECT filter(array(2, 1, 3, 5, 4), x -> x % 2 != 0);
+   -- 结果：[1, 3, 5]
+   ```
+2. 选取数组中下标小于等于 2 的元素：
+   <= 2);
+   -- 结果：[4, 2, 6]
+   ```
+3. 过滤出数组中大于等于 10 的元素：
+   ```sql
+   SELECT filter(array(10, 15, 20, 25, 30), x ->
+3. 获取数组中下标为奇数的元素：
+   ```sql
+   SELECT filter(array(1, 2, 3, 4, 5, 6), (x, i) -> i % 2 = 0);
+   -- 结果：[1, 3, 5]
+   ```
+
+#### 注意事项
+- 确保 lambda 表达式中的 `expr` 返回值是布尔类型。
+- 当使用双参数形式的 lambda 表达式时，`i` 的取值范围是从 0 到数组长度减 1。
+
+通过使用 FILTER 函数，您可以轻松地对数组进行条件筛选，从而更高效地处理数据。

package/bin/skills/lakehouse-doc/references/sql_functions/scalar_functions/high_order_functions/forall.md

@@ -0,0 +1,68 @@
+### FORALL 函数
+
+#### 简介
+FORALL 函数用于判断数组中的所有元素是否满足指定的条件。该函数接受一个数组和一个单参数的 lambda 表达式作为输入，并返回一个布尔值结果。
+
+#### 语法
+``` sql
+FORALL(array, x -> expr)
+```
+
+#### 参数说明
+- `array`: 输入的数组，类型为 `array<T>`。
+- `x -> expr`: 单参数形式的 lambda 表达式，其中 `x` 对应数组中的元素，`expr` 是需要返回布尔值的表达式。
+
+#### 返回结果
+- 返回一个布尔值，表示数组中的所有元素是否满足 lambda 表达式指定的条件。
+
+#### 使用示例
+
+1. 判断数组中的所有元素是否小于等于 3：
+   ``` sql
+   SELECT FORALL(array(1, 2, 3, 4, 5), x -> x <= 3) AS result;
+   ```
+   结果：
+   ```
+   result
+   -------
+   false
+   ```
+
+2. 判断数组中的所有元素是否大于 10：
+   ``` sql
+   SELECT FORALL(array(1, 20, 30, 4), x -> x > 10) AS result;
+   ```
+   结果：
+   ```
+   result
+   -------
+   false
+   ```
+
+3. 判断包含空值的数组中的所有非空元素是否小于等于 3：
+   ``` sql
+   SELECT FORALL(array(1, null, 3), x -> IF(x IS NOT NULL, x <= 3, true)) AS result;
+   ```
+   结果：
+   ```
+   result
+   -------
+   true
+   ```
+
+4. 判断数组中的所有偶数元素是否大于等于 2：
+   ``` sql
+   SELECT FORALL(array(1, 2, 3, 4, 6), x -> MOD(x, 2) = 0 AND x >= 2) AS result;
+   ```
+   结果：
+   ```
+   result
+   -------
+   false
+   ```
+
+#### 注意事项
+- 当数组为空时，FORALL 函数将返回 `NULL` 值。
+- 当 lambda 表达式中的条件不满足所有元素时，函数返回 `false`。
+- 当 lambda 表达式中的条件满足所有元素时，函数返回 `true`。
+

package/bin/skills/lakehouse-doc/references/sql_functions/scalar_functions/high_order_functions/high_order_functions.md

@@ -0,0 +1,34 @@
+### 高阶函数
+高阶函数是那些接受一个或多个 lambda 函数作为参数的函数。在 SQL 语言中，lambda 函数通常用于处理数组、映射等复杂数据类型，以及在子查询中进行计算。
+
+#### Lambda 函数语法
+Lambda 函数的语法格式为 `arg -> expr` 或者 `(arg1, arg2) -> expr`：
+1. `->` 左侧为参数列表，可以表示数组中的元素，也可以表示映射中的键值对。参数绑定的具体含义取决于高阶函数的语义。
+2. `->` 右侧为 lambda 函数的计算体，即对形参的计算。在表达式 `expr` 中，可以引用外部查询或子查询中的列名。
+
+#### 使用示例
+1. 数组元素处理：
+``` sql
+SELECT transform(array(1, 2, 3), x -> x + 1);
+-- 结果：[2, 3, 4]
+```
+上述示例中，我们对数组 `[1, 2, 3]` 中的每个元素 `x` 应用 lambda 函数 `x -> x + 1`，得到新数组 `[2, 3, 4]`。
+
+2. 映射元素处理：
+``` sql
+SELECT transform(map('a', 1, 'b', 2), (k, v) -> k || ' : ' || v);
+-- 结果：{'a' : 'a : 1', 'b' : 'b : 2'}
+```
+在这个例子中，我们对映射 `{'a' : 1, 'b' : 2}` 中的每个键值对 `(k, v)` 应用 lambda 函数 `(k, v) -> k || ' : ' || v`，得到新的映射 `{'a' : 'a : 1', 'b' : 'b : 2'}`。
+
+3. 捕获外部列：
+``` sql
+SELECT transform(array(1, 2, 3), x -> x + a) FROM (SELECT 100 AS a) AS sub;
+-- 结果：[101, 102, 103]
+```
+在这个例子中，我们从子查询中捕获列 `a` 的值，并将其与数组 `[1, 2, 3]` 中的元素 `x` 相加，得到新数组 `[101, 102, 103]`。
+
+#### 注意事项
+1. Lambda 函数的参数列表应与高阶函数期望的参数类型和数量相匹配。
+2. 在 lambda 函数中，可以引用外部查询或子查询中的列名，但需确保其可读性和正确性。
+3. 高阶函数的具体用法和语义因函数而异，使用前请仔细阅读相关文档。

package/bin/skills/lakehouse-doc/references/sql_functions/scalar_functions/high_order_functions/map_filter.md

@@ -0,0 +1,25 @@
+### MAP_FILTER 函数
+
+#### 功能描述
+MAP_FILTER 函数用于根据给定的 lambda 表达式筛选 map 类型的元素。该函数接收两个参数：第一个参数为 map 类型的数据，第二个参数为一个二参形式的 lambda 表达式，分别对应 map 中的键（k）和值（v）。lambda 表达式需要返回一个布尔值，用于判断当前键值对是否应该保留在结果中。
+
+#### 参数说明
+- map: 输入的 map<K, V> 类型数据。
+- (k, v) -> expr: 一个二参形式的 lambda 表达式，k 和 v 分别代表 map 中的键和值。expr 需要返回一个布尔值，表示当前键值对是否应该被保留。
+
+#### 返回值
+返回一个新的 map<K, V> 类型数据，其中仅包含满足 lambda 表达式条件的键值对。
+
+#### 使用示例
+1. 筛选 map 中值小于等于 2 的元素：
+   <= 2);
+   // 结果：{2: "a", 1: "b"}
+   ```
+2. 筛选 map 中值小于等于 'b' 的元素：
+   ```sql
+   SELECT `map_filter`(map(2, 'a', 1, 'b', 3, 'c'), (k, v) ->
+2. 筛选 map 中值长度大于 1 的元素：
+   ```sql
+   SELECT `map_filter`(map(2, 'a', 1, 'bb', 3, 'c'), (k, v) -> LENGTH(v) > 1);
+   // 结果：{1: "bb"}
+   ```

package/bin/skills/lakehouse-doc/references/sql_functions/scalar_functions/high_order_functions/map_zip_with.md

@@ -0,0 +1,46 @@
+### MAP_ZIP_WITH 函数
+
+#### 功能描述
+MAP_ZIP_WITH 函数能够根据给定的 lambda 表达式，将两个 map 类型数据中 key 值相同的元素进行配对计算。计算过程中，若某个 key 在其中一个 map 中不存在对应值，则会补入 NULL 值。最终，该函数会返回一个新的 map，其中包含原始 key 值以及根据 lambda 表达式计算得到的新值。
+
+#### 参数说明
+- map1, map2: 输入的两个 map 类型数据，类型为 `map<K, V>`。
+- `(k, v1, v2) -> expr`: 一个三参数形式的 lambda 表达式，其中 `k` 为匹配的 key 值，`v1` 为 `map1` 中对应的 value，`v2` 为 `map2` 中对应的 value。lambda 表达式的返回值类型不限，但所有返回值必须为同一类型。
+
+#### 返回类型
+返回一个新的 map 类型数据，类型为 `map<K, R>`，其中 `R` 为 lambda 表达式计算得到的值类型。
+
+#### 使用示例
+1. 计算两个 map 中相同 key 对应 value 的和，并返回新的 map：
+```sql
+SELECT map_zip_with(map(1, 2, 3, 4), map(2, 3, 4, 5), (k, x, y) -> x + y);
+```
+结果：
+```
+{1:null,3:null,2:null,4:null} 
+```
+
+2. 将两个 map 中相同 key 对应的 value 转换为字符串并拼接，返回新的 map：
+```sql
+SELECT map_zip_with(map(1, "a", 2, "b"), map(1, "A", 2, "B"), (k, x, y) -> CONCAT(x, y));
+```
+结果：
+```
+{1:"aA", 2:"bB"}
+```
+
+3. 对两个 map 中相同 key 对应的 value 进行类型转换并相加，返回新的 map：
+```sql
+SELECT map_zip_with(map(1, 2), map(1, 100, 3, 300), (k, x, y) -> CAST((x + y) AS string));
+```
+结果：
+```
+{1:"102", 3:null}
+```
+
+#### 注意事项
+- 当 key 在一个 map 中不存在对应值时，会补入 NULL 值参与计算。
+- 请确保 lambda 表达式中的参数顺序与实际传入的参数顺序相符。
+- 返回的新 map 中，key 值的顺序可能与原始 map 中的顺序不同。
+
+通过以上描述和示例，您可以更好地理解和使用 MAP_ZIP_WITH 函数。在实际应用中，该函数能够帮助您灵活地对两个 map 类型数据进行操作和计算。

package/bin/skills/lakehouse-doc/references/sql_functions/scalar_functions/high_order_functions/transform.md

@@ -0,0 +1,48 @@
+### TRANSFORM 函数
+
+#### 功能描述
+TRANSFORM 函数用于根据给定的 lambda 表达式对数组（array）中的元素进行转换。该函数支持两种形式的 lambda 表达式：单参数形式和双参数形式（包含元素索引）。
+
+#### 参数说明
+- `array`: 输入的数组，类型为 `array<T>`，其中 T 可以是任意数据类型。
+- `x -> expr`: 单参数形式的 lambda 表达式，`x` 代表数组中的元素，`expr` 为根据 `x` 计算得到的新值，返回值类型无限制。
+- `(x, i) -> expr`: 双参数形式的 lambda 表达式，`x` 代表数组中的元素，`i` 代表元素的索引（从 0 开始计数），`expr` 为根据 `x` 和 `i` 计算得到的新值，返回值类型无限制。
+
+#### 返回值
+返回一个新的数组，类型为 `array<U>`，其中 U 是 lambda 表达式返回值的类型。
+
+#### 使用示例
+
+1. 计算数组中每个元素的平方并返回结果数组：
+   ```sql
+   SELECT transform(array(1, 2, 3), x -> x * x);
+   -- 输出结果：[1, 4, 9]
+   ```
+
+2. 将数组中的字符串元素转换为大写，并返回结果数组：
+   ```sql
+   SELECT transform(array('hello', 'world'), x -> upper(x));
+   -- 输出结果：['HELLO', 'WORLD']
+   ```
+
+3. 根据数组元素的索引和值计算新的数组，其中每个元素的值是其索引与值之和：
+   ```sql
+   SELECT transform(array(2, 1, 3), (x, i) -> x + i);
+   -- 输出结果：[2, 2, 5]
+   ```
+
+4. 对数组中的字符串进行拆分，并返回结果数组：
+   ```sql
+   SELECT transform(array('hello,world', NULL, '1,2,3'), x -> split(x, ','));
+   -- 输出结果：[["hello","world"],null,["1","2","3"]]
+   ```
+
+5. 将数组中的每个数值乘以 2 并返回结果数组：
+   ```sql
+   SELECT transform(array(1, 3, 5), x -> x * 2);
+   -- 输出结果：[2, 6, 10]
+   ```
+
+#### 注意事项
+- 请确保 lambda 表达式中的参数名称与实际传入的参数相匹配。
+- 在使用双参数形式的 lambda 表达式时，请注意元素索引是从 0 开始的。

package/bin/skills/lakehouse-doc/references/sql_functions/scalar_functions/high_order_functions/transform_keys.md

@@ -0,0 +1,48 @@
+### TRANSFORM_KEYS 函数
+
+#### 功能描述
+TRANSFORM_KEYS 函数用于根据提供的 lambda 表达式对 map 类型的输入进行键（key）转换。该函数将遍历输入的 map，并使用 lambda 表达式计算新的键，从而生成一个新的 map。
+
+#### 参数说明
+- map: 输入的 map 类型数据，格式为 `map<K, V>`，其中 K 表示原始键类型，V 表示原始值类型。
+- (k, v) -> expr: 二参形式的 lambda 表达式，k 对应原始 map 中的键（key），v 对应原始 map 中的值（value）。expr 为 lambda 表达式的返回值，表示新的键。注意，expr 的返回类型应该与原始键类型 K 兼容。
+
+#### 返回类型
+函数返回一个新的 map 类型数据，格式为 `map<K', V>`，其中 K' 为经过 lambda 表达式转换后的新键类型，V 为原始值类型。
+
+#### 使用示例
+
+**示例 1：增加键的整数值**
+
+```sql
+SELECT transform_keys(map(1, 'hello', 2, NULL, 3, 'world'), (k, v) -> CAST(k + 1 AS string));
+```
+结果：
+```
+{"2":"hello","3":NULL,"4":"world"}
+```
+
+**示例 2：将键转换为字符串类型**
+
+```sql
+SELECT transform_keys(map(1, 'hello', 2, NULL, 3, 'world'), (k, v) -> CAST(k AS string));
+```
+结果：
+```
+{"1":"hello","2":NULL,"3":"world"}
+```
+
+**示例 3：根据键值对中的值来转换键**
+
+```sql
+SELECT transform_keys(map(1, 'hello', 2, 'hi', 3, 'world'), (k, v) -> IF(v = 'hello', 'greeting', 'other'));
+```
+结果：
+```
+{"greeting":"hello","other":"hi","other":"world"}
+```
+
+#### 注意事项
+- 请确保 lambda 表达式返回的新键类型与原始键类型 K 兼容，否则会导致函数执行失败。
+- 当输入的 map 为空时，函数将返回一个空的 map。
+- 请确保 lambda 表达式中使用的功能和操作符在当前环境中可用，以免出现错误。

package/bin/skills/lakehouse-doc/references/sql_functions/scalar_functions/high_order_functions/transform_values.md

@@ -0,0 +1,36 @@
+### transform_values 函数
+
+#### 功能描述
+`transform_values` 函数用于根据指定的 lambda 表达式对输入的 map 类型数据进行值转换操作。该函数接受两个参数：第一个参数为 map 类型数据，第二个参数为一个双参数的 lambda 表达式，其两个参数分别对应 map 中的键（key）和值（value）。lambda 表达式的返回值将作为新 map 中的值（value）。
+
+#### 参数说明
+1. `map`: 输入的 map 类型数据，格式为 `map<K, V>`，其中 K 表示键的类型，V 表示值的类型。
+2. `(k, v) -> expr`: 一个双参数的 lambda 表达式，用于定义值转换的逻辑。`k` 对应 map 中的键，`v` 对应 map 中的值。`expr` 为 lambda 表达式，其返回值类型将作为新 map 中值的类型。
+
+#### 返回类型
+返回一个新的 map 类型数据，格式为 `map<R, V>`，其中 R 为 lambda 表达式的返回值类型。
+
+#### 使用示例
+1. 示例 1：计算字符串长度
+```sql
+SELECT transform_values(map(1, 'hello', 2, NULL, 3, 'world'), (k, v) -> LENGTH(v));
+```
+返回结果：`{1:5, 2:null, 3:5}`
+
+2. 示例 2：将字符串转换为大写
+```sql
+SELECT transform_values(map(1, 'hello', 2, 'sql', 3, 'world'), (k, v) -> UPPER(v));
+```
+返回结果：`{1:'HELLO', 2:'SQL', 3:'WORLD'}`
+
+3. 示例 3：为每个键值对添加后缀
+```sql
+SELECT transform_values(map(1, 'hello', 2, 'world'), (k, v) -> CONCAT(v, '_suffix'));
+```
+返回结果：`{1:'hello_suffix', 2:'world_suffix'}`
+
+#### 注意事项
+1. 当输入的 map 数据中的值为 NULL 时，lambda 表达式需要能够处理 NULL 值，否则可能会导致函数执行失败。
+2. 请确保 lambda 表达式返回值的类型与预期的新 map 中值的类型一致。
+
+通过使用 `transform_values` 函数，您可以灵活地对 map 类型数据进行各种转换操作，从而满足不同的业务需求。

package/bin/skills/lakehouse-doc/references/sql_functions/scalar_functions/high_order_functions/zip_with.md

@@ -0,0 +1,38 @@
+### ZIP_WITH 函数
+
+#### 功能描述
+ZIP_WITH 函数能够根据提供的 lambda 表达式，对两个数组（array1 和 array2）的对应位置元素进行计算，并生成一个新的数组。当两个输入数组长度不一致时，较短数组的缺失元素位置将补入 NULL 值，然后继续进行计算。
+
+#### 参数说明
+- array1, array2: `array<T>` 类型，需要进行操作的两个数组。
+- `(x1, x2) -> expr`: 二参形式的 lambda 表达式，其中 `x1` 对应 `array1` 的元素，`x2` 对应 `array2` 的元素。`expr` 为表达式内容，其返回值的类型没有限制。
+
+#### 返回类型
+返回一个新的数组，其元素类型与 lambda 表达式返回值的类型一致。
+
+#### 使用示例
+1. 两个数组对应元素相加，并转换为字符串类型：
+```sql
+SELECT zip_with(array(1, 2), array(2, 3), (x, y) -> CAST((x + y) AS string));
+-- 返回结果：["3", "5"]
+```
+2. 计算两个数组对应元素的差值：
+```sql
+SELECT zip_with(array(5, 3, 1), array(2, 4, 6), (x, y) -> x - y);
+-- 返回结果：[3, -1, -5]
+```
+3. 将两个数组对应元素拼接成新的字符串：
+```sql
+SELECT zip_with(array('a', 'b'), array('x', 'y'), (x, y) -> CONCAT(x, y));
+-- 返回结果：['ax', 'by']
+```
+4. 当数组长度不一致时，较短数组的缺失元素位置将补入 NULL 值：
+```sql
+SELECT zip_with(array(1, 2), array(2, 3, 4), (x, y) -> x * y);
+-- 返回结果：[2, 6, null]
+```
+#### 注意事项
+- 当输入的数组为空时，ZIP_WITH 函数将返回一个空数组。
+- 当 lambda 表达式中使用到 NULL 值时，其行为应符合 SQL 中对 NULL 的处理规则。
+
+通过以上描述和示例，您可以更好地理解并使用 ZIP_WITH 函数来处理数组数据。