@clickzetta/cz-cli-darwin-arm64 0.3.76 → 0.3.80

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

@@ -1,64 +0,0 @@
-### 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

@@ -1,28 +0,0 @@
-### 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

@@ -1,36 +0,0 @@
-### 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

@@ -1,37 +0,0 @@
-### 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

@@ -1,59 +0,0 @@
-### 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

@@ -1,36 +0,0 @@
-
-###  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

@@ -1,44 +0,0 @@
-### 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

@@ -1,46 +0,0 @@
-## 函数名称
-`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

@@ -1,79 +0,0 @@
-## 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

@@ -1,68 +0,0 @@
-### 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

@@ -1,46 +0,0 @@
-### 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

@@ -1,30 +0,0 @@
-### 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

@@ -1,39 +0,0 @@
-### 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

@@ -1,39 +0,0 @@
-### 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`。在实际应用中，请确保输入的数值在有效范围内，以避免错误。