@clickzetta/cz-cli-darwin-x64 0.3.1

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

@@ -0,0 +1,29 @@
+### ARRAY_COMPACT
+```sql
+array_compact(array)
+```
+
+#### 功能
+移除数组中的所有 null 值，返回不包含 null 的新数组
+
+#### 参数
+* array: `array<T>` - 输入的数组
+
+#### 返回结果
+* `array<T>` - 移除所有 null 元素后的新数组
+* 如果数组中所有元素都是 null 或数组为空，则返回空数组 `[]`
+
+#### 举例
+```sql
+> SELECT array_compact(array(null));
+[]
+
+> SELECT array_compact(array());
+[]
+
+> SELECT array_compact(array(1, 3, null, 4));
+[1,3,4]
+
+> SELECT array_compact(array(null, 3, null));
+[3]
+```

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

@@ -0,0 +1,38 @@
+### 数组包含函数：ARRAY_CONTAINS
+
+```
+array_contains(array, value)
+```
+
+#### 功能描述
+ARRAY_CONTAINS 函数用于判断一个数组（array）是否包含指定的值（value）。当指定的值存在于数组中时，函数返回 true，否则返回 false。
+
+#### 参数说明
+- array: `array<T>`，表示要进行搜索的数组。
+- value: T 类型，表示要查找的元素值。
+
+#### 返回类型
+- 返回一个布尔值（boolean），当数组包含指定值时返回 true，否则返回 false。
+
+#### 使用示例
+1. 判断数组中是否包含特定元素：
+   ```sql
+   SELECT array_contains(array(1, 2, 3, 4, 5), 3); -- 返回 true
+   SELECT array_contains(array(1, 2, 3, 4, 5), 6); -- 返回 false
+   ```
+   
+2. 在实际查询中使用 ARRAY_CONTAINS 函数：
+   ```sql
+   SELECT * FROM students
+   WHERE array_contains(interests, 'Basketball');
+   ```
+   上述查询将返回 interests 数组中包含 'Basketball' 兴趣的学生记录。
+
+3. 多条件判断：
+   ```sql
+   SELECT * FROM products
+   WHERE array_contains(features, 'Bluetooth') AND array_contains(features, 'Waterproof');
+   ```
+   上述查询将返回 features 数组中同时包含 'Bluetooth' 和 'Waterproof' 特性的产品记录。
+
+通过使用 ARRAY_CONTAINS 函数，您可以方便地在 SQL 查询中实现对数组元素的判断和筛选，从而更精确地获取所需的数据。

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

@@ -0,0 +1,43 @@
+### 数组去重函数：ARRAY_DISTINCT
+
+#### 功能描述
+`ARRAY_DISTINCT` 函数用于去除数组中的重复元素，返回一个不包含重复项的数组。该函数可以处理任何类型的数组，包括整数、浮点数、字符串等。
+
+#### 语法
+```
+ARRAY_DISTINCT(array)
+```
+
+#### 参数说明
+- `array`：`array<T>` 类型，表示需要去重的数组。
+
+#### 返回结果
+返回一个 `array<T>` 类型的数组，其中包含了去重后的数组元素。
+
+#### 使用示例
+1.  去除整数数组中的重复项：
+    ```sql
+   SELECT ARRAY_DISTINCT(ARRAY(1, 2, 2, 3));
+   -- 返回结果：[1, 2, 3]
+   ```
+
+2.  去除浮点数数组中的重复项：
+    ```sql
+   SELECT ARRAY_DISTINCT(ARRAY(3.14, 2.71, 2.71, 1.41));
+   -- 返回结果：[3.14, 2.71, 1.41]
+   ```
+
+3.  去除字符串数组中的重复项：
+    ```sql
+   SELECT ARRAY_DISTINCT(ARRAY('apple', 'orange', 'apple', 'banana'));
+   -- 返回结果：['apple', 'orange', 'banana']
+   ```
+
+4.  去除混合类型数组中的重复项：
+    ```sql
+   SELECT ARRAY_DISTINCT(ARRAY(1, 'a', 2, 'b', 1, 'a', 3));
+   -- 返回结果：[1,null,2,3]
+   ```
+   
+#### 注意事项
+- 当数组为空时，`ARRAY_DISTINCT` 函数将返回一个空数组。

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

@@ -0,0 +1,35 @@
+### 数组差分函数：ARRAY_EXCEPT
+
+```
+array_except(array1, array2)
+```
+
+#### 功能描述
+ARRAY_EXCEPT 函数用于计算两个数组之间的差异，即找出仅存在于第一个数组（array1）中的元素，并将结果中的重复元素去除。该函数在处理集合操作时非常有用，可以帮助用户快速找出两个数组的不同之处。
+
+#### 参数说明
+- array1: `array<T>` 类型，表示第一个输入数组。
+- array2: `array<T>` 类型，表示第二个输入数组。
+
+#### 返回结果
+返回一个 `array<T>` 类型的数组，其中包含仅存在于第一个数组中的元素，且结果中不包含重复元素。
+
+#### 使用示例
+1. 求两个整数数组的差异：
+```sql
+SELECT array_except(array(1, 2, 3, 4, 5), array(3, 4, 6, 7));
+```
+结果：
+```
+[1, 2, 5]
+```
+2. 求两个字符串数组的差异：
+```sql
+SELECT array_except(array('apple', 'banana', 'orange'), array('banana', 'grape', 'orange'));
+```
+结果：
+```
+['apple']
+```
+
+通过以上示例可以看出，ARRAY_EXCEPT 函数在处理数组差异时非常有效。用户可以根据需求，灵活运用该函数进行集合操作。

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

@@ -0,0 +1,39 @@
+### 数组交集函数：ARRAY_INTERSECT
+
+#### 功能描述
+`ARRAY_INTERSECT` 函数用于计算两个数组之间的交集，并去除重复元素。该函数在处理数据集时非常有用，特别是当你需要找出两个数据集中共有的元素时。
+
+#### 语法
+```
+array_intersect(array1, array2)
+```
+#### 参数说明
+- `array1` 和 `array2`：需要计算交集的两个数组，数组类型为 `array<T>`，其中 `T` 可以是任意数据类型。
+
+#### 返回类型
+函数返回一个新的数组，包含两个输入数组的交集元素，数组类型同样为 `array<T>`。
+
+#### 使用示例
+1. 计算两个整数数组的交集：
+    ```sql
+SELECT array_intersect(array(1, 2, 3, 4), array(3, 4, 5, 6));
+```
+    返回结果：`[3, 4]`
+
+2. 计算两个字符串数组的交集：
+    ```sql
+SELECT array_intersect(array('apple', 'banana', 'cherry'), array('banana', 'date', 'cherry'));
+```
+    返回结果：`['banana', 'cherry']`
+
+3. 计算两个日期数组的交集：
+    ```sql
+SELECT array_intersect(array('2021-01-01', '2021-01-02'), array('2021-01-02', '2021-01-03'));
+```
+    返回结果：`['2021-01-02']`
+
+#### 注意事项
+- 当输入的两个数组中包含不同类型的元素时，可能会导致函数执行失败或返回意外的结果。请确保输入数组的元素数据类型一致。
+- 如果两个数组中都不存在共有元素，函数将返回一个空数组。
+
+通过使用 `ARRAY_INTERSECT` 函数，你可以轻松地找出两个数组共有的元素，从而在数据分析和处理中得到更精确的结果。

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

@@ -0,0 +1,51 @@
+### 数组连接函数：ARRAY_JOIN
+
+#### 功能描述
+`ARRAY_JOIN` 函数的主要作用是将一个字符串数组中的元素按照指定的分隔符连接成一个单一的字符串。如果数组中的元素存在 `NULL` 值，并且指定了 `nullReplacement` 参数，那么这些 `NULL` 值会被替换为该参数指定的字符串。如果没有提供 `nullReplacement` 参数，那么 `NULL` 值将不会被包含在最终的连接结果中。
+
+#### 参数说明
+* `array`: 输入的字符串数组，类型为 `array<string>`。
+* `delimiter`: 用作数组元素之间的分隔符，类型为 `string`。
+* `nullReplacement` (可选): 用于替换数组中 `NULL` 值的字符串，类型为 `string`。
+
+#### 返回类型
+返回一个字符串，包含了连接后的数组元素。
+
+#### 示例
+1.  不使用 `nullReplacement` 参数：
+```sql
+SELECT ARRAY_JOIN(ARRAY('apple', 'banana', 'cherry'), ', ');
+```
+结果：
+```
+apple, banana, cherry
+```
+
+2.  使用 `nullReplacement` 参数：
+```sql
+SELECT ARRAY_JOIN(ARRAY('apple', NULL, 'cherry'), ', ', 'missing');
+```
+结果：
+```
+apple, missing, cherry
+```
+
+3.  忽略 `NULL` 值：
+```sql
+SELECT ARRAY_JOIN(ARRAY('a', NULL, 'b', NULL), '-');
+```
+结果：
+```
+a-b
+```
+
+4.  处理包含所有 `NULL` 值的数组：
+```sql
+SELECT ARRAY_JOIN(ARRAY(NULL, NULL, NULL), ', ', 'N/A');
+```
+结果：
+```
+N/A, N/A, N/A 
+```
+
+通过以上示例，您可以看到 `ARRAY_JOIN` 函数在不同情况下的使用方式和结果。此函数在需要将多个字符串元素合并为一个字符串时非常有用，尤其是在处理包含 `NULL` 值的数组时，可以灵活地选择是否包含这些值或用其他字符串替换它们。

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

@@ -0,0 +1,57 @@
+### 数组最大值函数：ARRAY_MAX
+#### 简介
+`array_max` 函数用于从输入的数组中找出最大值。该函数会自动忽略数组中的空值（null）。
+
+#### 语法
+```
+array_max(array)
+```
+
+#### 参数
+- `array`: `array<T>`，表示输入的数组，T 为数组元素的数据类型。
+
+#### 返回值
+- 返回类型根据输入数组的元素类型自动推导得出，即：`T <- array<T>`。
+
+#### 使用示例
+1. 求整数数组中的最大值：
+```
+SELECT array_max(array(1, 2, 3, 4, 5));
+```
+结果：
+```
+5
+```
+
+2. 求浮点数数组中的最大值：
+```
+SELECT array_max(array(1.2, 2.5, 3.7, 4.4, 5.1));
+```
+结果：
+```
+5.1
+```
+
+3. 求字符串数组中的最大值（按字典序）：
+```
+SELECT array_max(array('apple', 'banana', 'cherry', 'orange'));
+```
+结果：
+```
+'orange'
+```
+
+4. 处理包含空值的数组：
+```
+SELECT array_max(array(1, 2, null, 4));
+```
+结果：
+```
+4
+```
+
+#### 注意事项
+- 当输入数组为空时，`array_max` 函数将返回空值（null）。
+- 如果数组中所有元素都是空值，函数同样会返回空值（null）。
+
+通过以上示例和说明，您可以更有效地使用 `array_max` 函数来处理数组中的最大值问题。

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

@@ -0,0 +1,60 @@
+### 数组最小值函数：ARRAY_MIN
+
+#### 功能描述
+`array_min` 函数用于从输入的数组中找出并返回最小值。在处理数值类型的数组时，该函数会将 `null` 值忽略不计。这使得用户能够轻松地处理包含空值的数组，而不必担心其对结果的影响。
+
+#### 语法
+```
+array_min(array)
+```
+
+#### 参数
+- `array`: `array<T>` 类型的参数，表示将要从中查找最小值的数组。
+
+#### 返回结果
+- 返回类型根据输入数组的元素类型推导得出：`T <- array<T>`。如果数组为空或全部为 `null` 值，则返回 `null`。
+
+#### 使用示例
+
+**例 1：** 找出整数数组中的最小值
+```sql
+SELECT array_min(array(1, 5, 3, 2, 4));
+```
+结果：
+```
+1
+```
+
+**例 2：** 处理包含 `null` 值的数组
+```sql
+SELECT array_min(array(1, null, 3, null, 2));
+```
+结果：
+```
+1
+```
+
+**例 3：** 在数组中查找最小浮点数值
+```sql
+SELECT array_min(array(1.2, 4.5, 3.7, 2.9));
+```
+结果：
+```
+1.2
+```
+
+**例 4：** 返回空数组的最小值
+```sql
+SELECT array_min(array());
+```
+结果：
+NULL
+
+**例 5：** 处理全部为 `null` 值的数组
+```sql
+SELECT array_min(array(null, null, null));
+```
+结果：
+NULL
+
+通过上述示例，您可以看到 `array_min` 函数在不同情况下的应用。此函数非常适合在需要比较数组中元素大小并找出最小值的场景中使用。

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

@@ -0,0 +1,50 @@
+# 数组位置查找函数：ARRAY\_POSITION
+
+## 功能描述
+
+`array_position` 函数用于在一个给定的数组 `array` 中查找元素 `element` 的位置。如果找到该元素，函数返回其在数组中的起始位置（位置计数从1开始）；如果未找到该元素，则返回0。
+
+## 参数说明
+
+* `array`: `array<T>` 类型，表示待查找的数组。
+* `element`: T 类型，表示要查找的元素。
+
+## 返回值
+
+* 返回一个整数，表示元素在数组中的位置（从1开始计数），如果元素不存在，则返回0。
+
+## 使用示例
+
+以下是一些使用 `array_position` 函数的示例：
+
+1. 查找数字1在数组 `(1, 2, 3)` 中的位置：
+   ```sql
+   SELECT array_position(array(1, 2, 3), 1);
+   -- 结果：1
+   ```
+
+2. 查找数字4在数组 `(1, 2, 3)` 中的位置，预期结果为0（因为4不存在于该数组中）：
+   ```sql
+   SELECT array_position(array(1, 2, 3), 4);
+   -- 结果：0
+   ```
+
+3. 在一个包含字符串的数组中查找元素 "apple"：
+   ```sql
+   SELECT array_position(array('banana', 'apple', 'cherry'), 'apple');
+   -- 结果：2
+   ```
+
+4. 尝试在一个空数组中查找元素 "orange"，预期结果为0：
+   ```sql
+   SELECT array_position(array(), 'orange');
+   -- 结果：0
+   ```
+
+5. 查找数字3在一个包含重复元素的数组 `(1, 2, 3, 3)` 中的位置：
+   ```sql
+   SELECT array_position(array(1, 2, 3, 3), 3);
+   -- 结果：3
+   ```
+
+

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

@@ -0,0 +1,26 @@
+### ARRAY_PREPEND
+```sql
+array_prepend(array, element)
+```
+
+#### 功能
+在数组开头插入一个元素，返回新的数组
+
+#### 参数
+* array: `array<T>` - 输入的数组
+* element: `T` - 要插入的元素
+
+#### 返回结果
+* `array<T>` - 在开头插入元素后的新数组
+
+#### 举例
+```sql
+> SELECT array_prepend(array(1, 2, 3), 3);
+[3,1,2,3]
+
+> SELECT array_prepend(array(1, 2, 3), cast(null as int));
+[null,1,2,3]
+
+> SELECT array_prepend(cast(array() as array<int>), 1);
+[1]
+```

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

@@ -0,0 +1,34 @@
+### 数组移除函数：ARRAY_REMOVE
+
+#### 功能描述
+`ARRAY_REMOVE` 函数用于从给定的数组 `array` 中移除所有与指定元素 `element` 相等的项。该函数接受两个参数：第一个参数为待操作的数组，第二个参数为需要移除的元素。执行后，返回一个新的数组，其中不包含与指定元素相等的项。
+
+#### 参数说明
+- `array`: `array<T>` 类型，表示待操作的数组。
+- `element`: T 类型，表示需要从数组中移除的元素。
+
+#### 返回结果
+返回一个新的 `array<T>` 类型数组，其中不包含与指定元素 `element` 相等的项。
+
+#### 使用示例
+1.  从包含整数的数组中移除元素 `1`：
+    ```sql
+SELECT array_remove(array(1, 2, 3), 1);
+```
+    返回结果：
+    ```
+[2, 3]
+```
+
+2.  从包含字符串的数组中移除元素 `"apple"`：
+    ```sql
+SELECT array_remove(array("apple", "banana", "cherry", "apple"), "apple");
+```
+    返回结果：
+    ```
+["banana", "cherry"]
+```
+
+
+
+通过以上示例，您可以看到 `ARRAY_REMOVE` 函数在不同场景下的应用。该函数可以方便地用于处理数组数据，满足您在数据清洗、筛选等方面的需求。

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

@@ -0,0 +1,51 @@
+### 数组重复函数：ARRAY_REPEAT
+
+#### 功能描述
+`array_repeat` 函数用于创建一个新的数组，该数组由指定数量的相同元素组成。这个函数接受两个参数：`expr` 表示要重复的元素，`count` 表示重复的次数。函数返回一个类型为 `array<T>` 的数组，其中 `T` 是元素的类型。
+
+#### 参数说明
+- `expr` (T): 要重复的元素。
+- `count` (int): 元素需要重复的次数。
+
+#### 返回类型
+- 返回一个类型为 `array<T>` 的数组。
+
+#### 使用示例
+1.  重复字符串：
+    ```sql
+   SELECT array_repeat('hello', 3);
+   ```
+    结果：
+    ```
+   ["hello", "hello", "hello"]
+   ```
+2.  重复数值：
+    ```sql
+   SELECT array_repeat(42, 4);
+   ```
+    结果：
+    ```
+   [42, 42, 42, 42]
+   ```
+3.  结合其他函数使用：
+    ```sql
+   SELECT array_repeat(upper('a'), 5);
+   ```
+    结果：
+    ```
+   ["A", "A", "A", "A", "A"]
+   ```
+4.  重复日期时间：
+    ```sql
+   SELECT array_repeat(timestamp '2023-04-01 12:00:00', 2);
+   ```
+    结果：
+    ```
+   ["2023-04-01 12:00:00", "2023-04-01 12:00:00"]
+   ```
+
+#### 注意事项
+- 确保 `count` 参数是一个非负整数。如果 `count` 为负数，函数将返回一个空数组。
+- 当 `expr` 是一个复杂的数据类型（如对象或数组）时，整个结构将被重复，而不是单个元素。
+
+通过使用 `array_repeat` 函数，您可以轻松地创建包含重复元素的数组，从而简化数据处理和转换的逻辑。

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

@@ -0,0 +1,32 @@
+### 数组大小函数：ARRAY_SIZE
+
+#### 功能描述
+`ARRAY_SIZE` 函数用于获取数组中元素的数量，即数组的大小。该函数可以处理包括数字、字符串、布尔值等在内的各种数据类型的数组。
+
+#### 语法
+```
+ARRAY_SIZE(array)
+```
+#### 参数说明
+* `array`: `array<T>` 类型，表示待计算大小的数组。
+
+#### 返回类型
+* 返回一个整数，表示数组中元素的数量。
+
+#### 使用示例
+1.  计算数字数组的大小：
+    ```sql
+SELECT ARRAY_SIZE(array(1, 2, 3, 4, 5));
+-- 返回结果：5
+```
+2.  计算字符串数组的大小：
+    ```sql
+SELECT ARRAY_SIZE(array('apple', 'banana', 'cherry'));
+-- 返回结果：3
+```
+3.  计算包含布尔值的数组的大小：
+    ```sql
+SELECT ARRAY_SIZE(array(true, false, true, false, true));
+-- 返回结果：5
+```
+

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

@@ -0,0 +1,46 @@
+### 数组排序函数：ARRAY_SORT
+
+#### 功能描述
+`ARRAY_SORT` 函数用于对输入的数组进行排序处理。该函数会将数组中的元素按照自然顺序进行排序，并将所有的 `null` 值放置在数组的末尾。
+
+#### 函数语法
+```
+ARRAY_SORT(array: array<T>);
+```
+
+#### 参数说明
+- `array`: 输入的数组，可以是任何类型的数组，包括但不限于整数、浮点数、字符串等。
+
+#### 返回结果
+返回一个新的、已排序的数组。数组中的元素将按照升序排列，所有 `null` 值将被移动到数组的末尾。
+
+#### 使用示例
+1. 对整数数组进行排序：
+   ```sql
+   SELECT ARRAY_SORT(array(2, 1, 3));
+   // 结果：[1, 2, 3]
+   ```
+2. 对包含 `null` 值的数组进行排序：
+   ```sql
+   SELECT ARRAY_SORT(array(null, 4, 3, null, 5, 6));
+   // 结果：[3, 4, 5, 6, null, null]
+   ```
+3. 对字符串数组进行排序：
+   ```sql
+   SELECT ARRAY_SORT(array('banana', 'apple', 'cherry'));
+   // 结果：['apple', 'banana', 'cherry']
+   ```
+4. 对浮点数数组进行排序：
+   ```sql
+   SELECT ARRAY_SORT(array(3.14, 2.71, 1.41));
+   // 结果：[1.41, 2.71, 3.14]
+   ```
+5. 对混合类型数组进行排序：
+   ```sql
+   SELECT ARRAY_SORT(array('2019', 2, null, '2020', 1));
+   // 结果：[1, 2, '2019', '2020', null]
+   ```
+
+#### 注意事项
+- 当数组中包含不可比较类型的元素时，可能会导致排序结果不符合预期。
+- 如果数组中的元素类型不一致，排序操作可能会按照隐式类型转换规则进行，这可能影响排序结果的准确性。

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

@@ -0,0 +1,31 @@
+### 数组降序排序函数：ARRAY_SORT_REVERSE
+
+#### 功能描述
+`ARRAY_SORT_REVERSE` 函数用于对输入的数组进行降序排序。该函数接受一个数组作为参数，并返回一个新的、按照元素值从大到小排列的数组。
+
+#### 参数说明
+- `array`: 输入参数，类型为 `array<T>`，表示需要进行排序的数组。
+
+#### 返回结果
+返回一个类型为 `array<T>` 的新数组，其元素按照降序排列。
+
+#### 使用示例
+1. 对整数数组进行降序排序：
+   ```sql
+   SELECT array_sort_reverse(array(2, 1, 3));
+   -- 结果：[3, 2, 1]
+   ```
+2. 对浮点数数组进行降序排序：
+   ```sql
+   SELECT array_sort_reverse(array(1.5, 3.2, 2.8));
+   -- 结果：[3.2, 2.8, 1.5]
+   ```
+3. 对字符串数组按照字符串的字典顺序进行降序排序：
+   ```sql
+   SELECT array_sort_reverse(array('banana', 'apple', 'cherry'));
+   -- 结果：['cherry', 'banana', 'apple']
+   ```
+
+#### 注意事项
+- 输入数组中的元素类型必须一致。
+- 该函数对数组中的 `NULL` 值敏感，`NULL` 值会被放置在返回数组的末尾。

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

@@ -0,0 +1,36 @@
+### 数组并集函数：ARRAY_UNION
+
+```
+array_union(array1, array2)
+```
+
+#### 功能描述
+ARRAY_UNION 函数用于计算两个数组的并集，即合并 array1 和 array2 中的所有元素，并去除重复项。该函数能够处理包含多种数据类型的数组，例如整数、浮点数、字符串等。
+
+#### 参数说明
+- `array1`: `array<T>` 类型，表示第一个输入数组。
+- `array2`: `array<T>` 类型，表示第二个输入数组。
+
+#### 返回结果
+返回一个新的数组，包含 array1 和 array2 中的所有不重复元素。
+
+#### 使用示例
+1.  求两个整数数组的并集：
+    ```sql
+SELECT array_union(array(2, 1, 3, 3), array(3, 5));
+-- 返回结果：[2, 1, 3, 5]
+```
+2.  求两个字符串数组的并集：
+    ```sql
+SELECT array_union(array('apple', 'orange', 'banana'), array('banana', 'grape', 'apple'));
+-- 返回结果：['apple', 'orange', 'banana', 'grape']
+```
+3.  求两个浮点数数组的并集：
+    ```sql
+SELECT array_union(array(1.2, 2.5, 3.7), array(3.7, 4.6, 5.3));
+-- 返回结果：[1.2, 2.5, 3.7, 4.6, 5.3]
+```
+
+
+#### 注意事项
+- 如果输入的数组为空，ARRAY_UNION 函数将返回一个空数组。