@clickzetta/cz-cli-darwin-x64 0.3.1

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

@@ -0,0 +1,41 @@
+### 数组交集检查函数：arrays_overlap
+
+#### 功能描述
+`arrays_overlap` 函数用于检查两个数组是否存在至少一个共同的元素。具体来说，该函数有以下功能：
+1. 如果两个数组 `array1` 和 `array2` 存在至少一个相同的元素，函数返回 `true`。
+2. 如果两个数组都没有交集，但至少有一个数组包含 `null` 值，且两个数组都不为空，则函数返回 `null`。
+3. 其他情况下，函数返回 `false`。
+
+#### 参数说明
+- `array1`, `array2`: 待比较的两个数组，类型为 `array<T>`，其中 `T` 可以是任意数据库支持的数据类型。
+
+#### 返回类型
+- 返回类型为 `boolean` 或 `null`。
+
+#### 使用示例
+1. 检查两个数组是否有交集：
+```sql
+SELECT arrays_overlap(array(1, 2, 3), array(3, 4, 5)); -- 返回 true
+```
+2. 当数组中包含 `null` 时的情况：
+```sql
+SELECT arrays_overlap(array(1, 2, 3), array(null, 4, 5)); -- 返回 null
+```
+3. 两个非空数组但没有交集的情况：
+```sql
+SELECT arrays_overlap(array(1, 2, 3), array(4, 5, 6)); -- 返回 false
+```
+4. 一个数组为空的情况：
+```sql
+SELECT arrays_overlap(array(), array(1, 2, 3)); -- 返回 false
+```
+5. 两个数组都为空的情况：
+```sql
+SELECT arrays_overlap(array(), array()); -- 返回 false
+```
+
+
+#### 注意事项
+- 当使用 `arrays_overlap` 函数时，请注意数组元素的类型需要一致，否则可能会导致比较失败。
+- 如果数组中包含 `null` 值，函数的行为会有所不同，这一点在使用时需要特别注意。
+

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

@@ -0,0 +1,50 @@
+### 数组合并函数：arrays\_zip
+
+`arrays_zip(a1, a2, ... aN)` 是一款强大的数组处理函数，它可以将多个数组 a1、a2 至 aN 合并为一个新的数组。新数组中的每个元素是一个结构体（struct），结构体包含 N 个字段，分别对应输入数组中的第 k 个元素。如果某个数组的第 k 个元素不存在，则在结构体中填充 null 值。
+
+#### 功能描述
+
+该函数的主要作用是将多个数组按照相同的索引位置进行合并，生成一个新的数组。新数组的每个元素都是一个结构体，结构体中的字段数量与输入数组的数量相同。这种合并方式非常适合在处理多维数据时进行数据整合。
+
+#### 参数说明
+
+* `a1 ~ aN`: 需要合并的数组，数组类型为 `array<T>`，其中 T 可以是任意数据类型。
+
+#### 返回结果
+
+返回一个新的数组，数组中的每个元素都是一个结构体。结构体包含 N 个字段，分别对应输入数组中的第 k 个元素。字段名称为 `0`、`1` 至 `N-1`。
+
+#### 使用示例
+
+1. 基本使用：
+   ```sql
+   SELECT arrays_zip(array(1, 2), array(4));
+   ```
+   结果：
+   ```json
+   [{"0":1,"1":4},{"0":2,"1":null}]
+   ```
+   上述示例中，两个数组长度相同，直接合并生成一个新的数组。
+
+2. 不等长数组合并：
+   ```sql
+   SELECT arrays_zip(array(1, 2, 3), array(4, 5));
+   ```
+   结果：
+   ```json
+    [{"0":1,"1":4},{"0":2,"1":5},{"0":3,"1":null}]
+   ```
+   在这个示例中，两个数组长度不同，合并时较短的数组后面的元素会被填充为 null。
+
+3. 多数组合并：
+   ```sql
+   SELECT arrays_zip(array(1, 2), array(4, 5), array('a', 'b'));
+
+   ```
+   结果：
+   ```json
+    [{"0":1,"1":4,"2":"a"},{"0":2,"1":5,"2":"b"}]
+   ```
+   本示例中，三个数组被合并成一个新数组，每个元素都是一个包含三个字段的结构体。
+
+

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

@@ -0,0 +1,45 @@
+### 函数名称：CARDINALITY
+
+#### 功能描述
+`CARDINALITY` 函数用于计算数组中元素的数量或映射中键值对的数量。
+
+#### 语法
+```
+CARDINALITY(array)
+CARDINALITY(map)
+```
+
+#### 参数说明
+- `array`: 输入的数组，元素类型为 `T`。
+- `map`: 输入的映射，由键类型 `K` 和值类型 `V` 组成。
+
+#### 返回类型
+- 返回一个整型数值（`int`），表示数组中元素的个数或映射中键值对的个数。
+
+#### 使用示例
+1.  计算数组中元素的个数：
+    ```
+SELECT CARDINALITY(ARRAY(1, 2, 3, 4, 5)); -- 返回 5
+```
+2.  计算映射中键值对的个数：
+    ```
+SELECT CARDINALITY(MAP("a", 1, "b", 2, "c", 3)); -- 返回 3
+```
+3.  结合实际数据表进行操作：
+    假设有一个名为 `students` 的数据表，表结构如下：
+    ```
+CREATE TABLE students (
+  id INT,
+  name VARCHAR,
+  hobbies ARRAY<VARCHAR>
+);
+```
+    向 `students` 表中插入一条数据：
+    ```
+INSERT INTO students (id, name, hobbies) VALUES (1, 'Alice', ARRAY('reading', 'swimming', 'traveling'));
+```
+    使用 `CARDINALITY` 函数计算该学生的爱好数量：
+    ```
+SELECT CARDINALITY(hobbies) FROM students WHERE id = 1; -- 返回 3
+```
+

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

@@ -0,0 +1,49 @@
+### CONCAT 函数
+
+#### 概述
+`CONCAT` 函数用于将多个数组、字符串或二进制数据连接起来，生成一个新的数组、字符串或二进制数据。
+
+#### 语法
+```
+CONCAT(array1, array2, ..., arrayN)
+CONCAT(str1, str2, ..., strN)
+CONCAT(binary1, binary2, ..., binaryN)
+```
+
+#### 功能描述
+1. 数组连接：将 `array1` 至 `arrayN` 中的所有元素合并成一个新的数组。
+2. 字符串连接：将 `str1` 至 `strN` 中的所有字符串拼接成一个新的字符串。
+3. 二进制数据连接：将 `binary1` 至 `binaryN` 中的所有二进制数据拼接成一个新的二进制数据。
+
+#### 参数说明
+- `array1` 至 `arrayN`: `array<T>` 类型，表示要连接的数组。
+- `str1` 至 `strN`: `string` 类型，表示要连接的字符串。
+- `binary1` 至 `binaryN`: `binary` 类型，表示要连接的二进制数据。
+
+#### 返回值
+- 数组连接版本：返回一个新的 `array<T>` 类型数组。
+- 字符串连接版本：返回一个新的字符串。
+- 二进制数据连接版本：返回一个新的二进制数据。
+
+#### 使用示例
+```sql
+-- 数组连接示例
+SELECT CONCAT(array(1, 2), array(3, 4));
+-- 结果：[1, 2, 3, 4]
+
+-- 字符串连接示例
+SELECT CONCAT('hello', '-', 'world');
+-- 结果：'hello-world'
+
+-- 二进制数据连接示例
+SELECT CONCAT(CAST('123' AS BINARY), CAST('456' AS BINARY));
+-- 结果：'123456'
+```
+
+#### 注意事项
+- 当连接空数组或空字符串时，`CONCAT` 函数将返回一个空数组或空字符串。
+- 当连接多个二进制数据时，请确保它们的长度相同，否则可能导致无法正确连接。
+- 在连接字符串时，如果需要在连接的字符串之间添加分隔符，可以将其作为一个额外的参数传递给 `CONCAT` 函数。
+
+#### 总结
+`CONCAT` 函数提供了一种简单且高效的方式来连接数组、字符串和二进制数据。通过使用此函数，您可以轻松地将多个数据组合成一个统一的数据结构，以便进一步处理和分析。

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

@@ -0,0 +1,73 @@
+
+### CONCAT_WS 函数
+
+#### 概述
+`CONCAT_WS` 函数用于将多个字符串或数组中的字符串元素连接成一个字符串。它可以根据指定的分隔符 `sep` 来连接输入的字符串或数组中的字符串元素。如果输入的字符串为 `NULL`，则在结果中忽略该值。
+
+#### 语法
+```
+CONCAT_WS(sep, str1, str2, ..., strN)
+CONCAT_WS(sep, array1, array2, ..., arrayN)
+```
+
+#### 参数
+- `sep`: 分隔符字符串，用于连接输入的各个字符串。
+- `str1, str2, ..., strN`: 要连接的字符串。
+- `array1, array2, ..., arrayN`: 包含要连接的字符串元素的数组。
+
+#### 返回结果
+返回一个连接后的字符串。
+
+#### 使用示例
+
+1. 基本使用：
+```sql
+SELECT CONCAT_WS('-', 'hello', 'world');
+```
+结果：
+```
+hello-world
+```
+
+2. 连接多个字符串：
+```sql
+SELECT CONCAT_WS('-', 'hello', 'my', 'friend', '!');
+```
+结果：
+```
+hello-my-friend-!
+```
+
+3. 忽略 `NULL` 值：
+```sql
+SELECT CONCAT_WS('-', 'hello', NULL, 'world', NULL);
+```
+结果：
+```
+hello-world
+```
+
+4. 使用数组连接字符串：
+```sql
+SELECT CONCAT_WS('-', array('hello', 'my', 'friend'), array('is', NULL, 'awesome'));
+```
+结果：
+```
+hello-my-friend-is-awesome
+```
+
+5. 结合其他函数使用：
+```sql
+SELECT CONCAT_WS('-', UPPER('hello'), LENGTH('world'), LOWER('!'));
+```
+结果：
+```
+HELLO-5-!
+```
+
+#### 注意事项
+- 当输入的字符串或数组元素为 `NULL` 时，`CONCAT_WS` 函数会忽略这些值。
+- 如果所有输入的字符串或数组元素均为 `NULL`，则返回空字符串。
+- 如果分隔符 `sep` 也为 `NULL`，则返回 NULL。
+
+通过以上示例和说明，可以更好地理解 `CONCAT_WS` 函数的用法和功能。在实际应用中，可以根据需要灵活地使用此函数来连接字符串或数组元素。

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

@@ -0,0 +1,34 @@
+###  ELEMENT_AT
+``` sql
+element_at(array, index)
+element_at(map, key)
+```
+
+#### 功能
+对于array类型，返回array的第index个元素，下标以1开头
+对于map类型，返回map的key所对应的value，如果key不存在，则返回NULL
+
+#### 参数
+* array: `array<T>`
+* index: bigint
+* map: `map<K, V>`
+* key: K
+
+#### 返回结果
+* array根据入参推导：`T <- array<T>`
+* map根据入参推导：`V <- map<K, V>`
+
+#### 举例
+```sql
+> SELECT element_at(array(1, 2, 3), 2);
+2
+
+> SELECT try_element_at(array(1, 2, 3), 5);
+NULL
+
+> SELECT element_at(map(1, 'a', 2, 'b'), 2);
+b
+
+> SELECT element_at(map(1, 'a', 2, 'b'), 3);
+NULL
+```

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

@@ -0,0 +1,62 @@
+### FLATTEN 函数
+------------------
+
+### 概述
+
+`FLATTEN` 函数用于将二维数组（即数组的数组）转换成一维数组。该函数可以处理包含多个子数组的复杂结构，并将其元素展平成一个连续的序列。
+
+### 语法
+
+```sql
+flatten(array<array>)
+```
+
+### 参数说明
+
+- `array<array>`: 一个二维数组，其中包含多个子数组。每个子数组可以包含任意类型的元素。
+
+### 返回值
+
+返回一个包含所有子数组元素的一维数组。
+
+### 使用示例
+
+**示例 1: 基本用法**
+
+假设我们有一个二维数组，我们想要将其展平成一个一维数组。
+
+```sql
+SELECT FLATTEN(
+  ARRAY(
+    ARRAY(1, 2),
+    ARRAY(3, 4)
+  )
+);
+```
+
+返回结果：
+
+```
+[1, 2, 3, 4]
+```
+
+**示例 2: 嵌套数组**
+
+如果我们的二维数组包含嵌套的更深层次的数组，`FLATTEN` 函数也可以处理。
+
+```sql
+SELECT FLATTEN(
+  ARRAY(
+    ARRAY(ARRAY(1), ARRAY(2, 3)),
+    ARRAY(ARRAY(4), ARRAY(5, 6))
+  )
+);
+```
+
+返回结果：
+
+```
+[[1],[2,3],[4],[5,6]]
+```
+
+

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

@@ -0,0 +1,44 @@
+### MAP 函数
+
+#### 功能描述
+MAP 函数用于创建一个键值对集合，其中每个键（key）对应一个值（value）。该函数可以一次性插入多个键值对，方便用户快速构建一个 Map 类型的数据结构。
+
+#### 语法格式
+```
+MAP(k1, v1, ..., kN, vN)
+```
+
+#### 参数说明
+- k1, ..., kN : 表示函数的键参数，类型为 `K`。
+- v1, ..., vN : 表示函数的值参数，类型为 `V`。
+
+#### 返回类型
+- 返回一个 `map<K, V>` 类型的对象。
+
+#### 使用示例
+1. 创建一个包含两个键值对的 Map：
+   ```sql
+   SELECT MAP("name", "Alice", "age", '25');
+   // 返回：{"name":"Alice","age":"25"}
+   ```
+2. 构建一个包含三个键值对的 Map，其中包含重复的键（但值不同）：
+   ```sql
+   SELECT MAP("fruit", "apple", "fruit", "banana", "color", "green");
+   // 返回：{"fruit":"banana","color":"green"}
+   ```
+3. 向 Map 中插入不同类型的键值对（字符串和整数）：
+   ```sql
+   SELECT MAP("width", 100, "height", 200);
+   // 返回：{"width":100,"height":200}
+   ```
+4. 创建一个空的 Map 对象：
+   ```sql
+   SELECT MAP();
+   // 返回：{}
+   ```
+
+#### 注意事项
+- 确保提供的键和值数量匹配（成对出现），否则会导致函数执行失败。
+- 如果存在重复的键，后面的键值对会覆盖前面的键值对。
+- MAP 函数可以接受任意类型的键和值，但键必须是可比较的类型，以便在 Map 中进行查找操作。
+

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

@@ -0,0 +1,38 @@
+### MAP_CONCAT 函数
+
+#### 功能描述
+`MAP_CONCAT` 函数用于将多个 `map` 类型参数中的键值对合并到一起，形成一个全新的 `map`。这个函数在处理多个数据源并需要将它们的数据整合到一个单一的数据结构时非常有用。
+
+#### 语法格式
+```
+MAP_CONCAT(map1, map2, ..., mapN)
+```
+
+#### 参数说明
+- `map1` ~ `mapN`: 输入的 `map` 类型参数，可以是两个或更多，每个参数都是一个 `map<K, V>` 类型，其中 `K` 表示键的类型，`V` 表示值的类型。
+
+#### 返回类型
+返回一个新的 `map<K, V>` 类型，其中包含了所有输入 `map` 参数中的键值对。
+
+#### 使用示例
+1. 基础使用：
+   ```sql
+   SELECT MAP_CONCAT(map('key1', 'value1'), map('key2', 'value2'));
+   // 返回结果：{"key1":"value1","key2":"value2"}
+   ```
+   在这个例子中，两个 `map` 被合并成一个，包含了两个键值对。
+
+2. 多个参数合并：
+   ```sql
+   SELECT MAP_CONCAT(map('a', 1), map('b', 2), map('c', 3));
+   // 返回结果：{"a":1,"b":2,"c":3}
+   ```
+   三个 `map` 被合并成一个，形成了一个包含三个键值对的新 `map`。
+
+3. 重复键的处理：
+   ```sql
+   SELECT MAP_CONCAT(map('key', 'original'), map('key', 'override'));
+   // 返回结果：{"key":"override"}
+   ```
+   当多个 `map` 包含相同的键时，后面的 `map` 中的值会覆盖前面的值。
+

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

@@ -0,0 +1,34 @@
+### MAP_CONTAINS_KEY 函数
+
+#### 功能描述
+MAP_CONTAINS_KEY 函数用于判断给定的 map 类型数据中是否包含指定的键（key）。当指定的键存在于 map 中时，函数返回 true；否则返回 false。
+
+#### 语法
+```
+MAP_CONTAINS_KEY(map: map<K, V>, key: K): boolean
+```
+
+#### 参数
+- map: 待检查的 map 类型数据，其中 K 表示键的类型，V 表示值的类型。
+- key: 需要查询的键，其类型应与 map 中的键类型 K 相匹配。
+
+#### 返回值
+返回一个布尔值，表示 map 中是否包含指定的键。
+
+#### 使用示例
+1.  判断 map 中是否包含键 'a'：
+    ```sql
+SELECT MAP_CONTAINS_KEY(map('a', 1), 'a'); -- 返回 true
+```
+2.  判断 map 中是否包含键 'b'：
+    ```sql
+SELECT MAP_CONTAINS_KEY(map('a', 1), 'b'); -- 返回 false
+```
+3.  假设有一个 map 类型的数据，包含键值对 ('name', 'Alice') 和 ('age', 25)，判断 map 中是否包含键 'name'：
+    ```sql
+SELECT MAP_CONTAINS_KEY(map('name', 'Alice', 'age', 25), 'name'); -- 返回 true
+```
+4.  判断上述 map 中是否包含键 'gender'：
+    ```sql
+SELECT MAP_CONTAINS_KEY(map('name', 'Alice', 'age', 25), 'gender'); -- 返回 false
+```

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

@@ -0,0 +1,44 @@
+### MAP_ENTRIES 函数
+
+#### 功能描述
+`MAP_ENTRIES` 函数用于将输入的 Map 类型数据转换为一个数组，数组中的每个元素都是一个结构体（struct），该结构体包含两个字段，分别对应 Map 中的键（key）和值（value）。
+
+#### 语法
+```
+MAP_ENTRIES(map<K, V>)
+```
+
+#### 参数
+- `map`: 输入的 Map 类型数据，其中 `K` 表示键的类型，`V` 表示值的类型。
+
+#### 返回结果
+返回一个数组，数组中的每个元素都是一个结构体，结构体包含两个字段：`key` 和 `value`，分别对应 Map 中的键和值。
+
+#### 使用示例
+1. 基本使用：
+   ```sql
+   SELECT MAP_ENTRIES(map(1, 'a', 2, 'b'));
+   ```
+   返回结果：
+   ```
+   [{"key":1,"value":"a"},{"key":2,"value":"b"}]
+   ```
+
+2. 与其他函数结合使用：
+   ```sql
+   SELECT MAP_ENTRIES(map_filter(map(1, 'a', 2, 'b'), (key,v)->key > 1));
+   ```
+   返回结果：
+   ```
+   [{"key":2,"value":"b"}]
+   ```
+
+3. 嵌套 Map 转换：
+   ```sql
+   SELECT MAP_ENTRIES(map(map(1, 'a'), map(2, 'b')));
+   ```
+   返回结果：
+   ```
+   [{"key":{1:"a"},"value":{2:"b"}}] 
+   ```
+

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

@@ -0,0 +1,33 @@
+### MAP_EQUAL 函数
+
+#### 功能描述
+MAP_EQUAL 函数用于比较两个 Map 类型的数据结构（以下简称 Map），判断它们是否完全相同。如果两个 Map 的键值对完全一致，则函数返回 true；否则，返回 false。
+
+#### 语法
+```
+MAP_EQUAL(m1, m2)
+```
+其中，`m1` 和 `m2` 分别表示需要比较的两个 Map。
+
+#### 参数说明
+- `m1`, `m2`: 需要比较的两个 Map。
+
+#### 返回结果
+返回一个布尔值（boolean）。如果两个 Map 完全相同，则返回 true；否则，返回 false。
+
+#### 使用示例
+1. 比较两个完全相同的 Map：
+   ```
+   SELECT MAP_EQUAL(MAP('k1', 'v1', 'k2', 'v2'), MAP('k1', 'v1', 'k2', 'v2'));
+   → true
+   ```
+2. 比较两个不同的 Map（键值对不一致）：
+   ```
+   SELECT MAP_EQUAL(MAP('k1', 'v1', 'k2', 'v2'), MAP('k1', 'v3', 'k2', 'v4'));
+   → false
+   ```
+3. 比较两个不同的 Map（键不一致）：
+   ```
+   SELECT MAP_EQUAL(MAP('k1', 'v1', 'k3', 'v3'), MAP('k2', 'v2', 'k3', 'v3'));
+   → false
+   ```

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

@@ -0,0 +1,34 @@
+### MAP_EXCEPT 函数
+
+#### 功能描述
+MAP_EXCEPT 函数用于从第一个映射（map1）中移除与第二个映射（map2）中相同的键值对（K, V）。该函数在数据清洗和转换中非常有用，可以帮助用户快速过滤掉不需要的重复数据。
+
+#### 参数说明
+* map1, map2: `map<K, V>` 类型，分别代表第一个和第二个映射。
+
+#### 返回结果
+返回一个新的映射（map<K, V>），其中包含了从第一个映射中移除与第二个映射相同的键值对后的结果。
+
+#### 使用示例
+1. 过滤重复的键值对
+```sql
+SELECT MAP_EXCEPT(MAP(1, 'apple', 2, 'orange'), MAP(1, 'apple', 3, 'banana'));
+-- 返回结果：{2:'orange'}
+```
+在这个示例中，MAP_EXCEPT 函数从第一个映射中移除了与第二个映射相同的键值对（1, 'apple'）。
+
+2. 保留唯一的键值对
+```sql
+SELECT MAP_EXCEPT(MAP(1, 'apple', 2, 'orange', 3, 'banana'), MAP(2, 'orange', 4, 'grape'));
+-- 返回结果：{1:'apple', 3:'banana'}
+```
+在这个示例中，MAP_EXCEPT 函数从第一个映射中移除了与第二个映射相同的键值对（2, 'orange'），同时保留了其他唯一的键值对。
+
+3. 处理 NULL 值
+```sql
+SELECT MAP_EXCEPT(MAP(1, NULL, 2, 'pear'), MAP(1, NULL));
+-- 返回结果：{2:'pear'}
+```
+在这个示例中，MAP_EXCEPT 函数从第一个映射中移除了与第二个映射相同的键值对（1, NULL），同时保留了其他唯一的键值对。
+
+通过以上示例，您可以看到 MAP_EXCEPT 函数在处理映射数据时的灵活性和实用性。您可以根据自己的需求，灵活地应用该函数进行数据过滤和转换。

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

@@ -0,0 +1,28 @@
+###  MAP_FROM_ARRAYS
+``` sql
+map_from_arrays(k, v)
+```
+
+#### 功能
+使用两个array创建map，map的key和value于参数array中的顺序意义对应。两个array的长度需要严格一致
+
+#### 参数
+* k: `array<K>`
+* v: `array<V>`
+
+#### 返回结果
+`map<K, V>`
+
+#### 举例
+```sql
+> select map_from_arrays(k, v)
+  from values
+      (array(1, 2, 3), array('a', 'b', 'c')),
+      (array(1, 2, 3), array('a', NULL, 'c')),
+      (null, array('a', 'b', 'c')),
+      (array(1, 2, 3), null) as t(k, v) ;
+{1:"a",2:"b",3:"c"}
+{1:"a",2:null,3:"c"}
+NULL
+NULL
+```

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

@@ -0,0 +1,52 @@
+### MAP\_FROM\_ENTRIES 函数
+
+#### 功能描述
+`MAP_FROM_ENTRIES` 函数用于从数组中创建一个 map 类型。输入的数组元素需要符合 `map_entries` 函数的格式，即每个元素都是一个包含 `key` 和 `value` 属性的结构体。
+
+#### 参数说明
+* `array`: 输入参数，类型为 `array<struct<key:K, value:V>>`，表示包含多个结构体的数组，每个结构体具有 `key` 和 `value` 两个属性。
+
+#### 返回结果
+返回一个 `map<K, V>` 类型的结果，其中 `K` 表示 key 的类型，`V` 表示 value 的类型。
+
+#### 使用示例
+1. 创建一个包含两个元素的数组，每个元素都是一个结构体，结构体中包含两个属性：`key` 和 `value`。
+```sql
+SELECT MAP_FROM_ENTRIES(ARRAY(
+NAMED_STRUCT('key',1, 'value','a'),
+NAMED_STRUCT('key',2, 'value','b')
+));
+
+```
+返回结果：
+```
+{
+  1:"a",
+  2:"b"
+}
+```
+
+2. 创建一个包含三个元素的数组，元素类型为结构体，结构体中包含不同类型的 key 和 value。
+```sql
+SELECT MAP_FROM_ENTRIES(ARRAY(
+NAMED_STRUCT('key',1, 'value','apple' ),
+NAMED_STRUCT('key',2, 'value','carrot'),
+NAMED_STRUCT('key',3, 'value','dog')
+));
+
+
+```
+返回结果：
+```
+{
+  1:"apple",
+  2:"carrot",
+  3:"dog"
+}
+```
+
+注意：在上述示例中，`extra` 属性不会包含在最终的 map 中，因为我们只关心 `key` 和 `value` 属性。
+
+#### 注意事项
+* 输入数组中的每个结构体必须具有 `key` 和 `value` 两个属性，否则会导致函数执行失败。
+* key 的类型需要唯一，不能有重复的 key 值，否则后面的 key 值会覆盖前面的 key 值。