@clickzetta/cz-cli-darwin-x64 0.3.1

package/bin/skills/lakehouse-doc/references/sql_functions/window_functions/last_value.md

@@ -0,0 +1,160 @@
+### LAST_VALUE 函数
+
+#### 功能描述
+排序键相同时`LAST_VALUE` 函数用于返回在指定窗口内的最后一行的某个表达式的值。该函数在数据分析和处理中非常有用，特别是当你需要获取分组内或整个数据集的最后一个非空值时。
+
+#### 参数说明
+- `expr`：任意类型的表达式，其值将被返回。
+- `ignoreNull`（可选）：布尔类型常量，默认值为 `false`。当设置为 `true` 时，函数将忽略窗口内的空值（`NULL`），并返回最后一个非空值。
+
+#### 返回结果
+返回值的类型与 `expr` 参数的类型相同。
+
+1. 基本使用：
+
+   ```sql
+
+   SELECT name, salary, LAST_VALUE(salary) OVER (PARTITION BY salary ) as min_salary
+    FROM VALUES
+     ('Eric', 1, 28000),
+     ('Alex', 1, 32000),
+     ('Felix', 2, 21000),
+     ('Frank', 1, 30000),
+     ('Tom', 2, 23000),
+     ('Jane', 3, 29000),
+     ('Jeff', 3, 35000),
+     ('Paul', 2, 29000),
+     ('Charles', 2, 23000),
+     ('Charles F', 2, 23000),
+     ('null',4,null),
+     ('NotNull',4,23000)
+     AS tab(name, dep_no, salary);
+   +-----------+--------+------------+
+   |   name    | salary | min_salary |
+   +-----------+--------+------------+
+   | null      | null   | null       |
+   | Eric      | 28000  | 28000      |
+   | Jeff      | 35000  | 35000      |
+   | Frank     | 30000  | 30000      |
+   | Felix     | 21000  | 21000      |
+   | Tom       | 23000  | 23000      |
+   | Charles   | 23000  | 23000      |
+   | Charles F | 23000  | 23000      |
+   | NotNull   | 23000  | 23000      |
+   | Jane      | 29000  | 29000      |
+   | Paul      | 29000  | 29000      |
+   | Alex      | 32000  | 32000      |
+   +-----------+--------+------------+
+   ```
+
+2. 忽略 NULL 值：
+
+   在这个例子中，我们将忽略工资为 NULL 的员工。
+
+   ```sql
+   SELECT name, salary, LAST_VALUE(salary,true) OVER (PARTITION BY salary ) as min_salary
+    FROM VALUES
+     ('Eric', 1, 28000),
+     ('Alex', 1, 32000),
+     ('Felix', 2, 21000),
+     ('Frank', 1, 30000),
+     ('Tom', 2, 23000),
+     ('Jane', 3, 29000),
+     ('Jeff', 3, 35000),
+     ('Paul', 2, 29000),
+     ('Charles', 2, 23000),
+     ('Charles F', 2, 23000),
+     ('null',4,null),
+     ('NotNull',4,23000)
+     AS tab(name, dep_no, salary);
+   +-----------+--------+------------+
+   |   name    | salary | min_salary |
+   +-----------+--------+------------+
+   | null      | null   | null       |
+   | Eric      | 28000  | 28000      |
+   | Jeff      | 35000  | 35000      |
+   | Frank     | 30000  | 30000      |
+   | Felix     | 21000  | 21000      |
+   | Tom       | 23000  | 23000      |
+   | Charles   | 23000  | 23000      |
+   | Charles F | 23000  | 23000      |
+   | NotNull   | 23000  | 23000      |
+   | Jane      | 29000  | 29000      |
+   | Paul      | 29000  | 29000      |
+   | Alex      | 32000  | 32000      |
+   +-----------+--------+------------+
+   ```
+
+3. 结合 ORDER BY 使用：
+
+   ```sql
+   SELECT name, salary, LAST_VALUE(salary) OVER (PARTITION BY dep_no ORDER BY dep_no DESC) as min_salary
+    FROM VALUES
+     ('Eric', 1, 28000),
+     ('Alex', 1, 32000),
+     ('Felix', 2, 21000),
+     ('Frank', 1, 30000),
+     ('Tom', 2, 23000),
+     ('Jane', 3, 29000),
+     ('Jeff', 3, 35000),
+     ('Paul', 2, 29000),
+     ('Charles', 2, 23000),
+     ('Charles F', 2, 23000),
+     ('null',4,null),
+     ('NotNull',4,23000)
+     AS tab(name, dep_no, salary);
+   +-----------+--------+------------+
+   |   name    | salary | min_salary |
+   +-----------+--------+------------+
+   | Jane      | 29000  | 35000      |
+   | Jeff      | 35000  | 35000      |
+   | Eric      | 28000  | 30000      |
+   | Alex      | 32000  | 30000      |
+   | Frank     | 30000  | 30000      |
+   | Felix     | 21000  | 23000      |
+   | Tom       | 23000  | 23000      |
+   | Paul      | 29000  | 23000      |
+   | Charles   | 23000  | 23000      |
+   | Charles F | 23000  | 23000      |
+   | null      | null   | 23000      |
+   | NotNull   | 23000  | 23000      |
+   +-----------+--------+------------+
+   ```
+
+4. 使用窗口函数：
+
+   当您需要对整个数据集应用 LAST 函数时，可以使用 ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING 子句。
+
+   ```sql
+   SELECT name, salary, LAST_VALUE(salary, true) OVER (ORDER BY salary ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) as global_min_salary
+    FROM VALUES
+     ('Eric', 1, 28000),
+     ('Alex', 1, 32000),
+     ('Felix', 2, 21000),
+     ('Frank', 1, 30000),
+     ('Tom', 2, 23000),
+     ('Jane', 3, 29000),
+     ('Jeff', 3, 35000),
+     ('Paul', 2, 29000),
+     ('Charles', 2, 23000),
+     ('Charles F', 2, 23000),
+     ('null',4,null),
+     ('NotNull',4,23000)
+     AS tab(name, dep_no, salary);
+   +-----------+--------+-------------------+
+   |   name    | salary | global_min_salary |
+   +-----------+--------+-------------------+
+   | null      | null   | 35000             |
+   | Felix     | 21000  | 35000             |
+   | Tom       | 23000  | 35000             |
+   | Charles   | 23000  | 35000             |
+   | Charles F | 23000  | 35000             |
+   | NotNull   | 23000  | 35000             |
+   | Eric      | 28000  | 35000             |
+   | Jane      | 29000  | 35000             |
+   | Paul      | 29000  | 35000             |
+   | Frank     | 30000  | 35000             |
+   | Alex      | 32000  | 35000             |
+   | Jeff      | 35000  | 35000             |
+   +-----------+--------+-------------------+
+   ```

package/bin/skills/lakehouse-doc/references/sql_functions/window_functions/lead.md

@@ -0,0 +1,49 @@
+### LEAD 函数
+
+#### 简介
+LEAD 函数是窗口函数的一种，用于访问当前行之后指定偏移量的行。通过使用 LEAD 函数，您可以获取当前行向分区尾部方向移动指定行数后对应的表达式的值。这在数据分析和处理中非常有用，例如比较当前行与下一行的数据差异。
+
+#### 语法
+```sql
+LEAD(expr[, offset[, default]]) OVER ([PARTITION BY clause] ORDER BY clause)
+```
+
+#### 参数
+- `expr`: 任意类型的表达式，可以是列名、常量或函数等。
+- `offset`: 可选参数，bigint 类型常量，默认值为 1，表示当前行后面的一行。当 offset 为 0 时，表示当前行本身。
+- `default`: 可选参数，当 offset 超过窗口的边界时使用的缺省值。类型与 expr 相同，默认值为 null。
+
+#### 返回结果
+返回值类型与 expr 相同。
+
+#### 使用示例
+
+1. 基本使用
+```sql
+SELECT a, b, LEAD(b) OVER (PARTITION BY a ORDER BY b) as next_b FROM VALUES ('A', 2), ('A', 1), ('B', 3), ('A', 1) tab(a, b);
+```
+结果：
+```
+A	1	1
+A	1	2
+A	2	null
+B	3	null
+```
+
+2. 使用 offset 和 default 参数
+```sql
+SELECT a, b, LEAD(b, 2, 0) OVER (PARTITION BY a ORDER BY b) as next_b FROM VALUES ('A', 2), ('A', 1), ('B', 3), ('A', 1) tab(a, b);
+```
+结果：
+```
+A	1	2
+A	1	0
+A	2	0
+B	3	0
+```
+
+
+#### 注意事项
+- 当 offset 值超出窗口边界时（例如，当前行之后没有足够的行），LEAD 函数将返回 default 参数指定的值。
+- LEAD 函数通常与窗口函数的 ORDER BY 子句一起使用，以确定如何访问相关行。
+- 在使用 LEAD 函数时，请确保正确设置 PARTITION BY 子句，以便正确地对数据进行分区。

package/bin/skills/lakehouse-doc/references/sql_functions/window_functions/max.md

@@ -0,0 +1,167 @@
+### MAX 函数
+
+```sql
+max(expr) OVER ([partition_clause] [orderby_clause] [frame_clause])
+```
+
+#### 功能描述
+
+MAX 函数用于计算并返回指定表达式（expr）在窗口范围内的最大值。该函数常用于数据分析和统计，以便快速获取某个分组或整体数据的最大值。
+
+#### 参数说明
+
+* **expr**: 需要计算最大值的表达式，可以是数值类型、字符串类型、时间类型等可比较的类型。
+
+#### 返回结果
+
+返回值的类型与传入的表达式类型相同。
+
+#### 使用示例
+
+**示例 1：简单使用**
+
+```sql
+SELECT name, dep_no, salary, MAX(salary) OVER () AS max_salary FROM VALUES
+  ('Eric', 1, 28000),
+  ('Alex', 1, 32000),
+  ('Felix', 2, 21000),
+  ('Frank', 1, 30000),
+  ('Tom', 2, 23000),
+  ('Jane', 3, 29000),
+  ('Jeff', 3, 35000),
+  ('Paul', 2, 29000),
+  ('Charles', 2, 23000),
+  ('Charles F', 2, 23000),
+  ('null',4,null),
+  ('NotNull',4,23000)
+  AS tab(name, dep_no, salary);
++-----------+--------+--------+------------+
+|   name    | dep_no | salary | max_salary |
++-----------+--------+--------+------------+
+| Eric      | 1      | 28000  | 35000      |
+| Alex      | 1      | 32000  | 35000      |
+| Felix     | 2      | 21000  | 35000      |
+| Frank     | 1      | 30000  | 35000      |
+| Tom       | 2      | 23000  | 35000      |
+| Jane      | 3      | 29000  | 35000      |
+| Jeff      | 3      | 35000  | 35000      |
+| Paul      | 2      | 29000  | 35000      |
+| Charles   | 2      | 23000  | 35000      |
+| Charles F | 2      | 23000  | 35000      |
+| null      | 4      | null   | 35000      |
+| NotNull   | 4      | 23000  | 35000      |
++-----------+--------+--------+------------+
+```
+
+上述 SQL 语句将返回 employees 表中所有员工的最大工资。
+
+**示例 2：按部门分组**
+
+```sql
+SELECT dep_no, salary, MAX(salary) OVER (PARTITION BY dep_no) AS max_salary_by_department FROM VALUES
+  ('Eric', 1, 28000),
+  ('Alex', 1, 32000),
+  ('Felix', 2, 21000),
+  ('Frank', 1, 30000),
+  ('Tom', 2, 23000),
+  ('Jane', 3, 29000),
+  ('Jeff', 3, 35000),
+  ('Paul', 2, 29000),
+  ('Charles', 2, 23000),
+  ('Charles F', 2, 23000),
+  ('null',4,null),
+  ('NotNull',4,23000)
+  AS tab(name, dep_no, salary);
++--------+--------+--------------------------+
+| dep_no | salary | max_salary_by_department |
++--------+--------+--------------------------+
+| 3      | 29000  | 35000                    |
+| 3      | 35000  | 35000                    |
+| 1      | 28000  | 32000                    |
+| 1      | 32000  | 32000                    |
+| 1      | 30000  | 32000                    |
+| 2      | 21000  | 29000                    |
+| 2      | 23000  | 29000                    |
+| 2      | 29000  | 29000                    |
+| 2      | 23000  | 29000                    |
+| 2      | 23000  | 29000                    |
+| 4      | null   | 23000                    |
+| 4      | 23000  | 23000                    |
++--------+--------+--------------------------+
+```
+
+该语句将返回每个部门员工的最高工资。
+
+**示例 3：结合排序**
+
+```sql
+SELECT name, salary, MAX(salary) OVER (ORDER BY salary DESC) AS max_salary_after FROM VALUES
+  ('Eric', 1, 28000),
+  ('Alex', 1, 32000),
+  ('Felix', 2, 21000),
+  ('Frank', 1, 30000),
+  ('Tom', 2, 23000),
+  ('Jane', 3, 29000),
+  ('Jeff', 3, 35000),
+  ('Paul', 2, 29000),
+  ('Charles', 2, 23000),
+  ('Charles F', 2, 23000),
+  ('null',4,null),
+  ('NotNull',4,23000)
+  AS tab(name, dep_no, salary);
++-----------+--------+------------------+
+|   name    | salary | max_salary_after |
++-----------+--------+------------------+
+| Jeff      | 35000  | 35000            |
+| Alex      | 32000  | 35000            |
+| Frank     | 30000  | 35000            |
+| Jane      | 29000  | 35000            |
+| Paul      | 29000  | 35000            |
+| Eric      | 28000  | 35000            |
+| Tom       | 23000  | 35000            |
+| Charles   | 23000  | 35000            |
+| Charles F | 23000  | 35000            |
+| NotNull   | 23000  | 35000            |
+| Felix     | 21000  | 35000            |
+| null      | null   | 35000            |
++-----------+--------+------------------+
+```
+
+在这个例子中，我们将员工按工资降序排列，并获取每个员工之后的最大工资值。
+
+**示例 4：使用窗口函数**
+
+```sql
+SELECT name, dep_no, salary,
+ MAX(salary) OVER (PARTITION BY dep_no ORDER BY salary DESC ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) AS top_two_salary
+ FROM VALUES
+  ('Eric', 1, 28000),
+  ('Alex', 1, 32000),
+  ('Felix', 2, 21000),
+  ('Frank', 1, 30000),
+  ('Tom', 2, 23000),
+  ('Jane', 3, 29000),
+  ('Jeff', 3, 35000),
+  ('Paul', 2, 29000),
+  ('Charles', 2, 23000),
+  ('Charles F', 2, 23000),
+  ('null',4,null),
+  ('NotNull',4,23000)
+  AS tab(name, dep_no, salary);
++-----------+--------+--------+----------------+
+|   name    | dep_no | salary | top_two_salary |
++-----------+--------+--------+----------------+
+| Jeff      | 3      | 35000  | 35000          |
+| Jane      | 3      | 29000  | 35000          |
+| Alex      | 1      | 32000  | 32000          |
+| Frank     | 1      | 30000  | 32000          |
+| Eric      | 1      | 28000  | 30000          |
+| Paul      | 2      | 29000  | 29000          |
+| Tom       | 2      | 23000  | 29000          |
+| Charles   | 2      | 23000  | 23000          |
+| Charles F | 2      | 23000  | 23000          |
+| Felix     | 2      | 21000  | 23000          |
+| NotNull   | 4      | 23000  | 23000          |
+| null      | 4      | null   | 23000          |
++-----------+--------+--------+----------------+
+```

package/bin/skills/lakehouse-doc/references/sql_functions/window_functions/min.md

@@ -0,0 +1,138 @@
+### MIN 函数
+
+```sql
+MIN(expr) OVER ([PARTITION BY clause] [ORDER BY clause] [FRAME clause])
+```
+
+#### 功能描述
+
+MIN 函数用于计算并返回窗口内指定表达式（expr）的最小值。该函数常用于数据分析和处理，以便快速获取某个特定分组内的最小数据。
+
+#### 参数说明
+
+* `expr`: 需要计算最小值的表达式，可以是数值类型、字符串类型、时间类型等可比较的类型。
+
+#### 返回结果
+
+* 返回值类型与传入的 `expr` 参数类型相同。
+
+#### 使用示例
+
+**示例 1：简单使用**
+
+```sql
+
+SELECT name, dep_no, salary, MIN(salary) OVER (PARTITION BY dep_no) AS min_salary
+ FROM VALUES
+  ('Eric', 1, 28000),
+  ('Alex', 1, 32000),
+  ('Felix', 2, 21000),
+  ('Frank', 1, 30000),
+  ('Tom', 2, 23000),
+  ('Jane', 3, 29000),
+  ('Jeff', 3, 35000),
+  ('Paul', 2, 29000),
+  ('Charles', 2, 23000),
+  ('Charles F', 2, 23000),
+  ('null',4,null),
+  ('NotNull',4,23000)
+  AS tab(name, dep_no, salary);
++-----------+--------+--------+------------+
+|   name    | dep_no | salary | min_salary |
++-----------+--------+--------+------------+
+| Jane      | 3      | 29000  | 29000      |
+| Jeff      | 3      | 35000  | 29000      |
+| Eric      | 1      | 28000  | 28000      |
+| Alex      | 1      | 32000  | 28000      |
+| Frank     | 1      | 30000  | 28000      |
+| Felix     | 2      | 21000  | 21000      |
+| Tom       | 2      | 23000  | 21000      |
+| Paul      | 2      | 29000  | 21000      |
+| Charles   | 2      | 23000  | 21000      |
+| Charles F | 2      | 23000  | 21000      |
+| null      | 4      | null   | 23000      |
+| NotNull   | 4      | 23000  | 23000      |
++-----------+--------+--------+------------+
+```
+
+上述 SQL 查询语句将返回每个部门的员工姓名、部门编号、薪资以及该部门的最低薪资。
+
+**示例 2：结合 ORDER BY 子句**
+
+```sql
+SELECT name, dep_no, salary, MIN(salary) OVER (PARTITION BY dep_no ORDER BY salary) AS min_salary
+ FROM VALUES
+  ('Eric', 1, 28000),
+  ('Alex', 1, 32000),
+  ('Felix', 2, 21000),
+  ('Frank', 1, 30000),
+  ('Tom', 2, 23000),
+  ('Jane', 3, 29000),
+  ('Jeff', 3, 35000),
+  ('Paul', 2, 29000),
+  ('Charles', 2, 23000),
+  ('Charles F', 2, 23000),
+  ('null',4,null),
+  ('NotNull',4,23000)
+  AS tab(name, dep_no, salary);
++-----------+--------+--------+------------+
+|   name    | dep_no | salary | min_salary |
++-----------+--------+--------+------------+
+| Jane      | 3      | 29000  | 29000      |
+| Jeff      | 3      | 35000  | 29000      |
+| Eric      | 1      | 28000  | 28000      |
+| Frank     | 1      | 30000  | 28000      |
+| Alex      | 1      | 32000  | 28000      |
+| Felix     | 2      | 21000  | 21000      |
+| Tom       | 2      | 23000  | 21000      |
+| Charles   | 2      | 23000  | 21000      |
+| Charles F | 2      | 23000  | 21000      |
+| Paul      | 2      | 29000  | 21000      |
+| null      | 4      | null   | null       |
+| NotNull   | 4      | 23000  | 23000      |
++-----------+--------+--------+------------+
+```
+
+此示例将按照每个部门的薪资进行排序，并返回每个部门的最低薪资。
+
+**示例 3：使用窗口函数计算累积最小值**
+
+```sql
+SELECT name, dep_no, salary,
+       MIN(salary) OVER (PARTITION BY dep_no ORDER BY salary ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS cum_min_salary
+ FROM VALUES
+  ('Eric', 1, 28000),
+  ('Alex', 1, 32000),
+  ('Felix', 2, 21000),
+  ('Frank', 1, 30000),
+  ('Tom', 2, 23000),
+  ('Jane', 3, 29000),
+  ('Jeff', 3, 35000),
+  ('Paul', 2, 29000),
+  ('Charles', 2, 23000),
+  ('Charles F', 2, 23000),
+  ('null',4,null),
+  ('NotNull',4,23000)
+  AS tab(name, dep_no, salary);
++-----------+--------+--------+----------------+
+|   name    | dep_no | salary | cum_min_salary |
++-----------+--------+--------+----------------+
+| Jane      | 3      | 29000  | 29000          |
+| Jeff      | 3      | 35000  | 29000          |
+| Eric      | 1      | 28000  | 28000          |
+| Frank     | 1      | 30000  | 28000          |
+| Alex      | 1      | 32000  | 28000          |
+| Felix     | 2      | 21000  | 21000          |
+| Tom       | 2      | 23000  | 21000          |
+| Charles   | 2      | 23000  | 21000          |
+| Charles F | 2      | 23000  | 21000          |
+| Paul      | 2      | 29000  | 21000          |
+| null      | 4      | null   | null           |
+| NotNull   | 4      | 23000  | 23000          |
++-----------+--------+--------+----------------+
+```
+
+在这个示例中，我们将计算每个部门的累积最小薪资，即从每个员工开始到当前员工为止的最小薪资。
+
+^
+^

package/bin/skills/lakehouse-doc/references/sql_functions/window_functions/nth_value.md

@@ -0,0 +1,58 @@
+# NTH\_VALUE 函数
+
+## 简介
+
+NTH\_VALUE 函数用于从指定窗口内返回第 offset 行的值。该函数在处理数据时非常有用，特别是当需要获取特定位置的数据时。
+
+## 语法
+
+```sql
+nth_value(expr, offset[,ignoreNull]) over ([partition_clause] [orderby_clause] [frame_clause])
+```
+
+## 参数
+
+* `expr`: 任意类型的表达式。
+* `offset`: 大整数类型（BIGINT），必须是正整数常量。当 offset 为 1 时，函数行为与 FIRST\_VALUE 函数相同。
+* `ignoreNull`: 可选参数，布尔类型常量，默认为 false。当设置为 true 时，函数将返回窗口内第 offset 个非 null 的值。
+
+## 返回结果
+
+返回值类型与 expr 类型相同。
+
+## 使用示例
+
+```sql
+SELECT dep_no, salary, nth_value(salary, 3) OVER (PARTITION BY dep_no)
+FROM VALUES
+  ('Eric', 1, null),
+  ('Alex', 1, 32000),
+  ('Felix', 2, 21000),
+  ('Frank', 1, 30000),
+  ('Tom', 2, 23000),
+  ('Jane', 3, 29000),
+  ('Jeff', 3, 35000),
+  ('Paul', 2, 29000),
+  ('Charles', 2, 23000)
+AS tab(name, dep_no, salary);
+```
+
+结果：
+
+```
++--------+--------+---------------------------------------------------+
+| dep_no | salary | `nth_value`(salary, 3) OVER (PARTITION BY dep_no) |
++--------+--------+---------------------------------------------------+
+| 3      | 29000  | null                                              |
+| 3      | 35000  | null                                              |
+| 1      | null   | 30000                                             |
+| 1      | 32000  | 30000                                             |
+| 1      | 30000  | 30000                                             |
+| 2      | 21000  | 29000                                             |
+| 2      | 23000  | 29000                                             |
+| 2      | 29000  | 29000                                             |
+| 2      | 23000  | 29000                                             |
++--------+--------+---------------------------------------------------+
+```
+
+

package/bin/skills/lakehouse-doc/references/sql_functions/window_functions/ntile.md

@@ -0,0 +1,57 @@
+### NTILE 函数
+
+```sql
+ntile(n) over ([partition_clause] [orderby_clause])
+```
+
+#### 功能描述
+
+NTILE 函数用于将数据集按照顺序划分为 n 个等份（桶），并为每个数据项分配一个桶编号。当数据集无法被均匀划分为 n 个等份时，前面的桶将优先分配额外的数据项。此函数通常用于数据分析和分组。
+
+#### 参数说明
+
+* `n` (bigint 类型常量)：划分的桶数量。
+
+#### 返回结果
+
+* 返回一个 bigint 类型的桶编号。
+
+#### 使用示例
+
+1. 简单使用：
+
+```sql
+SELECT name, dep_no,salary,NTILE(4) OVER (ORDER BY salary) AS quartile
+ FROM VALUES
+  ('Eric', 1, 28000),
+  ('Alex', 1, 32000),
+  ('Felix', 2, 21000),
+  ('Frank', 1, 30000),
+  ('Tom', 2, 23000),
+  ('Jane', 3, 29000),
+  ('Jeff', 3, 35000),
+  ('Paul', 2, 29000),
+  ('Charles', 2, 23000),
+  ('Charles F', 2, 23000),
+  ('null',4,null),
+  ('NotNull',4,23000)
+  AS tab(name, dep_no, salary);
++-----------+--------+--------+----------+
+|   name    | dep_no | salary | quartile |
++-----------+--------+--------+----------+
+| null      | 4      | null   | 1        |
+| Felix     | 2      | 21000  | 1        |
+| Tom       | 2      | 23000  | 1        |
+| Charles   | 2      | 23000  | 2        |
+| Charles F | 2      | 23000  | 2        |
+| NotNull   | 4      | 23000  | 2        |
+| Eric      | 1      | 28000  | 3        |
+| Jane      | 3      | 29000  | 3        |
+| Paul      | 2      | 29000  | 3        |
+| Frank     | 1      | 30000  | 4        |
+| Alex      | 1      | 32000  | 4        |
+| Jeff      | 3      | 35000  | 4        |
++-----------+--------+--------+----------+
+```
+
+此示例将员工按照薪资从低到高的顺序划分为 4 个等份（四分位数），并为每个员工分配一个桶编号。

package/bin/skills/lakehouse-doc/references/sql_functions/window_functions/percent_rank.md

@@ -0,0 +1,58 @@
+### 百分比排名函数（PERCENT\_RANK）
+
+#### 概述
+
+`PERCENT_RANK` 函数用于计算指定行在其所在分区中的百分比排名。该函数会根据 `ORDER BY` 子句指定的排序顺序对数据进行排序，并计算每个分区中各行的排名。其返回值是一个 `double` 类型，值域在 [0.0, 1.0] 范围内。具体计算公式为 `(当前行排名 - 1) / (分区总行数 - 1)`。当分区中只有一行时，返回值为 0。
+
+#### 使用方法
+
+```sql
+PERCENT_RANK() OVER (
+    [PARTITION BY partition_expression, ...]
+    [ORDER BY sort_expression [ASC | DESC], ...]
+)
+```
+
+* `PARTITION BY` 子句（可选）：指定用于分区的表达式，可以有多个。如果省略此子句，将使用整个结果集作为一个分区。
+* `ORDER BY` 子句：指定用于排序的表达式，可以有多个，并可指定排序方向（升序 ASC 或降序 DESC）。
+
+#### 示例
+
+以下示例展示了如何使用 `PERCENT_RANK` 函数计算不同部门人员的薪水排名百分比。
+
+```sql
+SELECT    name, dep_no,salary,
+PERCENT_RANK() OVER (PARTITION BY dep_no ORDER BY  salary DESC) AS PERCENT_RANK
+ FROM VALUES
+  ('Eric', 1, 28000),
+  ('Alex', 1, 32000),
+  ('Felix', 2, 21000),
+  ('Frank', 1, 30000),
+  ('Tom', 2, 23000),
+  ('Jane', 3, 29000),
+  ('Jeff', 3, 35000),
+  ('Paul', 2, 29000),
+  ('Charles', 2, 23000),
+  ('Charles F', 2, 23000),
+  ('null',4,null),
+  ('NotNull',4,23000)
+  AS tab(name, dep_no, salary);
++-----------+--------+--------+--------------+
+|   name    | dep_no | salary | PERCENT_RANK |
++-----------+--------+--------+--------------+
+| Jeff      | 3      | 35000  | 0.0          |
+| Jane      | 3      | 29000  | 1.0          |
+| Alex      | 1      | 32000  | 0.0          |
+| Frank     | 1      | 30000  | 0.5          |
+| Eric      | 1      | 28000  | 1.0          |
+| Paul      | 2      | 29000  | 0.0          |
+| Tom       | 2      | 23000  | 0.25         |
+| Charles   | 2      | 23000  | 0.25         |
+| Charles F | 2      | 23000  | 0.25         |
+| Felix     | 2      | 21000  | 1.0          |
+| NotNull   | 4      | 23000  | 0.0          |
+| null      | 4      | null   | 1.0          |
++-----------+--------+--------+--------------+
+```
+
+