@clickzetta/cz-cli-darwin-x64 0.3.1

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

@@ -0,0 +1,64 @@
+### JSON_EXTRACT 函数系列
+
+#### 简介
+JSON_EXTRACT 函数系列旨在从 JSON 格式的数据中提取特定元素。这些函数根据提供的 JSON 路径（json_path）从 JSON 对象或数组中提取信息，并将结果返回为相应的数据类型。当指定的元素不存在时，函数返回 NULL。
+
+#### JSON 路径规范
+JSON 路径是一种简洁的查询语法，用于访问 JSON 数据结构中的元素。以下是一些常用的 JSON 路径符号：
+
+- `$`：表示根元素。
+- `.key` 或 `[key]`：用于查找 JSON 对象中的键（key）。特别地，`[*]` 表示获取所有键对应的值。
+- `[index]`：用于根据索引（index）访问 JSON 数组的元素，索引从 0 开始。特别地，`[*]` 表示获取数组中的所有元素。
+
+#### 函数列表
+- `json_extract(json, json_path)`：从 JSON 数据中提取指定的元素，并返回 JSON 格式的结果。
+- `json_extract_boolean(json, json_path)`：从 JSON 数据中提取指定的元素，并将其转换为布尔值（BOOLEAN）。
+- `json_extract_int(json, json_path)`：从 JSON 数据中提取指定的元素，并将其转换为整数（INT）。
+- `json_extract_bigint(json, json_path)`：从 JSON 数据中提取指定的元素，并将其转换为大整数（BIGINT）。
+- `json_extract_float(json, json_path)`：从 JSON 数据中提取指定的元素，并将其转换为浮点数（FLOAT）。
+- `json_extract_double(json, json_path)`：从 JSON 数据中提取指定的元素，并将其转换为双精度浮点数（DOUBLE）。
+- `json_extract_string(json, json_path)`：从 JSON 数据中提取指定的元素，并将其转换为字符串（STRING）。
+- `json_extract_date(json, json_path)`：从 JSON 数据中提取指定的元素，并将其转换为日期（DATE）。
+- `json_extract_timestamp(json, json_path)`：从 JSON 数据中提取指定的元素，并将其转换为时间戳（TIMESTAMP）。
+
+#### 参数说明
+- `json`：要处理的 JSON 类型数据。
+- `json_path`：用于指定要提取元素的 JSON 路径的字符串。
+
+#### 返回结果
+- 对于 `json_extract_json` 函数，返回提取到的 JSON 格式数据。
+- 对于其他函数（如 `json_extract_boolean` 等），返回提取到的数据转换为指定数据类型的值。
+
+#### 使用示例
+1. 提取 JSON 对象中的嵌套元素：
+   ```sql
+   SELECT json_extract(json'{"a": {"b": 1}}', '$.a');
+   -- 输出：{"b":1}
+   ```
+
+2. 提取 JSON 对象中带有点的键：
+   ```sql
+   SELECT json_extract(json'{"key": 1, "key.with.dot": 2}', '$.key'),
+         json_extract(json'{"key": 1, "key.with.dot": 2}', "$['key.with.dot']");
+   -- 输出：1       2
+   ```
+
+3. 提取 JSON 数组中的所有元素：
+   ```sql
+   SELECT json_extract(json'[1, 2, 3]', '$[*]');
+   -- 输出：[1,2,3]
+   ```
+
+4. 将提取到的 JSON 元素转换为整数：
+   ```sql
+   SELECT json_extract_int(json'{"a": {"b": 1}}', '$.a.b');
+   -- 输出：1
+   ```
+
+5. 将提取到的 JSON 元素转换为布尔值：
+   ```sql
+   SELECT json_extract_boolean(json'{"a": {"b": 1}}', '$.a.b');
+   -- 输出：true
+   ```
+
+通过以上示例，您可以更深入地了解 JSON_EXTRACT 函数系列的使用方法和功能。这些函数为您提供了灵活且高效的方式来处理和分析 JSON 数据。

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

@@ -0,0 +1,28 @@
+### JSON_MINIFY
+```sql
+json_minify(json)
+```
+#### 功能
+压缩 JSON 字符串，移除多余的空格和换行符。
+
+#### 参数
+* `json`：string 类型的表达式
+
+#### 返回结果
+* string 类型，返回压缩后的 JSON 字符串。
+
+#### 举例
+```sql
+> SELECT json_minify('{ "a": 1, "b": 2 }');
+{"a":1,"b":2}
+
+> SELECT json_minify('[
+    "a",
+    "b",
+    "c"
+]');
+["a","b","c"]
+```
+#### 说明
+* 主要用于移除 JSON 字符串中的格式化空白字符。
+* 不改变 JSON 的内容和结构，仅压缩格式。

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

@@ -0,0 +1,36 @@
+### JSON_NORMALIZE
+```sql
+json_normalize(json)
+```
+#### 功能
+规范化 JSON 字符串，将 JSON 对象的键按字母顺序排序，并移除多余的空格。
+
+#### 参数
+* json : string 类型的表达式
+
+#### 返回结果
+* string 类型，返回规范化后的 JSON 字符串
+* 如果输入为 NULL 或无效的 JSON，返回 NULL
+
+#### 举例
+```sql
+> SELECT json_normalize('{"b": 1, "a": 2, "c": 3}');
+{"a":2,"b":1,"c":3}
+
+> SELECT json_normalize('[{"a": 4, "c": 5, "b": 6}]');
+[{"a":4,"b":6,"c":5}]
+
+> SELECT json_normalize('1');
+1
+
+> SELECT json_normalize(null);
+NULL
+
+> SELECT json_normalize('[');
+NULL
+```
+#### 说明
+* 对 JSON 对象的键进行字母排序，便于比较和去重
+* 会递归处理嵌套的 JSON 对象和数组
+* 对于非对象类型（如数字、字符串等），直接返回原值的压缩形式
+* 对于无效的 JSON 字符串，返回 NULL

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

@@ -0,0 +1,37 @@
+### JSON_OBJECT
+```sql
+json_object([key1, val1, key2, val2, ...])
+```
+#### 功能
+构造一个 JSON 对象。接受偶数个参数，成对地将它们转换为键值对。
+
+#### 参数
+* key1, val1, key2, val2, ... : 可选参数，成对出现。key 为字符串类型，val 可以是任意类型。
+
+#### 返回结果
+* JSON 类型，表示 JSON 对象
+
+#### 举例
+```sql
+> SELECT json_object();
+{}
+
+> SELECT json_object("a-null", NULL);
+{"a-null":null}
+
+> SELECT json_object('hello', 123, "world", timestamp '2020-10-10 00:00:00');
+{"hello":123,"world":"2020-10-10 00:00:00"}
+
+> SELECT json_object('hello', 123, "world", array(1, 2, 3));
+{"hello":123,"world":[1,2,3]}
+
+> SELECT json_object('hello', json_array(1, "a"), "world", array(1, 2, 3));
+{"hello":[1,"a"],"world":[1,2,3]}
+
+> SELECT json_object('hello', json_object("nested", "b"), "world", struct(1, 2, 3));
+{"hello":{"nested":"b"},"world":{"col1":1,"col2":2,"col3":3}}
+```
+#### 说明
+* 必须提供偶数个参数，否则会报错。
+* 支持嵌套的 JSON 对象和数组。
+* 可以接受复杂类型（如 array、struct 等），它们会自动转换为 JSON 格式。

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

@@ -0,0 +1,59 @@
+### JSON_PARSE 函数
+
+#### 简介
+`JSON_PARSE` 函数用于将 JSON 格式的字符串解析为 JSON 类型。解析后的 JSON 类型在输出时会自动去除多余的空格，且不保证字段（field）的顺序与原始 JSON 字符串完全一致。`PARSE_JSON` 是 `JSON_PARSE` 函数的别名，两者功能相同。
+
+#### 语法
+```
+json_parse(str)
+parse_json(str)
+```
+
+#### 参数
+- `str`: 需要解析的 JSON 格式字符串。
+
+#### 返回结果
+- 返回解析后的 JSON 类型。
+
+#### 使用示例
+
+**示例 1**：解析简单的 JSON 字符串
+```sql
+SELECT json_parse('{"name": "张三", "age": 25}');
+```
+返回结果：
+```json
+{"name":"张三","age":25}
+```
+
+**示例 2**：解析嵌套的 JSON 字符串
+```sql
+SELECT json_parse('{"user":{"name":"李四","age":30},"info":{"city":"北京","country":"中国"}}');
+```
+返回结果：
+```json
+{"user":{"name":"李四","age":30},"info":{"city":"北京","country":"中国"}}
+```
+
+**示例 3**：解析包含数组的 JSON 字符串
+```sql
+select parse_json('{"fruits":["苹果","香蕉","橙子"],"vegetables":["白菜","萝卜"]}') as res;
+```
+返回结果：
+```json
+{"fruits":["苹果","香蕉","橙子"],"vegetables":["白菜","胡萝卜"]}
+```
+
+**示例 4**：解析含有数字和布尔值的 JSON 字符串
+```sql
+SELECT json_parse('{"score":85.5,true_false:true,"count":-100}');
+```
+返回结果：
+```json
+{"score":85.5,"true_false":true,"count":-100}
+```
+
+#### 注意事项
+- 确保输入的字符串为有效的 JSON 格式，否则可能导致解析失败。
+- 在处理复杂的 JSON 字符串时，请注意字符串的缩进和引号使用，以确保正确解析。
+- 由于 JSON 类型在输出时会自动去除多余空格，因此输出结果中的字段顺序可能与原始输入有所不同。

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

@@ -0,0 +1,36 @@
+
+###  JSON_REMOVE
+``` sql
+json_remove(jsonObj, jsonPath)
+```
+#### 功能
+将满足jsonPath的元素从jsonObject中删除，返回剩余的元素
+* jsonPath 不支持通配符
+* 如果jsonPath不存在，则返回原始jsonObj
+
+#### 参数
+* jsonObj: json
+* jsonPath: string
+
+#### 返回结果
+* json
+
+#### 举例
+```sql
+> select parse_json(j), json_remove(parse_json(j), '$.b'), json_remove(parse_json(j), '$.b.c')
+  from values
+  ('{}'),
+  ('{"a":1}'),
+  ('{"a":2, "b":"y"}'),
+  ('{"a":3, "b":{"c":"x"}}'),
+  ('{"b":"y"}'),
+  (null),
+  ('{"c":3}')
+  as t(j);
+{}      {}      {}
+{"a":1} {"a":1} {"a":1}
+{"a":2,"b":"y"} {"a":2} {"a":2,"b":"y"}
+{"a":3,"b":{"c":"x"}}   {"a":3} {"a":3,"b":{}}
+{"b":"y"}       {}      {"b":"y"}
+NULL    NULL    NULL
+{"c":3} {"c":3} {"c":3}

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

@@ -0,0 +1,44 @@
+### JSON_TYPE
+```sql
+json_type(json)
+```
+#### 功能
+返回 JSON 值的类型。
+
+#### 参数
+* json : json 类型的表达式
+
+#### 返回结果
+* string 类型，返回以下值之一：
+  * `JSON_NULL` - JSON null 值
+  * `JSON_BOOLEAN` - JSON 布尔值
+  * `JSON_INTEGER` - JSON 整数
+  * `JSON_DOUBLE` - JSON 浮点数
+  * `JSON_STRING` - JSON 字符串
+  * `JSON_ARRAY` - JSON 数组
+  * `JSON_OBJECT` - JSON 对象
+  * `NULL` - 输入为 NULL 或无效 JSON
+
+#### 举例
+```sql
+> SELECT json_type(json_parse('null'));
+JSON_NULL
+
+> SELECT json_type(json_parse('true'));
+JSON_BOOLEAN
+
+> SELECT json_type(json_parse('1'));
+JSON_INTEGER
+
+> SELECT json_type(json_parse('1.1'));
+JSON_DOUBLE
+
+> SELECT json_type(json_parse('"a"'));
+JSON_STRING
+
+> SELECT json_type(json_parse('[1,2,3]'));
+JSON_ARRAY
+
+> SELECT json_type(json_parse('{"a":1, "b":{"c":"x","d": "x"}}'));
+JSON_OBJECT
+```

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

@@ -0,0 +1,46 @@
+## 函数名称
+`json_valid`
+
+## 功能描述
+`json_valid` 函数用于验证给定的字符串是否符合 JSON 格式规范。需要注意的是，某些字符串（如 `'1'`）虽然表示合法的 JSON 数字，但它们本身作为字符串并不直接符合 JSON 格式要求。使用此函数可以确保字符串是一个有效的 JSON 对象或数组。
+
+## 参数说明
+- `str`: 待验证的字符串。
+
+## 返回值
+返回一个布尔值，表示输入字符串是否为合法的 JSON 格式。
+
+- `true`: 输入字符串为合法的 JSON 格式。
+- `false`: 输入字符串不是合法的 JSON 格式。
+
+## 使用示例
+以下示例展示了如何使用 `json_valid` 函数来判断不同字符串是否符合 JSON 格式。
+
+```sql
+-- 合法的 JSON 数字
+SELECT json_valid('1') AS t;
+
+-- 合法的 JSON 对象
+SELECT json_valid('{}') AS t;
+
+-- 合法的 JSON 数组
+SELECT json_valid('[]') AS t;
+
+-- 合法的 JSON 对象，包含键值对
+SELECT json_valid('{"a": 1}') AS t;
+
+-- 不合法的 JSON 格式（空的键名）
+SELECT json_valid('{[]}') AS f;
+
+-- 合法的 JSON 数组，包含对象
+SELECT json_valid('[{}]') AS t;
+
+-- 字符串表示一个合法的 JSON 数字，但作为字符串不满足 JSON 格式要求
+SELECT json_valid('"1"') AS f;
+```
+
+## 结果解释
+- `true` 表示输入字符串是一个合法的 JSON 格式。
+- `false` 表示输入字符串不是一个合法的 JSON 格式。
+
+通过上述示例，您可以了解如何使用 `json_valid` 函数来验证各种字符串是否符合 JSON 格式要求。这在处理 JSON 数据时非常有用，可以确保数据的准确性和有效性。

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

@@ -0,0 +1,79 @@
+## JSON Schema提取函数
+
+### 功能描述
+
+`schema_of_json` 函数用于从给定的 JSON 字符串中解析并生成对应的 DDL schema。该函数可以帮助用户快速理解 JSON 数据的结构，便于后续的数据操作和处理。
+
+### 语法格式
+
+```
+schema_of_json(str)
+```
+
+### 参数说明
+
+- `str`: 需要解析的 JSON 格式字符串。
+
+### 返回结果
+
+- 返回一个表示 JSON 数据结构的字符串，格式为 DDL schema。
+
+### 使用示例
+
+以下是一个使用 `schema_of_json` 函数的示例：
+
+```sql
+SELECT schema_of_json(' {
+  "n": null,
+  "s": "hello",
+  "i": 123,
+  "f": 123.0,
+  "a": [ null, 123 ],
+  "m": {},
+  "st": {"a": "s"}
+} ');
+```
+
+函数返回结果：
+
+```
+struct<n:null,s:string,i:bigint,f:double,a:array<bigint>,m:map<string,string>,st:struct<a:string>>
+```
+
+### 更多示例
+
+1. 从包含日期的 JSON 字符串中提取 schema：
+
+   ```sql
+   SELECT schema_of_json(' {
+     "name": "John",
+     "age": 30,
+     "birthdate": "1991-01-22"
+   } ');
+   ```
+
+   返回结果：
+
+   ```
+   struct<name:string,age:bigint,birthdate:date>
+   ```
+
+2. 从嵌套的 JSON 字符串中提取 schema：
+
+   ```sql
+   SELECT schema_of_json(' {
+     "company": "Example Inc.",
+     "employees": [
+       {"name": "Alice", "position": "Developer"},
+       {"name": "Bob", "position": "Manager"}
+     ]
+   } ');
+   ```
+
+   返回结果：
+
+   ```
+   struct<company:string,employees:array<struct<name:string,position:string>>>
+   ```
+
+通过以上示例，您可以看到 `schema_of_json` 函数可以灵活地处理各种 JSON 数据结构，并生成相应的 DDL schema。这使得用户能够更轻松地理解和操作 JSON 数据。

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

@@ -0,0 +1,68 @@
+### TO\_JSON 函数
+
+#### 概述
+
+`TO_JSON` 函数用于将指定的表达式（expr）转换为 JSON 格式的文本。该函数能够处理各种数据类型，并将它们映射到相应的 JSON 类型。这对于在 SQL 查询中处理和输出 JSON 数据非常有用。
+
+#### 类型映射关系
+
+以下是 LakeHouse 数据类型与 JSON 类型之间的对应关系：
+
+* `struct` 和 `map`：转换为 JSON 对象（object）
+* `array`：转换为 JSON 数组（array）
+* `tinyint`、`smallint`、`int`、`bigint`、`float`、`double`：转换为 JSON 数值（numeric）
+* `boolean`：转换为 JSON 布尔值（boolean）
+* `string`：转换为 JSON 字符串（string）
+* `date`、`datetime`：转换为 JSON 字符串，格式为日期或日期时间
+* `null`：转换为 JSON  null 值
+
+需要注意的是，对于 `decimal` 类型，在转换为 JSON 时会以 `double` 类型输出，可能会丢失精度。此外，对于 `map<K, V>` 类型，如果 K 不是 `string`、`char` 或 `varchar` 类型，系统会先将其转换为字符串形式，再进行输出。这是因为 JSON 对象的键（key）必须为字符串类型。
+
+#### 函数语法
+
+```
+TO_JSON(expr)
+```
+
+#### 参数说明
+
+* `expr`：任意类型的表达式。
+
+#### 返回结果
+
+* 返回类型：字符串（string）
+
+#### 使用示例
+
+以下示例展示了如何使用 `TO_JSON` 函数处理不同类型的数据：
+
+1. 将数组映射为 JSON 对象：
+   ```sql
+   SELECT TO_JSON(MAP(ARRAY(1, 2), 2));
+   -- 输出：{"[1,2]":2}
+   ```
+
+2. 将 JSON 字符串直接输出：
+   ```sql
+   SELECT TO_JSON(JSON '{"a": 1}');
+   -- 输出：{"a": 1}
+   ```
+
+3. 将结构体转换为 JSON 对象：
+   ```sql
+   SELECT TO_JSON(NAMED_STRUCT( 'id',1, 'name','John Doe' ));
+   -- 输出：{"id":1,"name":"John Doe"}
+   ```
+
+4. 将 `null` 值转换为 JSON  null：
+   ```sql
+   SELECT TO_JSON(NULL);
+   --输出空字符串
+   +---------------+
+   | TO_JSON(NULL) |
+   +---------------+
+   |               |
+   +---------------+
+   ```
+
+通过以上示例，您可以看到 `TO_JSON` 函数在处理不同类型的数据时的灵活性和实用性。这使得在 SQL 查询中处理 JSON 数据变得更加简单和高效。

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

@@ -0,0 +1,46 @@
+### ABS 函数
+#### 简介
+`ABS` 函数用于计算给定数值表达式的绝对值。无论输入的数值是正数还是负数，`ABS` 函数都能返回相应的非负值。
+
+#### 语法
+```sql
+ABS(expr)
+```
+#### 参数
+- `expr`: 需要计算绝对值的数值类型表达式，可以是 `smallint`, `tinyint`, `int`, `bigint`, `decimal`, `double` 或 `float`。
+
+#### 返回结果
+返回参数 `expr` 的绝对值，返回值类型与输入参数类型一致。
+
+#### 使用示例
+1. 计算一个负整数的绝对值：
+   ```sql
+   SELECT ABS(-10); -- 返回结果为 10
+   ```
+2. 计算一个正整数的绝对值：
+   ```sql
+   SELECT ABS(5); -- 返回结果为 5
+   ```
+3. 计算一个小数的绝对值：
+   ```sql
+   SELECT ABS(-3.14); -- 返回结果为 3.14
+   ```
+4. 计算一个带有小数点的负数的绝对值：
+   ```sql
+   SELECT ABS(-0.5); -- 返回结果为 0.5
+   ```
+5. 计算一个 `decimal` 类型的绝对值：
+   ```sql
+   SELECT ABS(-123.456); -- 返回结果为 123.456
+   ```
+6. 在一个查询中使用 `ABS` 函数来获取员工工资的绝对值：
+   ```sql
+   SELECT employee_name, ABS(salary - 100) AS adjusted_salary
+   FROM employees;
+   -- 返回结果中，每名员工的 `adjusted_salary` 将显示为工资与 100 的差值的绝对值
+   ```
+
+#### 注意事项
+- 当 `expr` 为 `NULL` 时，`ABS` 函数将返回 `NULL`。
+- `ABS` 函数可以与其他 SQL 函数结合使用，例如在排序或过滤查询时。
+

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

@@ -0,0 +1,30 @@
+### ACOS
+
+```sql
+
+acos(expr)
+
+```
+
+#### 功能
+
+计算 expr 的反余弦值。
+
+#### 参数
+
+* expr : double 类型，取值范围为 [-1, 1]，其余类型会进行隐式类型转换。
+
+#### 返回结果
+
+double 类型。
+
+#### 举例
+
+```sql
+> SELECT acos(-1);
+0.0
+> SELECT acos(2);
+
+NaN
+
+```

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

@@ -0,0 +1,39 @@
+### ACOSH 函数
+#### 概述
+`ACOSH` 函数用于计算给定数值的反双曲余弦值。该函数接受一个 `DOUBLE` 类型的参数，并返回一个 `DOUBLE` 类型的数值结果。
+
+#### 语法
+```
+ACOSH(expr)
+```
+#### 参数
+- `expr`: 需要计算反双曲余弦值的 `DOUBLE` 类型数值。
+
+#### 返回结果
+返回参数 `expr` 的反双曲余弦值，结果类型为 `DOUBLE`。
+
+#### 使用示例
+1. 计算 `2` 的反双曲余弦值：
+```
+SELECT ACOSH(2); -- 结果约为 1.3169578969248166
+```
+2. 计算 `1` 的反双曲余弦值（结果为 `0`，因为 `1` 是 `ACOSH` 函数的极小值）：
+```
+SELECT ACOSH(1); -- 结果为 0.0
+```
+3. 计算接近于 `0` 的小数值的反双曲余弦值：
+```
+SELECT ACOSH(0.0001); -- 结果约为 NaN
+```
+4. 计算负数的反双曲余弦值（结果为 `NaN`，因为 `ACOSH` 函数只接受正数参数）：
+```
+SELECT ACOSH(-1); -- 结果为 NaN
+```
+5. 在一个查询中对多个数值计算反双曲余弦值：
+```
+SELECT ACOSH(2.5), ACOSH(3.7), ACOSH(0.5); -- 结果分别约为 1.566799236972411, 1.9826969446812033和 NaN
+```
+#### 注意事项
+- `ACOSH` 函数仅接受正数参数。如果传入负数或零，将返回 `NaN`（非数值结果）。
+- 当参数值接近于 `0` 时，反双曲余弦值会变得非常大。在实际应用中，需要注意数值溢出的问题。
+- `ACOSH` 函数与 `COSH` 函数互为逆运算。`COSH` 函数用于计算双曲余弦值，而 `ACOSH` 函数用于计算其逆运算结果。

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

@@ -0,0 +1,39 @@
+### ASIN 函数
+
+#### 功能描述
+`asin` 函数用于计算某个数值的反正弦值，即求出一个正弦值等于给定数值的角。该函数在数学、物理和工程等领域有广泛应用。
+
+#### 语法
+```
+asin(expr)
+```
+#### 参数
+- `expr`: 需要计算反正弦值的数值，类型为 double。
+
+#### 返回结果
+返回计算得到的反正弦值（弧度），类型为 double。
+
+#### 使用说明
+- 当 `expr` 的值在 -1 到 1 之间（包含 -1 和 1）时，`asin` 函数返回一个有效的角度值。
+- 当 `expr` 的值小于 -1 或大于 1 时，`asin` 函数将返回 `NaN`（Not a Number）。
+
+#### 示例
+```
+-- 计算 0 的反正弦值
+> SELECT asin(0);
+0.0
+
+-- 计算 0.5 的反正弦值
+> SELECT asin(0.5);
+0.5235987755982989
+
+-- 计算 -1 的反正弦值
+> SELECT asin(-1);
+-1.5707963267948966
+
+-- 计算大于 1 的数值的反正弦值，返回 NaN
+> SELECT asin(2);
+NaN
+```
+
+通过以上示例，可以看到 `asin` 函数在不同场景下的应用。请注意，当输入的数值不在 -1 到 1 的范围内时，函数将返回 `NaN`。在实际应用中，请确保输入的数值在有效范围内，以避免错误。