一文搞懂 MySQL 的窗口函数-低调大师

一文搞懂 MySQL 的窗口函数

2020-11-17 507

窗口函数在统计类的需求中很常见，稍微复杂一点的查询需求就有可能用到它，使用窗口函数可以极大的简化我们的 SQL 语句。像 Oracle、SQL Server 这些数据库在较早的版本就支持窗口函数了，MySQL 直到 8.0 版本后才支持它。

本文将介绍一些常用的窗口函数的用法。窗口函数按照实现方式分成两种：一种是非聚合窗口函数，另外一种是聚合窗口函数。

非聚合窗口函数是相对于聚合窗口函数来说的。聚合函数是对一组数据计算后返回单个值（即分组），非聚合函数一次只会处理一行数据。窗口聚合函数在行记录上计算某个字段的结果时，可将窗口范围内的数据输入到聚合函数中，并不改变行数。

1 非聚合窗口函数

MySQL 支持的非聚合窗口函数见表1。

名称	描述
`CUME_DIST()`	累积分配值
`DENSE_RANK()`	当前行在其分区中的排名，稠密排序
`FIRST_VALUE()`	指定区间范围内的第一行的值
`LAG()`	取排在当前行之前的值
`LAST_VALUE()`	指定区间范围内的最后一行的值
`LEAD()`	取排在当前行之后的值
`NTH_VALUE()`	指定区间范围内第N行的值
`NTILE()`	将数据分到N个桶，当前行所在的桶号
`PERCENT_RANK()`	排名值的百分比
`RANK()`	当前行在其分区中的排名，稀疏排序
`ROW_NUMBER()`	分区内当前行的行号

<center>表1 非聚合窗口函数列表</center>

常用的函数有：ROW_NUMBER()、RANK()、DENSE_RANK()、LEAD()、LAG()、NTH_VALUE()、FIRST_VALUE()、LAST_VALUE()。

ROW_NUMBER()、RANK()、DENSE_RANK()

ROW_NUMBER()、RANK()、DENSE_RANK()都是排序函数，都可以给区间内的数生成序号。如果区间内不存在重复值，它们的计算结果一样。

当出现重复值时，ROW_NUMBER()不考虑重复值，它会给相同的两个值分配不同的编号，编号的范围是从 1 到分区的行数。RANK() 和DENSE_RANK() 给重复的值生成相同的编号。不同的是，RANK()生成的序号有间隙，即重复值的下一项的编号和重复值的编号并不连续（下一项的值的编号 $\neq$ 当前重复值项的编号+1），而DENSE_RANK()就不是这样。

这几个函数的区别可结合下面的例子分析。

SELECT 
  sal,
  ROW_NUMBER() OVER(ORDER BY sal) AS 'rn',
  RANK() OVER(ORDER BY sal) AS 'rk',
  DENSE_RANK() OVER(ORDER BY sal) AS 'dk' 
FROM
  emp;

sal          rn      rk      dk  
-------  ------  ------  --------
800.00        1       1         1
950.00        2       2         2
1100.00       3       3         3
1250.00       4       4         4
1250.00       5       4         4
1300.00       6       6         5
1500.00       7       7         6
1600.00       8       8         7
2450.00       9       9         8
2850.00      10      10         9
2975.00      11      11        10
3000.00      12      12        11
3000.00      13      12        11
5000.00      14      14        12

如果没有指定 partition by 分区字段，那么窗口函数操作的区间就是全部数据。我们可以让函数只作用在 deptno 分区。

SELECT 
  sal,
  deptno,
  ROW_NUMBER() OVER(
      PARTITION BY deptno 
      ORDER BY sal) AS 'rn'
FROM
  emp;

sal      deptno      rn  
-------  ------  --------
1300.00      10         1
2450.00      10         2
5000.00      10         3
800.00       20         1
1100.00      20         2
2975.00      20         3
3000.00      20         4
3000.00      20         5
950.00       30         1
1250.00      30         2
1250.00      30         3
1500.00      30         4
1600.00      30         5
2850.00      30         6

如果我们要获取 emp 表中每个部门工资最高的前两名员工的信息，使用 ROW_NUMBER() 就可以这么写。

SELECT 
  * 
FROM
  (SELECT 
    empno,
    ename,
    deptno,
    sal,
    ROW_NUMBER() OVER(
      PARTITION BY deptno 
  ORDER BY sal DESC
  ) AS rn 
  FROM
    emp) t 
WHERE rn <= 2; 


 empno  ename   deptno  sal          rn  
------  ------  ------  -------  --------
  7839  KING        10  5000.00         1
  7782  CLARK       10  2450.00         2
  7788  SCOTT       20  3000.00         1
  7902  FORD        20  3000.00         2
  7698  BLAKE       30  2850.00         1
  7499  ALLEN       30  1600.00         2

注意，如果在OVER() 中没有ORDER 子句，那么，ROW_NUMBER()生成的编号是不确定的，而RANK()、DENSE_RANK() 生成的编号都是 1 。

LAG()、LEAD()

LAG() 可以获得位于当前行之前的数据，如果指定了分区，则获取数据的范围只能在分区内。默认是获取上一条的记录，如果没有获取到，则返回 NULL。

LAG() 的表达式是LAG(expr [, N[, default]]) [null_treatment] over_clause ，我们可以指定向后获取第 N 行，以及在获取不到数据时指定默认值。

LEAD() 的表达式和 LAG() 是一样的，因此在 LEAD() 中也可以指定获取的行数 N 及默认值。
```
SELECT 
  empno,
  sal,
  LAG(sal) OVER(ORDER BY empno)AS 'lag',
  LEAD(sal) OVER(ORDER BY empno)AS 'lead',
  LAG(sal,2,0) OVER(ORDER BY empno)AS 'lag_2'
FROM
  emp LIMIT 6;


 empno  sal      lag      lead     lag_2    
------  -------  -------  -------  ---------
  7369  800.00   (NULL)   1600.00  0.00     
  7499  1600.00  800.00   1250.00  0.00     
  7521  1250.00  1600.00  2975.00  800.00   
  7566  2975.00  1250.00  1250.00  1600.00  
  7654  1250.00  2975.00  2850.00  1250.00  
  7698  2850.00  1250.00  2450.00  2975.00  
```
我们使用 LAG(sal,2,0) 获取当前行向前偏移 2 行的值，在当前行的编号是 1 和 2 时，由于偏移的行不存在，只能返回默认值 0 。

FIRST_VALUE()、LAST_VALUE()、NTH_VALUE()

这几个函数可以分别获取区间范围内第一行、最后一行、第 N 行的值。

SELECT 
  empno,
  deptno,
  FIRST_VALUE(empno) OVER(
      PARTITION BY deptno 
      ORDER BY empno)AS 'first',
  LAST_VALUE(empno) OVER(
      PARTITION BY deptno ORDER BY empno 
      ROWS BETWEEN unbounded preceding 
      AND unbounded following)AS 'last',
  NTH_VALUE(empno,2) OVER(
      PARTITION BY deptno 
      ORDER BY empno)AS 'nth_2'
FROM
  emp;


 empno  deptno   first    last   nth_2  
------  ------  ------  ------  --------
  7782      10    7782    7934    (NULL)
  7839      10    7782    7934      7839
  7934      10    7782    7934      7839
  7369      20    7369    7902    (NULL)
  7566      20    7369    7902      7566
  7788      20    7369    7902      7566
  7876      20    7369    7902      7566
  7902      20    7369    7902      7566
  7499      30    7499    7900    (NULL)
  7521      30    7499    7900      7521
  7654      30    7499    7900      7521
  7698      30    7499    7900      7521
  7844      30    7499    7900      7521
  7900      30    7499    7900      7521

当在OVER() 中指定了排序字段， FIRST_VALUE()、LAST_VALUE()、NTH_VALUE() 这几个函数的滑动窗口范围是从第一行到当前行（即 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW），直接使用 LAST_VALUE() 得到的结果并不是我们直觉上想看到的那样。因此，需要把LAST_VALUE()的窗口范围改成 RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING。

关于滑动窗口更加详细的描述，在后面有讲到。

NTILE()

NTILE(N)将一个分区划分为N个组（桶），给分区中的每一行分配其桶号，并返回其分区中当前行的桶号。

SELECT 
  empno,
  deptno,
  NTILE(2) OVER(
      PARTITION BY deptno 
      ORDER BY empno) AS ntile2
FROM
  emp;


 empno  deptno  ntile2  
------  ------  --------
  7782      10         1
  7839      10         1
  7934      10         2
  7369      20         1
  7566      20         1
  7788      20         1
  7876      20         2
  7902      20         2
  7499      30         1
  7521      30         1
  7654      30         1
  7698      30         2
  7844      30         2
  7900      30         2

CUME_DIST()

统计一组数据中小于等于（或大于等于，和 OVER() 中指定的排序行为有关系）当前行的值的百分比。

SELECT 
  sal,
  ROW_NUMBER() OVER(
ORDER BY sal) AS rn,
  CUME_DIST() OVER(
ORDER BY sal) AS dist
FROM
  emp;


sal          rn                 dist  
-------  ------  ---------------------
800.00        1    0.07142857142857142
950.00        2    0.14285714285714285
1100.00       3    0.21428571428571427
1250.00       4    0.35714285714285715
1250.00       5    0.35714285714285715
1300.00       6    0.42857142857142855
1500.00       7                    0.5
1600.00       8     0.5714285714285714
2450.00       9     0.6428571428571429
2850.00      10     0.7142857142857143
2975.00      11     0.7857142857142857
3000.00      12     0.9285714285714286
3000.00      13     0.9285714285714286
5000.00      14                      1

当我们在OVER() 指定排序的行为是 ORDER BY sal DESC时，看到的却是另一番景象。

SELECT 
  sal,
  ROW_NUMBER() OVER(
ORDER BY sal DESC) AS rn,
  CUME_DIST() OVER(
ORDER BY sal DESC) AS dist
FROM
  emp;


sal          rn                 dist  
-------  ------  ---------------------
5000.00       1    0.07142857142857142
3000.00       2    0.21428571428571427
3000.00       3    0.21428571428571427
2975.00       4     0.2857142857142857
2850.00       5    0.35714285714285715
2450.00       6    0.42857142857142855
1600.00       7                    0.5
1500.00       8     0.5714285714285714
1300.00       9     0.6428571428571429
1250.00      10     0.7857142857142857
1250.00      11     0.7857142857142857
1100.00      12     0.8571428571428571
950.00       13     0.9285714285714286
800.00       14                      1

PERCENT_RANK() 和 CUME_DIST() 一样，也是统计某个值的分配情况，只是它们的算法不一样。

PERCENT_RANK() 的计算公式：

(rank - 1) / (rows - 1)

其中，rank 表示行的等级（如果出现重复值，则用最小的那个编号），rows 表示分区的行数。具体请看下面这个例子。

SELECT 
  empno,
  sal,
  ROW_NUMBER() OVER(ORDER BY sal) AS rn,
  PERCENT_RANK() OVER(ORDER BY sal) AS percent
FROM
  emp;


sal          rn              percent  
-------  ------  ---------------------
800.00        1                      0
950.00        2    0.07692307692307693
1100.00       3    0.15384615384615385
1250.00       4    0.23076923076923078
1250.00       5    0.23076923076923078
1300.00       6    0.38461538461538464
1500.00       7    0.46153846153846156
1600.00       8     0.5384615384615384
2450.00       9     0.6153846153846154
2850.00      10     0.6923076923076923
2975.00      11     0.7692307692307693
3000.00      12     0.8461538461538461
3000.00      13     0.8461538461538461
5000.00      14                      1

当 sal = 800 时，percent = (1 -1 ) / (14 - 1) = 0；

当 sal = 1250 时，存在两个编号：4 跟 5。取最小的编号，则 percent = (4 -1 ) / (14 - 1) = 0.230769；

当 sal = 5000 时， percent = (14 -1 ) / (14 - 1) = 1。

注意，如果在OVER()中没有指定 ORDER 子句，那么 PERCENT_RANK() 计算的结果都是一样的。

2 聚合窗口函数

在下面这些聚合窗口函数后面加上 OVER() 子句，它们就变成了聚合窗口函数。

AVG()
BIT_AND()
BIT_OR()
BIT_XOR()
COUNT()
JSON_ARRAYAGG()
JSON_OBJECTAGG()
MAX()
MIN()
STDDEV_POP(), STDDEV(), STD()
STDDEV_SAMP()
SUM()
VAR_POP(), VARIANCE()
VAR_SAMP()

常用的聚合窗口函数有：AVG() OVER()、COUNT() OVER()、MAX() OVER()、MIN() OVER()、SUM() OVER()。

下面这个例子，它利用窗口函数只查一次 emp 表完成了这些需求：

统计所有员工的薪资；
统计每个部门的人数；
计算每个部门的平均薪资；
获取公司里面的最高薪资;
获取最早入职的员工的入职时间。

SELECT 
  empno AS '编号',
  ename AS '姓名',
  sal AS '薪资',
  deptno AS '部门编号',
  SUM(sal) OVER() AS '薪资总额',
  COUNT(*) OVER(PARTITION BY deptno) AS '部门人数',
  AVG(sal) OVER(PARTITION BY deptno) AS '部门平均薪资',
  MAX(sal) OVER() AS '最高薪资',
  MIN(hiredate) OVER() '最早入职时间'
FROM
  emp;

输出结果>>>

3 命名窗口函数

我们可以用 WINDOWS 关键字给窗口起别名，并在OVER() 中引用它。命名窗口子句位于 HAVING 子句和 ORDER 子句的位置之间，其语法如下：

WINDOW window_name AS (window_spec)
    [, window_name AS (window_spec)]

我们可以同时定义多个窗口名字。

再来看下 window_spec 的定义：

window_spec:
    [window_name] [partition_clause] [order_clause] [frame_clause]

也就是说，我们在定义一个窗口函数时，可以指定下面这些内容：

引用的窗口别名，比如先定义了窗口 w1，再在窗口 w2 中引用 w1，就像这样WINDOW w1 AS (w2), w2 AS ()。但是，不能循环引用。
PARTITION 子句；
ORDER 子句；
滑动窗口范围。

对于在 SQL 中使用了多个窗口函数，且这些窗口函数中的 OVER() 的内容都相同，使用命名窗口函数就很合适。

比如，对于下面这条 SQL。

SELECT
  sal,
  ROW_NUMBER() OVER (ORDER BY sal) AS 'row_number',
  RANK()       OVER (ORDER BY sal) AS 'rank',
  DENSE_RANK() OVER (ORDER BY sal) AS 'dense_rank'
FROM emp;

可以改造成命名窗口的形式。一旦想改变 OVER() 里面的内容，只需改动命名窗口里面的内容，而不用像原来的 SQL 那样要改动每个窗口函数的内容。

SELECT
  sal,
  ROW_NUMBER() OVER w AS 'row_number',
  RANK()       OVER w AS 'rank',
  DENSE_RANK() OVER w AS 'dense_rank'
FROM emp
WINDOW w AS (ORDER BY sal);

我们再来看一个复杂一点的例子。

SELECT
  deptno,
  sal,
  ROW_NUMBER() OVER w2 AS 'row_number',
  RANK()       OVER (w1 ORDER BY sal) AS 'rank',
  DENSE_RANK() OVER w3 AS 'dense_rank'
FROM emp
WINDOW w1 AS(PARTITION BY deptno),
	   w2 AS(ORDER BY sal),
	   w3 AS(w2)
ORDER BY sal;

我们在 RANK() OVER() 的子句里面引用了窗口 w1，并在其后面接入了 ORDER 子句；在定义窗口 w3 时，我们直接引用了窗口 w2，即窗口 w3 所表现的行为和 w2 一致。

实际上，上面这条 SQL 等价于下面这条 SQL。

SELECT
  deptno,
  sal,
  ROW_NUMBER() OVER (
      ORDER BY sal) AS 'row_number',
  RANK()       OVER (
      PARTITION BY deptno ORDER BY sal) AS 'rank',
  DENSE_RANK() OVER (ORDER BY sal) AS 'dense_rank'
FROM emp
ORDER BY sal;

4 动态窗口

我们来看下 OVER()的语法结构：

over_clause:
    {OVER (window_spec) | OVER window_name}
    
window_spec:
    [window_name] [partition_clause] [order_clause] [frame_clause]

PARTITION 子句和 ORDER 子句大家都比较熟悉了，接下来给大家介绍 FRAME 子句。

FRAME 子句的就是用来实现动态窗口。窗口函数在每行记录上执行，有的函数的窗口不会发生变化，这种就属于静态窗口；有的函数随着记录不同，窗口大小也在不断变化，这种就属于动态窗口。

看下面这个例子，我们通过滑动窗口实现随着时间的变化累加部门的薪资，以及计算当前行和上下行记录的平均薪资。

SELECT 
  empno,
  deptno,
  sal,
  SUM(sal) OVER(PARTITION BY deptno ORDER BY hiredate ROWS UNBOUNDED PRECEDING) AS total,
  AVG(sal) OVER(PARTITION BY deptno ORDER BY hiredate ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING) AS average
FROM
  emp;
  

 empno  deptno  sal      total     average        
------  ------  -------  --------  -------------
  7782      10  2450.00  2450.00   3725.000000  
  7839      10  5000.00  7450.00   2916.666667  
  7934      10  1300.00  8750.00   3150.000000  
  7369      20  800.00   800.00    1887.500000  
  7566      20  2975.00  3775.00   2258.333333  
  7902      20  3000.00  6775.00   2991.666667  
  7788      20  3000.00  9775.00   2366.666667  
  7876      20  1100.00  10875.00  2050.000000  
  7499      30  1600.00  1600.00   1425.000000  
  7521      30  1250.00  2850.00   1900.000000  
  7698      30  2850.00  5700.00   1866.666667  
  7844      30  1500.00  7200.00   1866.666667  
  7654      30  1250.00  8450.00   1233.333333  
  7900      30  950.00   9400.00   1100.000000

当计算 empno = 7782 这行记录时，total = 2450，average = （2450 + 5000）/ 2 = 3725；

当计算 empno = 7839 这行记录时，total = 2450 + 5000 = 7450，average = （2450 + 5000 + 1300）/ 3 = 2916.66；

当计算 empno = 7934 这行记录时，total = 2450 + 5000 + 1300 = 8750，average = （5000 + 1300）/ 2 = 3150；

可以通过基于行或者基于范围的方式指定窗口的大小：

基于行：选择当前行的前后几行。比如范围是当前行的往前两行和往后三行，就可以这么写语句 ROWS BETWEEN 2 PRECEDING AND 3 FOLLOWING。
基于范围：选择数据范围。例如获取值在区间 [c-2，c+3]的数据，语句就是 RANGE BETWEEN 2 PRECEDING AND 3 FOLLOWING，c 表示当前行的值。典型的应用场景是统计每天的日活、月活，这些用基于行的方式不好表示。

我们再来看关于指定窗口大小的表达式：

CURRENT ROW 边界是当前行，一般和其他范围关键字一起使用

UNBOUNDED PRECEDING 边界是分区中的第一行

UNBOUNDED FOLLOWING 边界是分区中的最后一行

expr PRECEDING  边界是当前行减去expr的值

expr FOLLOWING  边界是当前行加上expr的值

关于 expr 的有效的表达式可以是：

10 PRECEDING
INTERVAL 5 DAY PRECEDING
5 FOLLOWING
INTERVAL '2:30' MINUTE_SECOND FOLLOWING

注意，有些窗口函数即使指定了FRAME 子句，在计算的时候仍然选择的全分区的数据。这些函数包括：

CUME_DIST()
DENSE_RANK()
LAG()
LEAD()
NTILE()
PERCENT_RANK()
RANK()
ROW_NUMBER()

FRAME 子句的默认值取决于是否有 ORDER 子句。

当存在于 ORDER BY 时，默认值为分区起始行到当前行，包含和当前行的值相等的其它行。语句相当于是 ROW UNBOUNDED PRECEDING 或者 ROW BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW 。
当不存在 ORDER BY 时，默认是分区的所有行，即 ROW BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING。

5 窗口函数的限制

窗口函数不能直接用在 UPDATE 和 DELETE 语句中，但可以用在子查询中；
不支持嵌套窗口函数；
聚合窗口函数中不能使用 DISTINCT ；
依赖于当前行的值的滑动窗口端点。

本文分享自微信公众号 - SQL实现（gh_684ee9235a26）。
如有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一起分享。

微信关注我们

原文链接：https://my.oschina.net/u/4600992/blog/4721081

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

亿级大表分库分表实战总结（万字干货，实战复盘）

分库分表的文章网上非常多，但是大多内容比较零散，以讲解知识点为主，没有完整地说明一个大表的切分、新架构设计、上线的完整过程。因此，我结合去年做的一个大型分库分表项目，来复盘一下完整的分库分表从架构设计到发布上线的实战总结。 1.前言为什么需要做分库分表。这个相信大家多少都有所了解。海量数据的存储和访问成为了MySQL数据库的瓶颈问题，日益增长的业务数据，无疑对MySQL数据库造成了相当大的负载，同时对于系统的稳定性和扩展性提出很高的要求。而且单台服务器的资源（CPU、磁盘、内存等）总是有限的，最终数据库所能承载的数据量、数据处理能力都将遭遇瓶颈。目前来说一般有两种方案。 1）一种是更换存储，不使用MySQL，比如可以使用HBase、polarDB、TiDB等分布式存储。 2）如果出于各种原因考虑，还是想继续使用MySQL，一般会采用第二种方式，那就是分库分表。文章开头就说了，网上分库分表文章很多，对知识点讲解比较多，因此，本文将不再过多赘述分库分表方案的范式处理。而是专注于梳理分库分表从架构设计到发布上线的完整过程，同时总结其中的注意事项和最佳实践。包括五个部分：...

2020-11-16

557

今年双11的整体节奏从之前的“光棍节”变为“双节棍”，具体业务上也有很多变化和调整，应了阿里的土话“唯一不变的是变化”。面对这些变化，是挑战也是机会，我们要做的就是，“既要”高效支撑保障业务先赢，“又要”确保体验和稳定性带给用户极致体验，“还要”追求创新让前端持续演进。为了实现“既要、又要、还要”，包括技术方案、流程机制、人员组织等各方面都进行了大量的设计和保障。最终第一次双峰的双11圆满结束，淘系前端也实现了自己的目标，包括应用大量优化手段和创新方案带来业务转化提升；将FaaS、PHA、ESR等技术应用在更多场景，分别向服务端、客户端、CDN节点进一步拓展了前端的能力和边界；应用视觉还原、一体化研发等提升研发效率，大幅缓解资源瓶颈等等。下面会整体介绍一下淘系前端在今年双11的思考和沉淀，希望对大家有所助益。后续也会有各个专项的系列文章，希望大家持续关注。变化 & 挑战今年的双11，首先感受到的就是源源不断的变化。单峰变双峰：双11从之前的一个波段变成今年的两个波段，大促的三个阶段预售、预热、正式也都对应的翻倍。首先带来的是研发工作量的大幅增加，在时间排期不变、工作量增加...

2020-11-16

531

资源下载

更多资源

优质分享App

近一个月的开发和优化，本站点的第一个app全新上线。该app采用极致压缩，本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。