@clickzetta/cz-cli-darwin-x64 0.3.1

package/bin/skills/lakehouse-doc/references/sql_functions/aggregate_functions/covar_samp.md

@@ -0,0 +1,113 @@
+### COVAR_SAMP 函数
+
+```
+covar_samp(y, x)
+```
+
+#### 功能描述
+
+`COVAR_SAMP` 函数用于计算两个数值列之间的样本协方差（Sample Covariance）。协方差衡量两个变量共同变化的程度。样本协方差使用 (n-1) 作为分母，是总体协方差的无偏估计。
+
+#### 参数说明
+
+* `y`：数值类型的表达式,作为因变量。必须是可以转换为 `DOUBLE` 的数值类型。
+* `x`：数值类型的表达式,作为自变量。必须是可以转换为 `DOUBLE` 的数值类型。
+
+#### 返回类型
+
+* 返回 `DOUBLE` 类型的样本协方差值。
+  * 正值：x 和 y 倾向于同向变化（正相关）
+  * 负值：x 和 y 倾向于反向变化（负相关）
+  * 接近 0：变量之间相关性较弱
+
+#### 注意事项
+
+* 函数计算过程中，`NULL` 值会被忽略。
+* 如果有效数据点少于 1 个，返回 `NULL`。
+* 样本协方差使用除以 (n-1) 的公式计算，是总体协方差的无偏估计。在样本量较小时，样本协方差的波动性（方差）通常较大。
+* 当 n 很大时，样本协方差和总体协方差的差异很小。
+
+#### 使用示例
+
+1. 基本用法：计算样本协方差
+
+```sql
+SELECT covar_samp(c1, c2)
+FROM VALUES (1, 1), (2, 2), (2, 2), (3, 3) AS tab(c1, c2);
++--------------------+
+| covar_samp(c1, c2) |
++--------------------+
+| 0.6666666666666666 |
++--------------------+
+```
+
+2. 与总体协方差对比
+
+```sql
+SELECT covar_pop(c1, c2), covar_samp(c1, c2)
+FROM VALUES (1, 1), (2, 2), (2, 2), (3, 3) AS tab(c1, c2);
++-------------------+--------------------+
+| covar_pop(c1, c2) | covar_samp(c1, c2) |
++-------------------+--------------------+
+| 0.5               | 0.6666666666666666 |
++-------------------+--------------------+
+```
+
+3. 完全正相关的数据
+
+```sql
+SELECT covar_samp(x, y)
+FROM VALUES (1, 2), (2, 4), (3, 6), (4, 8) AS t(x, y);
++--------------------+
+| covar_samp(x, y)   |
++--------------------+
+| 3.3333333333333335 |
++--------------------+
+```
+
+4. 完全负相关的数据
+
+```sql
+SELECT covar_samp(x, y)
+FROM VALUES (1, 8), (2, 6), (3, 4), (4, 2) AS t(x, y);
++---------------------+
+| covar_samp(x, y)    |
++---------------------+
+| -3.3333333333333335 |
++---------------------+
+```
+
+5. NULL 值会被忽略
+
+```sql
+SELECT covar_samp(x, y)
+FROM VALUES (1, 1), (2, NULL), (3, 3), (NULL, 4), (5, 5) AS t(x, y);
++-------------------+
+| covar_samp(x, y)  |
++-------------------+
+| 4.0               |
++-------------------+
+```
+
+6. 按分组计算样本协方差
+
+```sql
+SELECT
+  product,
+  covar_samp(price, sales_volume) as price_sales_covar
+FROM VALUES
+  ('A', 10, 100),
+  ('A', 20, 80),
+  ('A', 30, 60),
+  ('B', 15, 50),
+  ('B', 25, 40),
+  ('B', 35, 30)
+AS sales(product, price, sales_volume)
+GROUP BY product;
++---------+--------------------+
+| product | price_sales_covar  |
++---------+--------------------+
+| A       | -200.0             |
+| B       | -100.0             |
++---------+--------------------+
+```

package/bin/skills/lakehouse-doc/references/sql_functions/aggregate_functions/first_value.md

@@ -0,0 +1,122 @@
+### FIRST_VALUE 函数
+
+```
+first_value(expr [, ignoreNulls]) [FILTER (WHERE condition)]
+first(expr [, ignoreNulls]) [FILTER (WHERE condition)]
+```
+
+#### 功能描述
+
+`FIRST_VALUE` 函数用于返回聚合组或窗口中的第一个值。可以选择是否忽略 `NULL` 值。`first` 是 `first_value` 的别名。
+
+#### 参数说明
+
+* `expr`：任意类型的表达式，要获取其第一个值。
+* `ignoreNulls`：可选的布尔值参数，默认为 `false`。
+  * `false`（默认）：返回第一个值，即使是 `NULL`
+  * `true`：忽略 `NULL` 值，返回第一个非 `NULL` 值
+
+#### 返回类型
+
+* 返回与输入表达式相同的数据类型。
+* 返回聚合组或窗口中的第一个值。
+
+#### 注意事项
+
+* 如果所有值都是 `NULL`（且 `ignoreNulls` 为 `true`），返回 `NULL`。
+* 如果输入为空集，返回 `NULL`。
+* 值的顺序取决于数据的输入顺序（不确定）。使用 `WITHIN GROUP (ORDER BY ...)` 可以指定确定性的顺序。
+
+#### 使用示例
+
+1. 基本用法：返回第一个值
+
+```sql
+SELECT first_value(col), first(col)
+FROM VALUES (10), (5), (20) AS tab(col);
++------------------+------------+
+| first_value(col) | first(col) |
++------------------+------------+
+| 10               | 10         |
++------------------+------------+
+```
+
+2. 处理 NULL 值（默认返回第一个值，即使是 NULL）
+
+```sql
+SELECT first_value(col), first(col)
+FROM VALUES (NULL), (5), (NULL) AS tab(col);
++------------------+------------+
+| first_value(col) | first(col) |
++------------------+------------+
+| NULL             | NULL       |
++------------------+------------+
+```
+
+3. 忽略 NULL 值，返回第一个非 NULL 值
+
+```sql
+SELECT first_value(col, true), first(col, true)
+FROM VALUES (NULL), (5), (NULL) AS tab(col);
++------------------------+-------------------+
+| first_value(col, true) | first(col, true)  |
++------------------------+-------------------+
+| 5                      | 5                 |
++------------------------+-------------------+
+```
+
+4. 使用 WITHIN GROUP (ORDER BY ...) 指定顺序
+
+```sql
+SELECT a,
+       first_value(b) WITHIN GROUP(ORDER BY c) as first_b,
+       first_value(b, true) WITHIN GROUP(ORDER BY c) as first_non_null_b
+FROM VALUES
+  ('apple', 11, 22),
+  ('apple', 1, 2),
+  ('orange', NULL, 1),
+  ('orange', 111, 2),
+  ('orange', NULL, 3)
+AS t(a, b, c)
+GROUP BY a;
++--------+---------+------------------+
+| a      | first_b | first_non_null_b |
++--------+---------+------------------+
+| apple  | 1       | 1                |
+| orange | NULL    | 111              |
++--------+---------+------------------+
+```
+
+5. 获取每个分组的第一个和最后一个值
+
+```sql
+SELECT
+  category,
+  first_value(value) as first_val,
+  last_value(value) as last_val
+FROM VALUES
+  ('A', 10),
+  ('A', 20),
+  ('B', 30),
+  ('B', 40)
+AS t(category, value)
+GROUP BY category;
++----------+-----------+----------+
+| category | first_val | last_val |
++----------+-----------+----------+
+| A        | 10        | 20       |
+| B        | 30        | 40       |
++----------+-----------+----------+
+```
+
+6. 使用 FILTER 子句条件性地获取第一个值
+
+```sql
+SELECT first_value(col) FILTER (WHERE col > 5)
+FROM VALUES (3), (10), (7), (12) AS tab(col);
++-------------------------------------------+
+| first_value(col) FILTER (WHERE (col > 5)) |
++-------------------------------------------+
+| 10                                        |
++-------------------------------------------+
+```

package/bin/skills/lakehouse-doc/references/sql_functions/aggregate_functions/group_bitmap.md

@@ -0,0 +1,42 @@
+# GROUP_BITMAP 函数
+
+## 简介
+
+`GROUP_BITMAP` 函数是一个聚合函数，用于对一组无符号整数值进行聚合，计算出对应的 Bitmap（位图）数据结构。该函数在处理大规模数据集时非常高效，尤其适用于需要对大量整数值进行集合操作（如并集、交集等）的场景。
+
+## 语法
+
+```sql
+group_bitmap(value)
+```
+
+## 参数
+
+* `value`：`INTEGER` 或 `BIGINT` 类型的表达式，表示需要聚合的整数值。通常，这些值是从数据表的某一列中提取的。
+
+## 返回值
+
+返回一个 `INT` 类型的结果，表示聚合后的位图。`Bitmap` 是一种紧凑的数据结构，通过位表示法存储整数值的存在性。每个位对应一个整数值，如果该位为 1，则表示对应的整数值存在于集合中；如果该位为 0，则表示对应的整数值不存在于集合中。
+
+## 使用示例
+
+示例 1：基本用法
+
+```sql
+SELECT group_bitmap(v) AS bitmap_result
+FROM VALUES (1), (2), (3), (4), (5) AS t(v);
++---------------+
+| bitmap_result |
++---------------+
+| 5             |
++---------------+
+```
+
+**结果**：
+返回一个 `INT` 类型的位图。
+
+## 注意事项
+
+1. **输入值范围**：`group_bitmap` 函数适用于无符号整数值。如果输入值为负数，可能会导致意外的结果或错误。
+2. **性能优化**：在处理大规模数据集时，`group_bitmap` 函数非常高效。但如果数据量过大，仍需注意性能影响。在可能的情况下，可尝试优化输入数据以提高函数执行效率。
+3. **中间状态的使用**：如果需要对多个分组进行聚合操作，建议使用 `group_bitmap_state` 和 `group_bitmap_merge` 函数，以避免重复计算。

package/bin/skills/lakehouse-doc/references/sql_functions/aggregate_functions/group_bitmap_and.md

@@ -0,0 +1,46 @@
+# GROUP_BITMAP_AND 函数
+
+## 简介
+
+`GROUP_BITMAP_AND` 函数用于计算一组 `Bitmap` 数据的按位与（`AND`）操作，并返回最终结果。该函数在处理大规模数据集时非常高效，尤其适用于需要对多个 `Bitmap` 进行交集操作的场景。它可以直接返回最终的 `Bitmap` 结果，而无需中间状态。
+
+## 语法
+
+```sql
+group_bitmap_and(bitmap)
+```
+
+## 参数
+
+- **`bitmap`**：`BITMAP` 类型的表达式，表示需要进行按位与操作的 `Bitmap` 数据。
+
+## 返回值
+
+返回一个 `INT` 类型的结果，表示所有输入 `Bitmap` 的按位与操作的结果。
+
+## 使用示例
+
+示例 1：计算多个 `Bitmap` 的按位与操作
+
+假设有一个数据表 `t`，其中包含列 `v`，存储了多个数组。现在需要计算这些数组的按位与操作的结果。
+
+```sql
+SELECT group_bitmap_and(bitmap_build(v)) AS res
+FROM VALUES
+  (ARRAY(1,2,3,4,5,6,7,8,9,10)),
+  (ARRAY(6,7,8,9,10,11,12,13,14,15)),
+  (ARRAY(2,4,6,8,10,12))
+AS t(v);
++-----+
+| res |
++-----+
+| 3   |
++-----+
+```
+
+## 相关函数
+
+- **`group_bitmap_and_state`**：返回按位与操作的中间状态，适用于需要分步计算的场景。
+- **`group_bitmap_merge`**：合并多个中间状态的 `Bitmap` 对象。
+- **`bitmap_and`**：对两个 `Bitmap` 进行按位与操作。
+- **`bitmap_to_array`**：将 `Bitmap` 转换为数组形式，便于查看结果。

package/bin/skills/lakehouse-doc/references/sql_functions/aggregate_functions/group_bitmap_and_state.md

@@ -0,0 +1,47 @@
+# GROUP_BITMAP_AND_STATE 函数
+
+## 简介
+
+`GROUP_BITMAP_AND_STATE` 函数用于计算一组 `Bitmap` 数据的按位与（`AND`）操作，并返回中间状态。该函数在处理大规模数据集时非常高效，尤其适用于需要对多个 `Bitmap` 进行交集操作的场景。返回的中间状态可以用于后续的合并操作，从而实现更复杂的聚合逻辑。
+
+## 语法
+
+```sql
+group_bitmap_and_state(bitmap)
+```
+
+## 参数
+
+- **`bitmap`**：`BITMAP` 类型的表达式，表示需要进行按位与操作的 `Bitmap` 数据。
+
+## 返回值
+
+返回一个中间状态的 `BITMAP` 对象，表示按位与操作的中间结果。该中间状态可以用于后续的合并操作。
+
+## 使用示例
+
+示例 1：使用 `bitmap_to_array` 查看结果
+
+假设有一个数据表 `t`，其中包含列 `v`，存储了多个数组。现在需要计算这些数组的按位与操作的结果，并将其转换为数组形式以便查看。
+
+```sql
+SELECT bitmap_to_array(group_bitmap_and_state(bitmap_build(v))) AS res
+FROM VALUES (ARRAY(1, 2)), (ARRAY(1, 2)), (ARRAY(1)) AS t(v);
++-----+
+| res |
++-----+
+| [1] |
++-----+
+```
+
+## 注意事项
+
+1. **输入类型**：请确保输入的 `bitmap` 是 `BITMAP` 类型，否则会导致函数执行失败。
+2. **中间状态的使用**：返回的中间状态可以用于后续的合并操作，从而实现更复杂的聚合逻辑。
+3. **性能优化**：在处理大规模数据集时，`group_bitmap_and_state` 函数非常高效。但如果数据量过大，仍需注意性能影响。在可能的情况下，可尝试优化输入数据以提高函数执行效率。
+## 相关函数
+
+- **`group_bitmap_and`**：直接计算按位与操作的最终结果。
+- **`group_bitmap_merge`**：合并多个中间状态的 `Bitmap` 对象。
+- **`bitmap_and`**：对两个 `Bitmap` 进行按位与操作。
+- **`bitmap_to_array`**：将 `Bitmap` 转换为数组形式，便于查看结果。

package/bin/skills/lakehouse-doc/references/sql_functions/aggregate_functions/group_bitmap_merge.md

@@ -0,0 +1,37 @@
+# GROUP_BITMAP_MERGE 函数
+
+## 简介
+
+`GROUP_BITMAP_MERGE` 函数用于合并多个中间状态的 `Bitmap` 对象，最终返回合并后的基数。该函数在处理大规模数据集时非常高效，尤其适用于需要对多个 `Bitmap` 中间状态进行合并的场景。
+
+## 语法
+
+```sql
+group_bitmap_merge(bitmap)
+```
+
+## 参数
+
+* `bitmap`：`BITMAP` 类型的中间状态，表示需要合并的 `Bitmap` 状态。
+
+## 返回值
+
+返回一个 `INT` 类型的结果，表示合并后的 `Bitmap` 基数。
+
+## 使用示例
+
+假设需要合并由多个数组构建的 `Bitmap` 数据并返回基数：
+
+```sql
+SELECT group_bitmap_merge(bitmap_build(v)) AS res
+FROM VALUES
+  (ARRAY(1,2,3,4,5,6,7,8,9,10)),
+  (ARRAY(6,7,8,9,10,11,12,13,14,15)),
+  (ARRAY(2,4,6,8,10,12))
+AS t(v);
++-----+
+| res |
++-----+
+| 15  |
++-----+
+```

package/bin/skills/lakehouse-doc/references/sql_functions/aggregate_functions/group_bitmap_merge_state.md

@@ -0,0 +1,29 @@
+### GROUP_BITMAP_MERGE_STATE 函数
+
+#### 功能描述
+`GROUP_BITMAP_MERGE_STATE` 函数用于对多个位图（`bitmap`）值进行合并操作，合并这些值并返回它们的并集。该函数特别适用于处理分类数据，能够高效地合并具有相同分类的位图表示，从而得到一个包含所有类别元素的位图。
+
+#### 参数说明
+- **`bitmap`**：输入参数，类型为位图（`BITMAP`）。指需要进行逻辑“或”操作的位图列的值。
+
+#### 返回结果
+函数返回一个位图类型的值，该值包含了输入参数中所有位图值的并集。
+
+#### 使用示例
+以下示例展示了如何使用 `GROUP_BITMAP_MERGE_STATE` 函数来计算位图的逻辑“或”运算结果，并进一步计算其基数（`cardinality`）：
+
+```sql
+SELECT c, bitmap_cardinality(GROUP_BITMAP_MERGE_STATE(bitmap_build(v))) AS b
+FROM (
+  VALUES ('a', ARRAY(1)), ('a', ARRAY(2)), ('a', ARRAY(2)), ('b', ARRAY(3)), ('b', NULL)
+) AS t(c, v)
+GROUP BY c;
++---+---+
+| c | b |
++---+---+
+| a | 2 |
+| b | 1 |
++---+---+
+```
+
+在这个查询中，我们创建了一个包含分类 `c` 和与之对应的位图值 `v` 的表。然后，我们使用 `GROUP_BITMAP_MERGE_STATE` 函数对每个分类下的位图值进行合并。对于分类 `a`，合并后的位图包含了 `[1, 2]`；对于分类 `b`，合并后的位图包含了 `[3]`。最终，查询结果将显示每个分类的合并位图的基数。

package/bin/skills/lakehouse-doc/references/sql_functions/aggregate_functions/group_bitmap_or.md

@@ -0,0 +1,44 @@
+# GROUP_BITMAP_OR函数
+
+## 简介
+
+`GROUP_BITMAP_OR` 函数用于对一组 `Bitmap` 数据进行按位或（`OR`）操作，并返回最终结果。该函数在处理大规模数据集时非常高效，尤其适用于需要对多个 `Bitmap` 进行并集操作的场景。它可以直接返回最终的 `Bitmap` 结果，而无需中间状态。
+
+## 语法
+
+```sql
+group_bitmap_or(bitmap)
+```
+
+## 参数
+
+* `bitmap`：`BITMAP` 类型的表达式，表示需要进行按位或操作的 `Bitmap` 数据。
+
+## 返回值
+
+返回一个 `INT` 类型的结果，表示所有输入 `Bitmap` 的按位或操作的结果。
+
+## 使用示例
+
+### 示例 1：计算多个 `Bitmap` 的按位或操作
+
+假设有一个数据表 `t`，其中包含列 `v`，存储了多个数组。现在需要计算这些数组的按位或操作的结果。
+
+```sql
+SELECT group_bitmap_or(bitmap_build(v)) AS res
+FROM VALUES
+  (ARRAY(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)),
+  (ARRAY(6, 7, 8, 9, 10, 11, 12, 13, 14, 15)),
+  (ARRAY(2, 4, 6, 8, 10, 12))
+AS t(v);
++-----+
+| res |
++-----+
+| 15  |
++-----+
+```
+
+## 注意事项
+
+1. **输入类型**：请确保输入的 `bitmap` 是 `BITMAP` 类型，否则会导致函数执行失败。
+2. **客户端支持**：客户端可能不支持直接打印 `BITMAP` 类型的结果。如果需要查看结果，可以使用 `bitmap_to_array` 函数将 `Bitmap` 转换为数组形式。

package/bin/skills/lakehouse-doc/references/sql_functions/aggregate_functions/group_bitmap_or_state.md

@@ -0,0 +1,64 @@
+# GROUP_BITMAP_OR_STATE 函数
+
+## 简介
+
+`GROUP_BITMAP_OR_STATE` 函数用于对一组 `Bitmap` 数据进行按位或（`OR`）操作，并返回中间状态的 `bitmap`。该函数在处理大规模数据集时非常高效，尤其适用于需要对多个 `Bitmap` 进行并集操作的场景。返回的中间状态可以用于后续的合并操作，从而实现更复杂的聚合逻辑。
+
+## 语法
+
+```sql
+group_bitmap_or_state(bitmap)
+```
+
+## 参数
+
+* `bitmap`：`BITMAP` 类型的表达式，表示需要进行按位或操作的 `Bitmap` 数据。
+
+## 返回值
+
+返回一个中间状态的 `BITMAP` 对象，表示按位或操作的中间结果。该中间状态可以用于后续的合并操作。
+
+## 使用示例
+
+示例 1：基本用法
+
+```sql
+SELECT bitmap_to_array(group_bitmap_or_state(bitmap_build(v))) AS res
+FROM VALUES
+  (ARRAY(1, 2, 3)),
+  (ARRAY(1, 2)),
+  (ARRAY(1))
+AS t(v);
++---------+
+|   res   |
++---------+
+| [1,2,3] |
++---------+
+```
+
+**结果**：
+返回一个中间状态的 `Bitmap` 对象，表示按位或操作的中间结果。
+
+示例 2：与 `group_bitmap_merge` 结合使用
+
+`group_bitmap_merge` 函数用于合并多个中间状态的 `Bitmap` 对象，最终生成一个完整的 `Bitmap`。
+
+```sql
+SELECT group_bitmap_merge(or_state) AS final_bitmap
+FROM (
+  SELECT group_bitmap_or_state(bitmap_build(v)) AS or_state
+  FROM VALUES
+    (ARRAY(1, 2, 3)),
+    (ARRAY(1, 2)),
+    (ARRAY(1))
+  AS t(v)
+);
++--------------+
+| final_bitmap |
++--------------+
+| 3            |
++--------------+
+```
+
+**结果**：
+返回一个完整的 `Bitmap`，表示所有输入 `Bitmap` 的按位或操作的结果。

package/bin/skills/lakehouse-doc/references/sql_functions/aggregate_functions/group_bitmap_state.md

@@ -0,0 +1,27 @@
+### GROUP_BITMAP_STATE 函数
+
+#### 功能描述
+`GROUP_BITMAP_STATE` 函数用于根据输入的表达式（`expr`）构建一个 `BITMAP` 类型的结果。该函数通常用于对整数类型的数据进行分组操作，并将每个分组的唯一值转换为一个 `bitmap` 数组。
+
+#### 参数说明
+- `expr`：待处理的整数类型表达式。
+
+#### 返回类型
+- 返回一个 `BITMAP` 类型的结果。
+
+#### 使用示例
+以下是一个使用 `group_bitmap_state` 函数的示例。我们有一个包含两列的数据表，分别为 `c` 和 `v`。我们希望根据 `c` 列的值进行分组，并将 `v` 列中每个分组的唯一值转换为一个 `bitmap` 数组。
+
+```sql
+SELECT c, bitmap_to_array(group_bitmap_state(v)) AS bitmap_array
+FROM VALUES ('a', 1), ('a', 2), ('a', 2), ('b', 3) AS v(c, v)
+GROUP BY c;
++-+--+--------------+
+| c  | bitmap_array |
++----+--------------+
+| a  | [1,2]        |
+| b  | [3]          |
++----+--------------+
+```
+
+在这个示例中，我们可以看到 `a` 分组包含两个唯一值 1 和 2，因此返回的 `bitmap` 数组为 `[1,2]`。而 `b` 分组只包含一个唯一值 3，所以返回的 `bitmap` 数组为 `[3]`。

package/bin/skills/lakehouse-doc/references/sql_functions/aggregate_functions/group_bitmap_xor.md

@@ -0,0 +1,45 @@
+# GROUP_BITMAP_XOR 函数
+
+## 简介
+
+`GROUP_BITMAP_XOR` 函数用于对一组 `Bitmap` 数据进行按位异或（`XOR`）操作，并返回最终结果。该函数在处理大规模数据集时非常高效，尤其适用于需要对多个 `Bitmap` 进行异或操作的场景。它可以直接返回最终的 `Bitmap` 结果，而无需中间状态。
+
+## 语法
+
+```sql
+group_bitmap_xor(bitmap)
+```
+
+## 参数
+
+* `bitmap`：`BITMAP` 类型的表达式，表示需要进行按位异或操作的 `Bitmap` 数据。
+
+## 返回值
+
+返回一个 `INT` 类型的结果，表示所有输入 `Bitmap` 的按位异或操作的结果。
+
+## 使用示例
+
+示例 1：计算多个 `Bitmap` 的按位异或操作
+
+假设有一个数据表 `t`，其中包含列 `v`，存储了多个数组。现在需要计算这些数组的按位异或操作的结果。
+
+```sql
+SELECT group_bitmap_xor(bitmap_build(v)) AS res
+FROM VALUES
+  (ARRAY(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)),
+  (ARRAY(6, 7, 8, 9, 10, 11, 12, 13, 14, 15)),
+  (ARRAY(2, 4, 6, 8, 10, 12))
+AS t(v);
++-----+
+| res |
++-----+
+| 10  |
++-----+
+```
+
+## 注意事项
+
+1. **输入类型**：请确保输入的 `bitmap` 是 `BITMAP` 类型，否则会导致函数执行失败。
+2. **客户端支持**：客户端可能不支持直接打印 `BITMAP` 类型的结果。如果需要查看结果，可以使用 `bitmap_to_array` 函数将 `Bitmap` 转换为数组形式。
+3. **结果解释**：按位异或操作的结果表示所有输入 `Bitmap` 中仅出现一次的元素。如果输入的 `Bitmap` 中有重复元素，结果中将不包含这些元素。