升职加薪

Mysql -窗口函数详解

数据分析｜MySQL窗口函数详解与案例实战

1. 窗口函数定义与分类

2. 各类别窗口函数用法详解

2.1 序号函数：ROW_NUMBER()、RANK()、DENSE_RANK()

2.2 分布函数：PERCENT_RANK()、CUME_DIST()

2.3 前后函数：LAG(expr,n)、LEAD(expr,n)

2.4 头尾函数：FIRST_VALUE(expr)、LAST_VALUE(expr)

2.5 其它函数：NTH_VALUE(expr, n)、NTILE(n)

2.6 聚合函数作为窗口函数：SUM()、AVG()、MAX()、MIN()、COUNT()

2.7 Frame子句

3. 窗口函数实战

3.1 基础数据准备

3.2 窗口函数用法实战

4. 相关业务问题

4.1 解决方法

4.2 TOPN问题模板

4.3 聚合函数作为窗口函数

5. 总结

数据分析｜MySQL窗口函数详解与案例实战

1. 窗口函数定义与分类

（1）定义

窗口函数也称OLAP函数（Online Anallytical Processing，联机分析处理），可对数据进行实时分析处理。

窗口表示记录集合；窗口函数表示在满足某些条件的记录集合上执行的特殊函数，对于每条记录都要在此窗口内执行函数；有的函数随着记录的不同，窗口大小都是固定的，称为静态窗口；有的函数则相反，不同的记录对应着不同的窗口，称为滑动窗口。

（2）窗口函数与普通函数的区别与联系

①聚合函数是将多条记录聚合为一条；窗口函数是每条记录都会执行，有几条记录执行完还是几条。

②聚合函数也可以用于窗口函数。

（3）基本用法

<窗口函数> over ([partition by <列清单>]
                        order by <排序用列清单>)

over关键字用来指定函数执行的窗口范围，若后面括号什么都不写，则意味着窗口包含满足WHERE条件的所有行，窗口函数基于所有行进行计算；如不为空，则支持以下四种语法来设置窗口。

①window_name：给窗口指定一个别名。如果SQL中涉及的窗口较多，采用别名可以看起来更清晰易读；

②PARTITION BY 子句：窗口按照哪些字段进行分组，窗口函数在不同的分组上分别执行；

③ORDER BY子句：按照哪些字段进行排序，窗口函数将按照排序后的记录顺序进行编号；

④FRAME子句：FRAME是当前分区的一个子集，子句用来定义子集的规则，通常用来作为滑动窗口使用。

（4）窗口函数分类

图一：常用窗口函数汇总

2. 各类别窗口函数用法详解

2.1 序号函数：`ROW_NUMBER()、RANK()`、`DENSE_RANK()`

① ROW_NUMBER()

用途：显示分区中的当前行号
应用场景：查询每个学生分数最高的3门课程

SELECT * FROM (
     SELECT stu_id,
     ROW_NUMBER() OVER (PARTITION BY stu_id ORDER BY score DESC) AS score_order,
     lesson_id, score
     FROM t_score) t
 WHERE score_order <= 3;

+--------+-------------+-----------+-------+
| stu_id | score_order | lesson_id | score |
+--------+-------------+-----------+-------+
|      1 |           1 | L005      |    98 |
|      1 |           2 | L001      |    98 |
|      1 |           3 | L004      |    88 |
|      2 |           1 | L002      |    90 |
|      2 |           2 | L003      |    86 |
|      2 |           3 | L001      |    84 |
|      3 |           1 | L001      |   100 |
|      3 |           2 | L002      |    91 |
|      3 |           3 | L003      |    85 |
|      4 |           1 | L001      |    99 |
|      4 |           2 | L005      |    98 |
|      4 |           3 | L002      |    88 |
+--------+-------------+-----------+-------+

解释：row_number()是排序函数，partition by将学号分类，相当于group by子句功能，但group by子句分类汇总会改变原数据行数，而窗口函数保持原行数，order by将成绩降序排列。对于stu_id=1的同学，有两门课程的成绩均为98，序号随机排了1和2。但很多情况下二者应该是并列第一，则他的成绩为88的这门课的序号可能是第2名，也可能为第3名。这时ROW_NUMBER()就不能满足需求，需要使用RANK()和DENSE_RANK()，它们和ROW_NUMBER()非常类似，只是在出现重复值时处理逻辑有所不同。
注意：窗口函数是对where或group by处理后结果进行操作，因此按SQL语句运行顺序，窗口函数一般放在select子句中，不能在where子句中使用窗口函数别名。插播“Mysql语句执行顺序”

② RANK()、DENSE_RANK()

rank()/dense_rank()：与ROW_NUMBER()非常类似，只是在出现重复值时处理逻辑有所不同。下面我们查看学号stu_id=1使用不同序号函数的排序结果。

SELECT *
FROM (
         SELECT ROW_NUMBER() OVER (PARTITION BY stu_id ORDER BY score DESC) AS score_row_number,
                RANK() OVER (PARTITION BY stu_id ORDER BY score DESC)       AS score_rank,
                DENSE_RANK() OVER (PARTITION BY stu_id ORDER BY score DESC) AS score_dense_rank,
                stu_id,
                lesson_lid,
                score
         FROM t_score) t
WHERE stu_id = 1
  AND score_order1 <= 3
  AND score_order2 <= 3
  AND score_order3 <= 3
;

+------------------+------------+------------------+--------+-----------+-------+
| score_row_number | score_rank | score_dense_rank | stu_id | lesson_id | score |
+------------------+------------+------------------+--------+-----------+-------+
|                1 |          1 |                1 |      1 | L005      |    98 |
|                2 |          1 |                1 |      1 | L001      |    98 |
|                3 |          3 |                2 |      1 | L004      |    88 |
+------------------+------------+------------------+--------+-----------+-------+

当成绩相同时，会存在并列情况，主要区别是三个函数如何处理并列情况：

在rank()函数，如果有并列情况，会占用下一个名次，如：1,1,3；
在dense_rank()函数中，如果有并列的情况，不会占用下一个名次，如：1,1,2；
在row_number()函数中，会忽略并列的情况，依次排序，名次是：1,2,3;

2.2 分布函数：`PERCENT_RANK()`、`CUME_DIST()`

① PERCENT_RANK()

用途：每行按照公式(rank-1) / (rows-1)进行计算。其中，rank为RANK()函数产生的序号，rows为当前窗口的记录总行数
应用场景：不常用

SELECT RANK() OVER w         AS rk,
       PERCENT_RANK() OVER w AS prk,
       stu_id,
       lesson_id,
       score
FROM t_score
WHERE stu_id = 1
    WINDOW w AS (PARTITION BY stu_id ORDER BY score)
;

+----+------+--------+-----------+-------+
| rk | prk  | stu_id | lesson_id | score |
+----+------+--------+-----------+-------+
|  1 |    0 |      1 | L003      |    79 |
|  2 | 0.25 |      1 | L002      |    86 |
|  3 |  0.5 |      1 | L004      |    88 |
|  4 | 0.75 |      1 | L005      |    98 |
|  4 | 0.75 |      1 | L001      |    98 |
+----+------+--------+-----------+-------+

② CUME_DIST()

用途：分组内小于、等于当前rank值的行数 / 分组内总行数
应用场景：查询小于等于当前成绩（score）的比例

SELECT stu_id,
       lesson_id,
       score,
       CUME_DIST() OVER (ORDER BY score)                        AS cd1,
       CUME_DIST() OVER (PARTITION BY lesson_id ORDER BY score) AS cd2
FROM t_score
WHERE lesson_id IN ('L001', 'L002')
;

+--------+-----------+-------+-------+------+
| stu_id | lesson_id | score | cd1   | cd2  |
+--------+-----------+-------+-------+------+
|      2 | L001      |    84 | 0.125 | 0.25 |
|      1 | L001      |    98 |  0.75 |  0.5 |
|      4 | L001      |    99 | 0.875 | 0.75 |
|      3 | L001      |   100 |     1 |    1 |
|      1 | L002      |    86 |  0.25 | 0.25 |
|      4 | L002      |    88 | 0.375 |  0.5 |
|      2 | L002      |    90 |   0.5 | 0.75 |
|      3 | L002      |    91 | 0.625 |    1 |
+--------+-----------+-------+-------+------+

其中，cd1将整张表作为窗口，按成绩排序（默认升序），排序后cd1列的值依次为0-1；然后cd2按照lesson_id分组score排序，打乱了cd1的排列顺序，得到上图结果。

2.3 前后函数：`LAG(expr,n)`、`LEAD(expr,n)`

用途：返回位于当前行的前n行（LAG(expr,n)）或后n行（LEAD(expr,n)）的expr的值
应用场景：查询前1名同学的成绩和当前同学成绩的差值

内层SQL先通过LAG()函数得到前1名同学的成绩，外层SQL再将当前同学和前1名同学的成绩做差得到成绩差值diff。

SELECT stu_id, lesson_id, score, pre_score,score-pre_score AS diff
    FROM(
     SELECT stu_id, lesson_id, score,
     LAG(score,1) OVER w AS pre_score
     FROM t_score
     WHERE lesson_id IN ('L001','L002')
     WINDOW w AS (PARTITION BY lesson_id ORDER BY score)) t;

+--------+-----------+-------+-----------+------+
| stu_id | lesson_id | score | pre_score | diff |
+--------+-----------+-------+-----------+------+
|      2 | L001      |    84 |      NULL | NULL |
|      1 | L001      |    98 |        84 |   14 |
|      4 | L001      |    99 |        98 |    1 |
|      3 | L001      |   100 |        99 |    1 |
|      1 | L002      |    86 |      NULL | NULL |
|      4 | L002      |    88 |        86 |    2 |
|      2 | L002      |    90 |        88 |    2 |
|      3 | L002      |    91 |        90 |    1 |
+--------+-----------+-------+-----------+------+

2.4 头尾函数：`FIRST_VALUE(expr)`、`LAST_VALUE(expr)`

用途：返回第一个（FIRST_VALUE(expr)）或最后一个（LAST_VALUE(expr)）expr的值
应用场景：截止到当前成绩，按照日期排序查询第1个和最后1个同学的分数

- 添加新列：
ALTER TABLE t_score ADD create_time DATE;
SELECT stu_id, lesson_id, score, create_time,
    FIRST_VALUE(score) OVER w AS first_score,
    LAST_VALUE(score) OVER w AS last_score
    FROM t_score
    WHERE lesson_id IN ('L001','L002')
    WINDOW w AS (PARTITION BY lesson_id ORDER BY create_time);

+--------+-----------+-------+-------------+-------------+------------+
| stu_id | lesson_id | score | create_time | first_score | last_score |
+--------+-----------+-------+-------------+-------------+------------+
|      3 | L001      |   100 | 2018-08-07  |         100 |        100 |
|      1 | L001      |    98 | 2018-08-08  |         100 |         98 |
|      2 | L001      |    84 | 2018-08-09  |         100 |         84 |
|      4 | L001      |    99 | 2018-08-09  |         100 |         99 |
|      3 | L002      |    91 | 2018-08-07  |          91 |         91 |
|      1 | L002      |    86 | 2018-08-08  |          91 |         86 |
|      2 | L002      |    90 | 2018-08-09  |          91 |         90 |
|      4 | L002      |    88 | 2018-08-10  |          91 |         88 |
+--------+-----------+-------+-------------+-------------+------------+

其中，FIRST_VALUE取得的是当前窗口的第一行，LAST_VALUE取得的是当前窗口到此条记录的最后一行，即当前记录；若想取得当前窗口的最后一行记录，需添加frame子句，rows between unbounded preceding and unbounded following。

2.5 其它函数：`NTH_VALUE(expr, n)`、`NTILE(n)`

① NTH_VALUE(expr,n)

用途：返回窗口中第n个expr的值。expr可以是表达式，也可以是列名
应用场景：截止到当前成绩，显示每个同学的成绩中排名第2和第3的成绩的分数

SELECT stu_id, lesson_id, score,
    NTH_VALUE(score,2) OVER w AS second_score,
    NTH_VALUE(score,3) OVER w AS third_score
    FROM t_score
    WHERE stu_id IN (1,2)
    WINDOW w AS (PARTITION BY stu_id ORDER BY score);

+--------+-----------+-------+--------------+-------------+
| stu_id | lesson_id | score | second_score | third_score |
+--------+-----------+-------+--------------+-------------+
|      1 | L003      |    79 |         NULL |        NULL |
|      1 | L002      |    86 |           86 |        NULL |
|      1 | L004      |    88 |           86 |          88 |
|      1 | L001      |    98 |           86 |          88 |
|      1 | L005      |    98 |           86 |          88 |
|      2 | L004      |    75 |         NULL |        NULL |
|      2 | L005      |    77 |           77 |        NULL |
|      2 | L001      |    84 |           77 |          84 |
|      2 | L003      |    86 |           77 |          84 |
|      2 | L002      |    90 |           77 |          84 |
+--------+-----------+-------+--------------+-------------+

② NTILE(n):分桶

用途：将分区中的有序数据分为n个等级，记录等级数
应用场景：将每门课程按照成绩分成3组

SELECT
    NTILE(3) OVER w AS nf,
    stu_id, lesson_id, score
    FROM t_score
    WHERE lesson_id IN ('L001','L002')
    WINDOW w AS (PARTITION BY lesson_id ORDER BY score);

+------+--------+-----------+-------+
| nf   | stu_id | lesson_id | score |
+------+--------+-----------+-------+
|    1 |      2 | L001      |    84 |
|    1 |      1 | L001      |    98 |
|    2 |      4 | L001      |    99 |
|    3 |      3 | L001      |   100 |
|    1 |      1 | L002      |    86 |
|    1 |      4 | L002      |    88 |
|    2 |      2 | L002      |    90 |
|    3 |      3 | L002      |    91 |
+------+--------+-----------+-------+

NTILE(n)函数在数据分析中应用较多，比如由于数据量大，需要将数据平均分配到n个并行的进程分别计算，此时就可以用NTILE(n)对数据进行分组（由于记录数不一定被n整除，所以数据不一定完全平均），然后将不同桶号的数据再分配。

2.6 聚合函数作为窗口函数：`SUM()`、`AVG()`、`MAX()`、`MIN()`、`COUNT()`

用途：在窗口中每条记录动态地应用聚合函数（SUM()、AVG()、MAX()、MIN()、COUNT()），可以动态计算在指定的窗口内的各种聚合函数值
应用场景：截止到当前时间，学生stu_id=1的累计分数/平均分数/最高分数/最低分数/成绩记录条数

SELECT stu_id, lesson_id, score, create_time,
    SUM(score) OVER w AS score_sum,
    MAX(score) OVER w AS score_max,
    MIN(score) OVER w AS score_min
    FROM t_score
    WHERE stu_id = 1
    WINDOW w AS (PARTITION BY stu_id ORDER BY create_time);

+--------+-----------+-------+-------------+-----------+-----------+-----------+
| stu_id | lesson_id | score | create_time | score_sum | score_max | score_min |
+--------+-----------+-------+-------------+-----------+-----------+-----------+
|      1 | L001      |    98 | 2018-08-08  |       184 |        98 |        86 |
|      1 | L002      |    86 | 2018-08-08  |       184 |        98 |        86 |
|      1 | L003      |    79 | 2018-08-09  |       263 |        98 |        79 |
|      1 | L004      |    88 | 2018-08-10  |       449 |        98 |        79 |
|      1 | L005      |    98 | 2018-08-10  |       449 |        98 |        79 |
+--------+-----------+-------+-------------+-----------+-----------+-----------+

注意：sum作为窗口函数，当求和字段与排序字段相同时，如果有重复数据，会直接把相同的数据相加，并不是逐步相加。为什么呢？

2.7 Frame子句

frame是当前分区的一个子集，子句用来定义子集的规则，通常用来作为滑动窗口使用。比如要根据每个订单动态计算包括本订单和按时间顺序前后两个订单的平均订单金额，则可以设置如下frame子句来创建滑动窗口：

select * from(
    select order_id,user_no,amount,
    avg(amount) over w as avg_num,
    create_date
    from order_tabl
    window w as (partition by user_no order by create_date desc rows between 1 preceding and 1 following)
)t;

+----------+---------+--------+-----------+---------------------+
| order_id | user_no | amount |   avg_num |         create_date |
+----------+-----------+-------+-------- -+---------------------+
|        5 | 001     |    900 | 850.0000  | 2018-01-04 00:00:00 |
|        4 | 001     |    800 | 666.6667  | 2018-01-03 00:00:00 | 
|        2 | 001     |    300 | 533.3333  | 2018-01-02 00:00:00 |
|        3 | 001     |    500 | 300.0000  | 2018-01-02 00:00:00 |
|        1 | 001     |    100 | 300.0000  | 2018-01-01 00:00:00 |
|       10 | 002     |    800 | 800.0000  | 2018-01-22 00:00:00 |
|        9 | 002     |    800 | 633.3333  | 2018-01-16 00:00:00 |
|        8 | 002     |    300 | 566.6667  | 2018-01-10 00:00:00 |
|        7 | 002     |    600 | 466.6667  | 2018-01-04 00:00:00 |
|        6 | 002     |    500 | 550.0000  | 2018-01-03 00:00:00 |
+----------+---------+--------+-----------+---------------------+

从结果可以看出，order_id为5订单属于边界值，没有前一行，因此平均订单金额为(900+800)/2=850；order_id为4的订单前后都有订单，所以平均订单金额为（900+800+300）/3=666.6667，以此类推就可以得到一个基于滑动窗口的动态平均订单值。

对于滑动窗口的范围指定，有两种方式，基于行和基于范围，具体区别如下：

① 基于行：通常使用BETWEEN frame_start AND frame_end语法来表示行范围，frame_start和frame_end可以支持如下关键字，来确定不同的动态行记录：

CURRENT ROW 边界是当前行，一般和其他范围关键字一起使用
UNBOUNDED PRECEDING 边界是分区中的第一行
UNBOUNDED FOLLOWING 边界是分区中的最后一行
expr PRECEDING 边界是当前行减去expr的值
expr FOLLOWING 边界是当前行加上expr的值

rows BETWEEN 1 PRECEDING AND 1 FOLLOWING 窗口范围是当前行、前一行、后一行一共三行记录。

rows UNBOUNDED FOLLOWING 窗口范围是当前行到分区中的最后一行。

rows BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING 窗口范围是当前分区中所有行，等同于不写。（last_value的窗口范围是窗口首行-当前行！即rows BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW）

② 基于范围：有些范围不可直接用行数来表示，比如窗口范围是一周前订单开始，截止到当前行，无法使用rows来表示，此时就可以使用范围来表示窗口：INTERVAL 7 DAY PRECEDING。Linux中常见的最近1分钟、5分钟负载是一个典型的应用场景。有的函数不管有没有frame子句，它的窗口都是固定的，也就是前面介绍的静态窗口，这些函数包括如下（排序/前后/分布等函数）：

DENSE_RANK()、RANK()、ROW_NUMBER()

LAG()、LEAD()

PERCENT_RANK()、CUME_DIST()

NTILE()

接下来我们以会员订单表dm_order_2018为例，来介绍每个函数的使用方法。表里包含了如下字段：订单id，订单金额，会员id，订单创建时间，订单状态等。

3. 窗口函数实战

3.1 基础数据准备

（1）建表

CREATE TABLE dm_order_2018
(
    id          varchar(100) DEFAULT NULL COMMENT '订单id',
    order_money float        DEFAULT NULL COMMENT '订单金额',
    member_id   int(11)      DEFAULT NULL COMMENT '会员id',
    create_time timestamp    DEFAULT NULL COMMENT '创建时间',
    status      int(11)      DEFAULT NULL COMMENT '订单状态|0：取消，1：待支付，2:付款成功'
);

（2）插入数据

INSERT INTO dm_order_2018 VALUES ('A001', '100.15', '1', '2018-01-01 13:23:12', '2');
INSERT INTO dm_order_2018 VALUES ('A023', '100.15', '1', '2018-01-01 15:23:12', '2');
INSERT INTO dm_order_2018 VALUES ('A002', '100', '2', '2018-04-01 14:23:12', '2');
INSERT INTO dm_order_2018 VALUES ('A003', '12.1', '3', '2018-01-01 13:23:12', '2');
INSERT INTO dm_order_2018 VALUES ('A004', '200.15', '4', '2018-01-01 13:23:12', '2');
INSERT INTO dm_order_2018 VALUES ('A005', '1200.15', '5', '2018-01-01 13:23:12', '2');
INSERT INTO dm_order_2018 VALUES ('A006', '0.15', '11', '2018-01-01 17:23:12', '2');
INSERT INTO dm_order_2018 VALUES ('A007', '1215.1', '31', '2018-01-01 10:23:12', '2');
INSERT INTO dm_order_2018 VALUES ('A008', '100.75', '15', '2018-01-01 14:23:12', '2');
INSERT INTO dm_order_2018 VALUES ('A009', '100.15', '8', '2018-01-01 15:23:12', '2');
INSERT INTO dm_order_2018 VALUES ('A010', '20.15', '9', '2018-01-01 16:23:12', '2');
INSERT INTO dm_order_2018 VALUES ('A011', '110.15', '21', '2018-01-01 14:23:12', '2');
INSERT INTO dm_order_2018 VALUES ('A012', '1.15', '13', '2018-01-01 13:03:12', '2');
INSERT INTO dm_order_2018 VALUES ('A013', '20.15', '14', '2018-02-01 13:53:12', '2');
INSERT INTO dm_order_2018 VALUES ('A014', '30.15', '15', '2018-03-01 13:23:12', '2');
INSERT INTO dm_order_2018 VALUES ('A015', '40.5', '13', '2018-01-01 13:23:12', '2');
INSERT INTO dm_order_2018 VALUES ('A016', '65', '1', '2017-01-01 13:23:12', '2');
INSERT INTO dm_order_2018 VALUES ('A017', '78.15', '1', '2017-03-01 09:23:12', '1');
INSERT INTO dm_order_2018 VALUES ('A018', '88.15', '1', '2017-11-01 20:23:12', '2');
INSERT INTO dm_order_2018 VALUES ('A019', '99', '12', '2018-02-11 13:23:12', '1');
INSERT INTO dm_order_2018 VALUES ('A020', '10.3', '13', '2018-04-01 13:23:12', '2');
INSERT INTO dm_order_2018 VALUES ('A021', '600', '5', '2018-11-01 08:58:31', '2');
INSERT INTO dm_order_2018 VALUES ('A022', '500', '31', '2018-11-11 08:59:02', '2');

（3）查看数据

select * FROM dm_order_2018;

+----+-----------+---------+-------------------+------+
|id  |order_money|member_id|create_time        |status|
+----+-----------+---------+-------------------+------+
|A022|500        |31       |2018-11-11 08:59:02|2     |
|A001|100.15     |1        |2018-01-01 13:23:12|2     |
|A023|100.15     |1        |2018-01-01 15:23:12|2     |
|A002|100        |2        |2018-04-01 14:23:12|2     |
|A003|12.1       |3        |2018-01-01 13:23:12|2     |
|A004|200.15     |4        |2018-01-01 13:23:12|2     |
|A005|1200.15    |5        |2018-01-01 13:23:12|2     |
|A006|0.15       |11       |2018-01-01 17:23:12|2     |
|A007|1215.1     |31       |2018-01-01 10:23:12|2     |
|A008|100.75     |15       |2018-01-01 14:23:12|2     |
|A009|100.15     |8        |2018-01-01 15:23:12|2     |
|A010|20.15      |9        |2018-01-01 16:23:12|2     |
|A011|110.15     |21       |2018-01-01 14:23:12|2     |
|A012|1.15       |13       |2018-01-01 13:03:12|2     |
|A013|20.15      |14       |2018-02-01 13:53:12|2     |
|A014|30.15      |15       |2018-03-01 13:23:12|2     |
|A015|40.5       |13       |2018-01-01 13:23:12|2     |
|A016|65         |1        |2017-01-01 13:23:12|2     |
|A017|78.15      |1        |2017-03-01 09:23:12|1     |
|A018|88.15      |1        |2017-11-01 20:23:12|2     |
|A019|99         |12       |2018-02-11 13:23:12|1     |
|A020|10.3       |13       |2018-04-01 13:23:12|2     |
|A021|600        |5        |2018-11-01 08:58:31|2     |
+----+-----------+---------+-------------------+------+

3.2 窗口函数用法实战

（1）序号函数：row_number() / rank() / dense_rank()

查询排序小于等于3的订单：

select *
FROM (
         select id,
                order_money,
                member_id,
                create_time,
                row_number() over (partition by member_id ORDER BY order_money desc) as row_num
         from dm_order_2018
     ) t
where row_num <= 3;

+----+-----------+---------+-------------------+-------+
|id  |order_money|member_id|create_time        |row_num|
+----+-----------+---------+-------------------+-------+
|A001|100.15     |1        |2018-01-01 13:23:12|1      |
|A023|100.15     |1        |2018-01-01 15:23:12|2      |
|A018|88.15      |1        |2017-11-01 20:23:12|3      |
|A002|100        |2        |2018-04-01 14:23:12|1      |
|A003|12.1       |3        |2018-01-01 13:23:12|1      |
|A004|200.15     |4        |2018-01-01 13:23:12|1      |
|A005|1200.15    |5        |2018-01-01 13:23:12|1      |
|A021|600        |5        |2018-11-01 08:58:31|2      |
|A009|100.15     |8        |2018-01-01 15:23:12|1      |
|A010|20.15      |9        |2018-01-01 16:23:12|1      |
|A006|0.15       |11       |2018-01-01 17:23:12|1      |
|A019|99         |12       |2018-02-11 13:23:12|1      |
|A015|40.5       |13       |2018-01-01 13:23:12|1      |
|A020|10.3       |13       |2018-04-01 13:23:12|2      |
|A012|1.15       |13       |2018-01-01 13:03:12|3      |
|A013|20.15      |14       |2018-02-01 13:53:12|1      |
|A008|100.75     |15       |2018-01-01 14:23:12|1      |
|A014|30.15      |15       |2018-03-01 13:23:12|2      |
|A011|110.15     |21       |2018-01-01 14:23:12|1      |
|A007|1215.1     |31       |2018-01-01 10:23:12|1      |
|A022|500        |31       |2018-11-11 08:59:02|2      |
+----+-----------+---------+-------------------+-------+

多种排序方式：

select *
FROM (select id,
             order_money,
             member_id,
             create_time,
             row_number() over (partition by member_id ORDER BY order_money desc) as row_num1,
             rank() over (partition by member_id ORDER BY order_money desc)       as row_num2,
             dense_rank() over (partition by member_id ORDER BY order_money desc) as row_num3
      from dm_order_2018
     ) t;

+----+-----------+---------+-------------------+--------+--------+--------+
|id  |order_money|member_id|create_time        |row_num1|row_num2|row_num3|
+----+-----------+---------+-------------------+--------+--------+--------+
|A001|100.15     |1        |2018-01-01 13:23:12|1       |1       |1       |
|A023|100.15     |1        |2018-01-01 15:23:12|2       |1       |1       |
|A018|88.15      |1        |2017-11-01 20:23:12|3       |3       |2       |
|A017|78.15      |1        |2017-03-01 09:23:12|4       |4       |3       |
|A016|65         |1        |2017-01-01 13:23:12|5       |5       |4       |
|A002|100        |2        |2018-04-01 14:23:12|1       |1       |1       |
|A003|12.1       |3        |2018-01-01 13:23:12|1       |1       |1       |
|A004|200.15     |4        |2018-01-01 13:23:12|1       |1       |1       |
|A005|1200.15    |5        |2018-01-01 13:23:12|1       |1       |1       |
|A021|600        |5        |2018-11-01 08:58:31|2       |2       |2       |
|A009|100.15     |8        |2018-01-01 15:23:12|1       |1       |1       |
|A010|20.15      |9        |2018-01-01 16:23:12|1       |1       |1       |
|A006|0.15       |11       |2018-01-01 17:23:12|1       |1       |1       |
|A019|99         |12       |2018-02-11 13:23:12|1       |1       |1       |
|A015|40.5       |13       |2018-01-01 13:23:12|1       |1       |1       |
|A020|10.3       |13       |2018-04-01 13:23:12|2       |2       |2       |
|A012|1.15       |13       |2018-01-01 13:03:12|3       |3       |3       |
|A013|20.15      |14       |2018-02-01 13:53:12|1       |1       |1       |
|A008|100.75     |15       |2018-01-01 14:23:12|1       |1       |1       |
|A014|30.15      |15       |2018-03-01 13:23:12|2       |2       |2       |
|A011|110.15     |21       |2018-01-01 14:23:12|1       |1       |1       |
|A007|1215.1     |31       |2018-01-01 10:23:12|1       |1       |1       |
|A022|500        |31       |2018-11-11 08:59:02|2       |2       |2       |
+----+-----------+---------+-------------------+--------+--------+--------+

rank（）会产生序号相同的记录，同时可能产生序号间隙，如1，1，3；而dense_rank（）也会产生序号相同的记录，但不会产生序号间隙，如1，1，2。

（2）分布函数：percent_rank() / cume_dist()

查看数据的分位数：

select *
FROM (select id,
             order_money,
             member_id,
             create_time,
             row_number() over w   as row_num,
             percent_rank() over w as percent
      from dm_order_2018
          window w as (partition by member_id ORDER BY create_time DESC)
     ) t;

+----+-----------+---------+-------------------+-------+-------+
|id  |order_money|member_id|create_time        |row_num|percent|
+----+-----------+---------+-------------------+-------+-------+
|A023|100.15     |1        |2018-01-01 15:23:12|1      |0      |
|A001|100.15     |1        |2018-01-01 13:23:12|2      |0.25   |
|A018|88.15      |1        |2017-11-01 20:23:12|3      |0.5    |
|A017|78.15      |1        |2017-03-01 09:23:12|4      |0.75   |
|A016|65         |1        |2017-01-01 13:23:12|5      |1      |
|A002|100        |2        |2018-04-01 14:23:12|1      |0      |
|A003|12.1       |3        |2018-01-01 13:23:12|1      |0      |
|A004|200.15     |4        |2018-01-01 13:23:12|1      |0      |
|A021|600        |5        |2018-11-01 08:58:31|1      |0      |
|A005|1200.15    |5        |2018-01-01 13:23:12|2      |1      |
|A009|100.15     |8        |2018-01-01 15:23:12|1      |0      |
|A010|20.15      |9        |2018-01-01 16:23:12|1      |0      |
|A006|0.15       |11       |2018-01-01 17:23:12|1      |0      |
|A019|99         |12       |2018-02-11 13:23:12|1      |0      |
|A020|10.3       |13       |2018-04-01 13:23:12|1      |0      |
|A015|40.5       |13       |2018-01-01 13:23:12|2      |0.5    |
|A012|1.15       |13       |2018-01-01 13:03:12|3      |1      |
|A013|20.15      |14       |2018-02-01 13:53:12|1      |0      |
|A014|30.15      |15       |2018-03-01 13:23:12|1      |0      |
|A008|100.75     |15       |2018-01-01 14:23:12|2      |1      |
|A011|110.15     |21       |2018-01-01 14:23:12|1      |0      |
|A022|500        |31       |2018-11-11 08:59:02|1      |0      |
|A007|1215.1     |31       |2018-01-01 10:23:12|2      |1      |
+----+-----------+---------+-------------------+-------+-------+

大于等于当前订单金额的订单比例有多少：

select *
FROM (select id,
             order_money,
             member_id,
             create_time,
             row_number() over w   as row_num,
             percent_rank() over w as percent
      from dm_order_2018
          window w as (partition by member_id ORDER BY create_time DESC)
     ) t;

+----+-----------+---------+-------------------+-------+-------+
|id  |order_money|member_id|create_time        |row_num|percent|
+----+-----------+---------+-------------------+-------+-------+
|A023|100.15     |1        |2018-01-01 15:23:12|1      |0      |
|A001|100.15     |1        |2018-01-01 13:23:12|2      |0.25   |
|A018|88.15      |1        |2017-11-01 20:23:12|3      |0.5    |
|A017|78.15      |1        |2017-03-01 09:23:12|4      |0.75   |
|A016|65         |1        |2017-01-01 13:23:12|5      |1      |
|A002|100        |2        |2018-04-01 14:23:12|1      |0      |
|A003|12.1       |3        |2018-01-01 13:23:12|1      |0      |
|A004|200.15     |4        |2018-01-01 13:23:12|1      |0      |
|A021|600        |5        |2018-11-01 08:58:31|1      |0      |
|A005|1200.15    |5        |2018-01-01 13:23:12|2      |1      |
|A009|100.15     |8        |2018-01-01 15:23:12|1      |0      |
|A010|20.15      |9        |2018-01-01 16:23:12|1      |0      |
|A006|0.15       |11       |2018-01-01 17:23:12|1      |0      |
|A019|99         |12       |2018-02-11 13:23:12|1      |0      |
|A020|10.3       |13       |2018-04-01 13:23:12|1      |0      |
|A015|40.5       |13       |2018-01-01 13:23:12|2      |0.5    |
|A012|1.15       |13       |2018-01-01 13:03:12|3      |1      |
|A013|20.15      |14       |2018-02-01 13:53:12|1      |0      |
|A014|30.15      |15       |2018-03-01 13:23:12|1      |0      |
|A008|100.75     |15       |2018-01-01 14:23:12|2      |1      |
|A011|110.15     |21       |2018-01-01 14:23:12|1      |0      |
|A022|500        |31       |2018-11-11 08:59:02|1      |0      |
|A007|1215.1     |31       |2018-01-01 10:23:12|2      |1      |
+----+-----------+---------+-------------------+-------+-------+

（3）前后函数：lag() / lead()

-- 查询上一个订单距离当前订单的时间间隔。
select id, order_money, member_id, create_time, last_time, datediff(create_time, last_time) as diff
FROM (select id,
             order_money,
             member_id,
             create_time,
             lag(create_time, 1) over w as last_time
      from dm_order_2018
          window w as (partition by member_id ORDER BY create_time ASC)
     ) t;

+----+-----------+---------+-------------------+-------------------+----+
|id  |order_money|member_id|create_time        |last_time          |diff|
+----+-----------+---------+-------------------+-------------------+----+
|A016|65         |1        |2017-01-01 13:23:12|NULL               |NULL|
|A017|78.15      |1        |2017-03-01 09:23:12|2017-01-01 13:23:12|59  |
|A018|88.15      |1        |2017-11-01 20:23:12|2017-03-01 09:23:12|245 |
|A001|100.15     |1        |2018-01-01 13:23:12|2017-11-01 20:23:12|61  |
|A023|100.15     |1        |2018-01-01 15:23:12|2018-01-01 13:23:12|0   |
|A002|100        |2        |2018-04-01 14:23:12|NULL               |NULL|
|A003|12.1       |3        |2018-01-01 13:23:12|NULL               |NULL|
|A004|200.15     |4        |2018-01-01 13:23:12|NULL               |NULL|
|A005|1200.15    |5        |2018-01-01 13:23:12|NULL               |NULL|
|A021|600        |5        |2018-11-01 08:58:31|2018-01-01 13:23:12|304 |
|A009|100.15     |8        |2018-01-01 15:23:12|NULL               |NULL|
|A010|20.15      |9        |2018-01-01 16:23:12|NULL               |NULL|
|A006|0.15       |11       |2018-01-01 17:23:12|NULL               |NULL|
|A019|99         |12       |2018-02-11 13:23:12|NULL               |NULL|
|A012|1.15       |13       |2018-01-01 13:03:12|NULL               |NULL|
|A015|40.5       |13       |2018-01-01 13:23:12|2018-01-01 13:03:12|0   |
|A020|10.3       |13       |2018-04-01 13:23:12|2018-01-01 13:23:12|90  |
|A013|20.15      |14       |2018-02-01 13:53:12|NULL               |NULL|
|A008|100.75     |15       |2018-01-01 14:23:12|NULL               |NULL|
|A014|30.15      |15       |2018-03-01 13:23:12|2018-01-01 14:23:12|59  |
|A011|110.15     |21       |2018-01-01 14:23:12|NULL               |NULL|
|A007|1215.1     |31       |2018-01-01 10:23:12|NULL               |NULL|
|A022|500        |31       |2018-11-11 08:59:02|2018-01-01 10:23:12|314 |
+----+-----------+---------+-------------------+-------------------+----+

可以看到，没有匹配到的数值默认以null填充。

（4）头尾函数：ﬁrst_val() / last_val()

-- 查询截止到当前订单，按照日期排序第一个订单和最后一个订单的订单金额。
select *
FROM (select id,
             order_money,
             member_id,
             create_time,
             first_value(order_money) over w as first_money,
             last_value(order_money) over w  as last_money
      from dm_order_2018
          window w as (partition by member_id ORDER BY create_time ASC)
     ) t;

+----+-----------+---------+-------------------+-------------------+-------------------+
|id  |order_money|member_id|create_time        |first_money        |last_money         |
+----+-----------+---------+-------------------+-------------------+-------------------+
|A016|65         |1        |2017-01-01 13:23:12|65                 |65                 |
|A017|78.15      |1        |2017-03-01 09:23:12|65                 |78.1500015258789   |
|A018|88.15      |1        |2017-11-01 20:23:12|65                 |88.1500015258789   |
|A001|100.15     |1        |2018-01-01 13:23:12|65                 |100.1500015258789  |
|A023|100.15     |1        |2018-01-01 15:23:12|65                 |100.1500015258789  |
|A002|100        |2        |2018-04-01 14:23:12|100                |100                |
|A003|12.1       |3        |2018-01-01 13:23:12|12.100000381469727 |12.100000381469727 |
|A004|200.15     |4        |2018-01-01 13:23:12|200.14999389648438 |200.14999389648438 |
|A005|1200.15    |5        |2018-01-01 13:23:12|1200.1500244140625 |1200.1500244140625 |
|A021|600        |5        |2018-11-01 08:58:31|1200.1500244140625 |600                |
|A009|100.15     |8        |2018-01-01 15:23:12|100.1500015258789  |100.1500015258789  |
|A010|20.15      |9        |2018-01-01 16:23:12|20.149999618530273 |20.149999618530273 |
|A006|0.15       |11       |2018-01-01 17:23:12|0.15000000596046448|0.15000000596046448|
|A019|99         |12       |2018-02-11 13:23:12|99                 |99                 |
|A012|1.15       |13       |2018-01-01 13:03:12|1.149999976158142  |1.149999976158142  |
|A015|40.5       |13       |2018-01-01 13:23:12|1.149999976158142  |40.5               |
|A020|10.3       |13       |2018-04-01 13:23:12|1.149999976158142  |10.300000190734863 |
|A013|20.15      |14       |2018-02-01 13:53:12|20.149999618530273 |20.149999618530273 |
|A008|100.75     |15       |2018-01-01 14:23:12|100.75             |100.75             |
|A014|30.15      |15       |2018-03-01 13:23:12|100.75             |30.149999618530273 |
|A011|110.15     |21       |2018-01-01 14:23:12|110.1500015258789  |110.1500015258789  |
|A007|1215.1     |31       |2018-01-01 10:23:12|1215.0999755859375 |1215.0999755859375 |
|A022|500        |31       |2018-11-11 08:59:02|1215.0999755859375 |500                |
+----+-----------+---------+-------------------+-------------------+-------------------+

查询截止到当前订单，按照日期排序第一个订单和最后一个订单的订单金额。

（5）滑动窗口示例

select id,
       order_money,
       member_id,
       create_time,
       avg(order_money) over w as avg_num,
       sum(order_money) over w as sum_num
from dm_order_2018
    window w as (partition by member_id order by create_time desc rows between 1 preceding and 1 following)

+----+-----------+---------+-------------------+-------------------+-------------------+
|id  |order_money|member_id|create_time        |avg_num            |sum_num            |
+----+-----------+---------+-------------------+-------------------+-------------------+
|A023|100.15     |1        |2018-01-01 15:23:12|100.1500015258789  |200.3000030517578  |
|A001|100.15     |1        |2018-01-01 13:23:12|96.1500015258789   |288.4500045776367  |
|A018|88.15      |1        |2017-11-01 20:23:12|88.81666819254558  |266.4500045776367  |
|A017|78.15      |1        |2017-03-01 09:23:12|77.10000101725261  |231.3000030517578  |
|A016|65         |1        |2017-01-01 13:23:12|71.57500076293945  |143.1500015258789  |
|A002|100        |2        |2018-04-01 14:23:12|100                |100                |
|A003|12.1       |3        |2018-01-01 13:23:12|12.100000381469727 |12.100000381469727 |
|A004|200.15     |4        |2018-01-01 13:23:12|200.14999389648438 |200.14999389648438 |
|A021|600        |5        |2018-11-01 08:58:31|900.0750122070312  |1800.1500244140625 |
|A005|1200.15    |5        |2018-01-01 13:23:12|900.0750122070312  |1800.1500244140625 |
|A009|100.15     |8        |2018-01-01 15:23:12|100.1500015258789  |100.1500015258789  |
|A010|20.15      |9        |2018-01-01 16:23:12|20.149999618530273 |20.149999618530273 |
|A006|0.15       |11       |2018-01-01 17:23:12|0.15000000596046448|0.15000000596046448|
|A019|99         |12       |2018-02-11 13:23:12|99                 |99                 |
|A020|10.3       |13       |2018-04-01 13:23:12|25.40000009536743  |50.80000019073486  |
|A015|40.5       |13       |2018-01-01 13:23:12|17.31666672229767  |51.950000166893005 |
|A012|1.15       |13       |2018-01-01 13:03:12|20.82499998807907  |41.64999997615814  |
|A013|20.15      |14       |2018-02-01 13:53:12|20.149999618530273 |20.149999618530273 |
|A014|30.15      |15       |2018-03-01 13:23:12|65.44999980926514  |130.89999961853027 |
|A008|100.75     |15       |2018-01-01 14:23:12|65.44999980926514  |130.89999961853027 |
|A011|110.15     |21       |2018-01-01 14:23:12|110.1500015258789  |110.1500015258789  |
|A022|500        |31       |2018-11-11 08:59:02|857.5499877929688  |1715.0999755859375 |
|A007|1215.1     |31       |2018-01-01 10:23:12|857.5499877929688  |1715.0999755859375 |
+----+-----------+---------+-------------------+-------------------+-------------------+

从结果可以看出，id为A001订单属于边界值，没有前一行，因此平均订单金额为(100.15+100.15)/2=100.15；第二行id为A001的订单前后都有订单，所以平均订单金额为（100.15+100.15+88.15/3=96.15；以此类推就可以得到一个基于滑动窗口的动态平均订单值。此例中，窗口函数用到了传统的聚合函数avg()，用来计算动态的平均值。

4. 相关业务问题

每个类别下用户最喜欢的产品是哪个？
每个类别下用户点击最多的5个商品是什么？

4.1 解决方法

分组取最大值(用关联子查询）：查询每个学号成绩最大的所有信息

SELECT* FROM score AS a WHERE 成绩=( SELECT MAX(成绩) FROM score AS b WHERE a.`学号`=b.`学号`);

分组取最小值：查询每个学号成绩最小的所有信息

SELECT* FROM score AS a WHERE 成绩=( SELECT MIN(成绩) FROM score AS b WHERE a.`学号`=b.`学号`);

分组取最大N条记录：查询每个学生成绩最高的两个科目

SELECT * FROM (SELECT*,row_number() over (PARTITION BY 姓名 ORDER BY 成绩 DESC) AS ranking FROM test1) AS newtest WHERE ranking<=2;

说明：

为了不受并列的影响，该题用row_number()
易错写法：select*, row_number() over(partition by 姓名 order by 成绩 desc） as ranking from test where ranking<=2; 按照sql运行顺序，where后边不能加别名，因为select在where后运行
涉及到既要分组又要排序的情况，要想到用窗口函数

4.2 TOPN问题模板

SELECT * FROM (SELECT*,row_number() over (PARTITION BY 姓名 ORDER BY 成绩 DESC) AS ranking FROM test1) AS newtest WHERE ranking<=N;

4.3 聚合函数作为窗口函数

聚合函数作为窗口函数，是起到"累加/累计"的效果，比如截止到本行，最大值，最小值是多少。与专用窗口函数的区别：括号中需要有指定列，不能为空

举例1：查询成绩的累加

SELECT*, SUM(成绩) over (ORDER BY 成绩 DESC) AS '求和' FROM class;

举例2：查找单科成绩高于该科目平均成绩的学生名单

（1）解法一：单科成绩需按科目分组，分组有两种：group by子句和窗口函数的partition by；要求平均值，通过avg()实现，并且找到大于平均值的学生，那么不能减少行数，则用partition by；

#错误解法：不能用where 成绩>分组平均值，因为where子句在select子句之后执行
select * ,avg(成绩) over (partition by 科目) as 分组平均值 from test3 where 成绩>分组平均值

#正确解法： 
select * from (select * ,avg(成绩) over (partition by 科目) as 分组平均值 from test3)as a where 成绩>分组平均值;

（2）解法二：关联子查询；

SELECT* FROM test3 AS a WHERE 成绩>(SELECT AVG(成绩) AS 平均值 FROM test3 AS b WHERE a.`科目`=b.`科目`);

5. 总结

1. 语法：窗口函数 over (partition by 用于分列的列名 order by 用于排序的列名）

2. 功能：既能分组又可以排序，且不改变行数

3. 分类：序号函数、分布函数、前后函数、头尾函数、聚合函数、其他函数等

4. 注意事项：一般写在select子句中

今天分享下MySQL中的窗口函数的实际操作，这对分析查询很有帮助，希望对大家有帮助。谢谢支持

欢迎关注微信公众号，访问更多精彩：数据星球DataStar。

如需转载，请联系授权，谢谢合作。

引文链接：

[1]MySQL操作实战（二）：窗口函数

https://blog.csdn.net/weixin_39010770/article/details/87862407

[2]数据分析系列 18/32 | MySQL中的数据分析函数实战

https://zhuanlan.zhihu.com/p/137711813

[3]MySQL 8.0窗口函数

https://www.cnblogs.com/DataArt/p/9961676.html

你可能感兴趣的:(mysql题库大全,数据库,窗口函数)

python dashboard django_Django + MySQL Dashboard 网页端数据库可视化 weixin_39639600 python dashboard django
1.OverviewPython+MySQL+Django,有些数据托管在MySQL的数据库，然后我们希望进行可视化，通过web的方式对数据库的信息去进行展示/检索/维护/..这个项目中，我们的数据托管在MySQL的数据库中，然后在Django中配置数据库信息，连接到数据库，在前端用Django-table2进行渲染;最终我们可以在web端看到如下所示效果，可以进行展示所有的数据，然后进行检索和过
SQL调优 - 优化 MySQL 中的 IN 语句查询效率逍遥Sean SQL设计与调优实战 sql mysql 数据库
作者：逍遥Sean简介：一个主修Java的Web网站\游戏服务器后端开发者主页：https://blog.csdn.net/Ureliable觉得博主文章不错的话，可以三连支持一下~如有疑问和建议，请私信或评论留言！前言在使用MySQL进行开发时，我们经常会使用到IN语句来查询某个字段是否包含在一个给定的值集合中。然而，当这个值集合的数量超过一定的限制时，IN语句可能会导致查询效率显著下降，甚至引
MySQL 如何深度分页问题 My LQS 历史经验篇学习笔记篇 mysql 数据库
在实际的数据库应用场景中，我们常常会遇到需要进行分页查询的需求。对于少量数据的分页查询，MySQL可以轻松应对。然而，当我们需要进行深度分页（即从大量数据的中间位置开始获取少量数据）时，就会面临性能严重下降的问题。本文将深入探讨MySQL深度分页的问题，并介绍子查询和滚动ID这两种有效的解决方式。深度分页问题背景深度分页通常是指使用LIMITm,n语句进行查询，其中m是偏移量，n是要返回的记录数。
Spring Boot项目使用MyBatis Plus的详细步骤 wujiada001 Java spring boot mybatis 后端
在SpringBoot项目中使用MyBatisPlus，可以极大地简化数据库操作，提高开发效率。以下是在SpringBoot项目中集成和使用MyBatisPlus的详细步骤：一、环境准备确保已安装Java和SpringBoot：MyBatisPlus是基于Java和SpringBoot的，因此需要先安装好这两个环境。创建SpringBoot项目：可以使用SpringInitializr（https
Java数据库连接：手写代码实现MySQL或Oracle连接并操作数据 bug菌¹ Java实战(进阶版)java 手动连接mysql 手动连接数据库手动连接Oracle Oracle MySQL
‍作者：bug菌✏️博客：CSDN、掘金、infoQ、51CTO等简介：CSDN|阿里云|华为云|51CTO等社区博客专家，历届博客之星Top30，掘金年度人气作者Top40，51CTO年度博主Top12，掘金|InfoQ|51CTO等社区优质创作者，全网粉丝合计15w+；硬核微信公众号
SQL范式与反范式_优化数据库性能随风九天匠心数据库 java 数据库 sql 范式反范式
1.引言什么是SQL范式SQL范式是指数据库设计中的一系列规则和标准，旨在减少数据冗余、提高数据完整性和一致性。常见的范式包括第一范式（1NF）、第二范式（2NF）、第三范式（3NF）和BCNF（Boyce-Codd范式）。什么是SQL反范式SQL反范式是指在满足范式要求的基础上，有意引入数据冗余以提高查询性能。反范式通常用于读取密集型的应用场景，以减少查询时的连接操作，提高查询效率。为什么需要优
springboot/ssm教学资源管理系统web在线课程教学视频Java代码编写 Java学长-kirito java spring boot spring
springboot/ssm教学资源管理系统web在线课程教学视频Java代码编写基于springboot(可改ssm)+vue项目开发语言：Java框架：springboot/可改ssm+vueJDK版本：JDK1.8（或11）服务器：tomcat数据库：mysql5.7（或8.0）数据库工具：Navicat/sqlyog开发软件：eclipse/idea依赖管理包：Maven代码+数据库保证完
Spring Boot整合MyBatis-Plus以及实现分页 Demon_Hao spring boot mybatis
MyBatis-Plus是MyBatis的一个增强工具包，它在原有的MyBatis框架之上提供了更多便捷的功能和增强，有助于简化开发流程、提高开发效率。以下是MyBatis-Plus的一些主要特点和功能：CRUD操作增强：MyBatis-Plus提供了一套强大的CRUD方法，可以帮助开发者快速完成常见的数据库操作，无需编写繁琐的SQL语句，从而简化了数据访问的操作。条件构造器：MyBatis-Pl
Oracle 分区在什么情况下使用？思维导图代码示例（java 架构) 用心去追梦 oracle java 架构
Oracle分区的适用场景Oracle分区（Partitioning）是一种强大的数据管理工具，适用于特定类型的数据库工作负载和数据结构。以下是一些适合使用分区的情况：1.大型表优化超大数据量：当表包含数百万甚至数十亿行时，分区可以帮助提高查询性能。频繁更新：对于经常被插入、更新或删除的数据，分区可以减少锁定范围，提高并发性。2.数据仓库历史数据分析：在数据仓库中，通常会存储多年的历史数据。通过按
SaaS架构设计 frank3G 框架相关 saas 架构设计数据库应用服务器 session 扩展
对于SaaS应用的可伸缩，最理想的情况：随着用户数的增大，系统架构不用做调整，而仅需要增加/增强相应的硬件设备（应用服务器、数据库服务器）即可。而通常强调的应用架构具有可伸缩性，一般指的是可以实现”Scaleout”，即水平扩展或者向外扩展。而”Scaleup”通常为垂直扩展或者向上扩展，也就是增强硬件设备，这种方式几乎是任何应用架构普遍适用的，但是通常都会面临高成本的问题。1、应用服务器层的水平
《SaaS架构设计》试读 DavyYew 11）SaaS与Cloud saas 架构设计云计算 salesforce 互联网数据库
SaaS基础架构—云计算今天的互联网业界对云计算的关注程度，已经不亚于对一次革命。微软、谷歌、Salesforce、Amazon等国外软件巨头纷纷推出了自己的云计算系统，意图领导这一轮的软件新浪潮。国内的阿里巴巴也已经投入大量资源进入云计算这片新的海洋。基于互联网的软件系统需要承担海量的数据、文件、数据库里的数据，等等。这就必然需要可扩充的、廉价的、可靠的和高性能的网络硬盘来提供图片、视频、博客等
注册表知识与技巧大全 George-Yao Other microsoft windows user system internet shell
注册表知识和技巧大全注册表基础：********系统文件夹：*********名称路径含义AppDataC:＼Windows＼ApplicationData应用程序CacheC:＼Windows＼TemporaryInternetFiles浏览器缓存CookiesC:＼Windows＼CookiesDesktopDesktop桌面FavoritesFavorites收藏夹FontsFonts字体H
ArcGIS——数据库与服务备份（一、oracle中的geodatabase备份使用impdp与expdp） gis_morningsun GIS ArcGIS JavaScript 数据备份 geodatabase impdpexpdp arcgis oracle
一、引言谷歌百度文章已翻烂，自己想找的东西也找不到，硬是靠着自己偷懒的毅力来搞定了这个问题。一般文章建议空间数据库从arcmap中备份恢复，普通数据使用传统的oracle备份恢复，我认为都是存储在数据库中，应该有办法从oracle层面可以一起备份的，这就是这篇文章的起源。从此走向了一条不归路。二、oracle中geodatabase备份过程1、创建企业级geodatabase安装oracle客户端
笔记系列----逻辑备份和恢复 imp/exp/impdp/expdp 柠檬 oracle 数据库 sql
注：需要打开监听1.传统的导入导出exp/imp传统的导入导出程序是exp/imp，用于实施数据库的逻辑备份和恢复导出程序exp将数据库的对象定义和数据被分到一个二进制文件中导入程序imp将二进制中的对象定义和数据导入到数据库中导入导出程序特点：1）按时间保存2）允许导出指定表，并重新导入新的数据库中3）可以把数据库迁移到另外一台异构服务器上4）在2个不同版本的oracle之间的数据传输数据5）在
车载诊断数据库---ODX数据库解析车载诊断技术车载电子电气架构数据库人工智能 AUTOSAR 架构软件工程汽车
我是穿拖鞋的汉子，魔都中坚持长期主义的汽车电子工程师。老规矩，分享一段喜欢的文字，避免自己成为高知识低文化的工程师：屏蔽力是信息过载时代一个人的特殊竞争力，任何消耗你的人和事，多看一眼都是你的不对。非必要不费力证明自己，无利益不试图说服别人，是精神上的节能减排。无人问津也好,技不如人也罢,你都要试着安静下来,去做自己该做的事.而不是让内心的烦躁、焦虑、毁掉你本就不多的热情和定力。时间不知不觉中，快
MyBatis学习：多表映射 Landy_Jay mybatis 学习数据库
目录一、多表映射概念1.1多表查询结果映射思路1.2实体类设计方案1.2.1对一关系设计1.2.2对多关系设计多表映射案例准备二、对一映射三、对多映射四、多表映射总结4.1多表映射优化4.2总结：一、多表映射概念1.1多表查询结果映射思路数据库的表结构具有复杂性，不是所有数据库都达到第三范式或BCNF范式，故数据库查询结果与java对象的属性映射也变得复杂。MyBatis使用ResultMap实现
MongoDB从入门到实战：全面掌握核心操作与Python对接技巧！ kdayjj966 windows python 服务器 mongodb 开发语言数据库
MongoDB数据库"NoSQL"⼀词最早于1998年被⽤于⼀个轻量级的关系数据库的名字随着web2.0的快速发展，NoSQL概念在2009年被提了出来NoSQL在2010年⻛⽣⽔起，现在国内外众多⼤⼩⽹站，如facebook、google、淘宝、京东、百度等，都在使⽤nosql开发⾼性能的产品对于⼀名程序员来讲，使⽤nosql已经成为⼀条必备技能NoSQL最常⻅的解释是“non-relation
java 绘制六边形_六边形架构 Java 实现 chinhoyoo java 绘制六边形
原标题：六边形架构Java实现链接：shipilev.net/jvm-anatomy-park/2-transparent-huge-pages/六边形架构是一种设计风格，通过分层实现核心逻辑与外部对象隔离。其核心逻辑是业务模块，外部元素是整合点，比如数据库、外部API、界面等。它将软件分为内部与外部，内部包含了核心业务逻辑与领域层(所谓分层架构)，外部包含界面、数据库、消息传递及其他内容。内部与
玩转数据库:Docker来安装MariaDB实录 shelby_loo 数据库 docker mariadb
各位,今天我来和大家分享一下在三丰云的Ubuntu系统下,使用Docker来安装MariaDB数据库服务的方法。首先,三丰云提供的这台1C1G10G5M的免费服务器,对我们开展实验来说已经足够了。能在云端运行环境,省去了买实体服务器的开销,对我们这些技术迷来说实在太方便了。使用Docker安装和运行MariaDB的步骤如下:拉取MariaDB镜像:dockerpullmariadb创建数据卷和启动
MySql运维篇---008：日志：错误日志、二进制日志、查询日志、慢查询日志，主从复制：概述虚拟机更改ip注意事项字节全栈_Jwy mysql 运维 android
#先登录mysqlmysql-uroot-p1234#通过此系统变量，查看当前mysql的版本中默认的日志格式是哪个showvariableslike'%binlog\_format%';1.2.3查看由于日志是以二进制方式存储的，不能直接读取，需要通过二进制日志查询工具mysqlbinlog来查看，具体语法：#logfilename：二进制文件名mysqlbinlog[参数选项]logfilen
GIt使用笔记大全 wdxylb git 笔记 elasticsearch
Git使用笔记大全1.安装Git在终端或命令提示符中，输入以下命令检查是否已安装Git：git--version如果未安装，可以从Git官方网站下载并安装适合你操作系统的版本。2.配置Git首次使用Git时，需要配置用户名和邮箱：gitconfig--globaluser.name"YourName"gitconfig--globaluser.email"[email protected]
玩转Docker | 使用Docker部署MySQL数据库心随_风动玩转Docker docker 容器运维
玩转Docker|使用Docker部署MySQL数据库玩转Docker|使用Docker部署MySQL数据库一、Docker简介（一）Docker是什么（二）Docker的优势二、准备工作（一）安装Docker（二）了解MySQL数据库三、使用Docker部署MySQL数据库（一）拉取MySQL镜像（二）运行MySQL容器（三）验证MySQL容器是否运行成功四、配置MySQL数据库（一）进入MyS
常用的数据可视化工具 python游乐园可视化信息可视化
商业智能（BI）工具Tableau：全球知名度很高的数据可视化工具。操作界面简洁易懂，支持多人协作。可以通过软件、网页、移动设备随时浏览已生成的图表。能够连接30多个数据源类型，混合数据源，还支持与R集成。PowerBI：由微软开发，可很好地集成微软的Office办公软件。支持自由导入多种数据，如文件、文件夹和数据库。有免费的基本版本，提供软件、网页、手机应用等多种查看数据的方式，具有实时馈送数据
HBase的原理会探索的小学生大数据 HBase
一、什么是HBaseHBase是一个分布式，版本化，面向列的数据库，依赖Hadoop和Zookeeper（1）HBase的优点提供高可靠性、高性能、列存储、可伸缩、实时读写的数据库系统(2)HBase表的特性Region包含多行列族包含多个列RegionServer管理一定数量的Region如果一个RegionServer宕机了，Master节点会重新将其负责的Region分配给其他RegionS
python操作sqlite3 reset2021 python基础理论 sqlite 数据库 python
01、sqlite数据库简介：SQLite，是一款轻型的数据库，它包含在一个相对小的C库中，很多嵌入式产品中使用了它，其中python就嵌入了它。所以在此就简单地讲述一下python中相关sqlite的操作。下面就数据库的常规操作，连接，增删改查几个操作进行讲述。2.1连接数据库#try-except:防止因连接失败导致程序崩溃try:#数据库文件路径db_file='saveinfo.db'#连
DBImage 使用 Jpeg 图片（VCL） pcplayer
Delphi的DBImage只支持BMP格式的图片。如果在数据库的Blob字段里面存储BMP图片，则DBImage可以自动显示图片。如果在Blob字段里面存储Jpg图片，则打开数据库的时候，如果绑定了一个DBImage到该字段，会报异常。要让DBImage支持JPEG，其核心是：TWICImage.TWICImage是Delphi10以来新增加的一个类，在Vcl.Graphics;单元里面。这个类
php代码审计学习路线子非鱼999 杂记 php 学习开发语言
学习PHP代码审计可以帮助你识别和修复PHP应用中的安全漏洞，保护应用免受恶意攻击。以下是系统的PHP代码审计学习路线，从基础到高级逐步提升：一、基础阶段：打好编程和安全基础PHP基础学习PHP语言的基础知识，如变量、数据类型、数组、字符串处理、函数、类和对象等。学习PHP的常见操作：文件处理、会话管理、数据库操作（如MySQL）。推荐资源：PHP官方文档PHP相关学习网站（如菜鸟教程）Web安全
SSM火车订票管理系统火车票务管理系统的设计与开发基于SSM框架的火车票预订系统设计与实现月影_计算机毕设课程设计
计算机毕业设计SSM火车订票管理系统3y92w（配套有源码程序mysql数据库论文）本套源码可以先看具体功能演示视频领取，文末有联xi可分享随着信息技术和网络技术的飞速发展，人类已进入全新的信息化时代，传统的管理技术已无法高效、便捷地管理信息。为了迎合时代需求，优化管理效率，各种各样的管理系统应运而生，各行各业相继进入信息管理时代，火车订票管理系统就是信息时代变革中的产物之一。火车订票管理系统的开
Python3 连接MySQL8 在奋斗的大道 python 学习笔记
第一步：安装pymysql，记住（大于python3.X）的版本：pipinstallpymysql第二步：验证pymysql是否安装成功：importpymysql#打开数据库连接#localhost为本地连接#root为用户名#password为密码#test_data为数据库db=pymysql.connect("localhost","root","123456","blog")#使用cu
python3 mysql8_python3连接MySQL8.0的两种方式 weixin_39872123 python3 mysql8
python3连接MySQL8.0的两种方式发布时间：2020-09-1913:15:14来源：脚本之家阅读：111作者：兔猪合家欢1、下载MySQL官方的mysql-connector-python-8.0.17-py3.7-windows-x86-64bit.msi，直接点击安装；2、安装完毕后直接可以导入mysql.connnector模块连接方式一：importmysql.connecto
强大的销售团队背后竟然是大数据分析的身影蓝儿唯美数据分析
Mark Roberge是HubSpot的首席财务官，在招聘销售职位时使用了大量数据分析。但是科技并没有挤走直觉。大家都知道数理学家实际上已经渗透到了各行各业。这些热衷数据的人们通过处理数据理解商业流程的各个方面，以重组弱点，增强优势。 Mark Roberge是美国HubSpot公司的首席财务官，HubSpot公司在构架集客营销现象方面出过一份力——因此他也是一位数理学家。他使用数据分析
Haproxy+Keepalived高可用双机单活 bylijinnan 负载均衡 keepalived haproxy 高可用
我们的应用MyApp不支持集群，但要求双机单活（两台机器：master和slave）： 1.正常情况下，只有master启动MyApp并提供服务 2.当master发生故障时，slave自动启动本机的MyApp，同时虚拟IP漂移至slave，保持对外提供服务的IP和端口不变 F5据说也能满足上面的需求，但F5的通常用法都是双机双活，单活的话还没研究过服务器资源 10.7
eclipse编辑器中文乱码问题解决 0624chenhong eclipse乱码
使用Eclipse编辑文件经常出现中文乱码或者文件中有中文不能保存的问题，Eclipse提供了灵活的设置文件编码格式的选项，我们可以通过设置编码格式解决乱码问题。在Eclipse可以从几个层面设置编码格式：Workspace、Project、Content Type、File 本文以Eclipse 3.3（英文）为例加以说明： 1. 设置Workspace的编码格式： Windows-&g
基础篇--resources资源不懂事的小屁孩 android
最近一直在做java开发，偶尔敲点android代码，突然发现有些基础给忘记了，今天用半天时间温顾一下resources的资源。 String.xml 字符串资源涉及国际化问题 http://www.2cto.com/kf/201302/190394.html string-array
接上篇补上window平台自动上传证书文件的批处理问卷酷的飞上天空 window
@echo off : host=服务器证书域名或ip，需要和部署时服务器的域名或ip一致 ou=公司名称, o=公司名称 set host=localhost set ou=localhost set o=localhost set password=123456 set validity=3650 set salias=s
企业物联网大潮涌动：如何做好准备？蓝儿唯美企业
物联网的可能性也许是无限的。要找出架构师可以做好准备的领域然后利用日益连接的世界。尽管物联网（IoT）还很新，企业架构师现在也应该为一个连接更加紧密的未来做好计划，而不是跟上闸门被打开后的集成挑战。“问题不在于物联网正在进入哪些领域，而是哪些地方物联网没有在企业推进，” Gartner研究总监Mike Walker说。 Gartner预测到2020年物联网设备安装量将达260亿，这些设备在全
spring学习——数据库（mybatis持久化框架配置） a-john mybatis
Spring提供了一组数据访问框架，集成了多种数据访问技术。无论是JDBC，iBATIS(mybatis)还是Hibernate，Spring都能够帮助消除持久化代码中单调枯燥的数据访问逻辑。可以依赖Spring来处理底层的数据访问。 mybatis是一种Spring持久化框架，要使用mybatis，就要做好相应的配置： 1，配置数据源。有很多数据源可以选择，如：DBCP，JDBC，aliba
Java静态代理、动态代理实例 aijuans Java静态代理
采用Java代理模式，代理类通过调用委托类对象的方法，来提供特定的服务。委托类需要实现一个业务接口，代理类返回委托类的实例接口对象。按照代理类的创建时期，可以分为：静态代理和动态代理。所谓静态代理：　指程序员创建好代理类，编译时直接生成代理类的字节码文件。所谓动态代理：　在程序运行时，通过反射机制动态生成代理类。一、静态代理类实例： 1、Serivce.ja
Struts1与Struts2的12点区别 asia007 Struts1与Struts2
1) 在Action实现类方面的对比：Struts 1要求Action类继承一个抽象基类；Struts 1的一个具体问题是使用抽象类编程而不是接口。Struts 2 Action类可以实现一个Action接口，也可以实现其他接口，使可选和定制的服务成为可能。Struts 2提供一个ActionSupport基类去实现常用的接口。即使Action接口不是必须实现的，只有一个包含execute方法的P
初学者要多看看帮助文档不要用js来写Jquery的代码百合不是茶 jquery js
解析json数据的时候需要将解析的数据写到文本框中, 出现了用js来写Jquery代码的问题; 1, JQuery的赋值有问题代码如下: data.username 表示的是: 网易 $("#use
经理怎么和员工搞好关系和信任 bijian1013 团队项目管理管理
产品经理应该有坚实的专业基础，这里的基础包括产品方向和产品策略的把握，包括设计，也包括对技术的理解和见识，对运营和市场的敏感，以及良好的沟通和协作能力。换言之，既然是产品经理，整个产品的方方面面都应该能摸得出门道。这也不懂那也不懂，如何让人信服？如何让自己懂？就是不断学习，不仅仅从书本中，更从平时和各种角色的沟通
如何为rich:tree不同类型节点设置右键菜单 sunjing contextMenu tree Richfaces
组合使用target和targetSelector就可以啦，如下： <rich:tree id="ruleTree" value="#{treeAction.ruleTree}" var="node" nodeType="#{node.type}" selectionChangeListener=&qu
【Redis二】Redis2.8.17搭建主从复制环境 bit1129 redis
开始使用Redis2.8.17 Redis第一篇在Redis2.4.5上搭建主从复制环境，对它的主从复制的工作机制，真正的惊呆了。不知道Redis2.8.17的主从复制机制是怎样的，Redis到了2.4.5这个版本，主从复制还做成那样，Impossible is nothing! 本篇把主从复制环境再搭一遍看看效果，这次在Unbuntu上用官方支持的版本。 Ubuntu上安装Red
JSONObject转换JSON--将Date转换为指定格式白糖_ JSONObject
项目中，经常会用JSONObject插件将JavaBean或List<JavaBean>转换为JSON格式的字符串，而JavaBean的属性有时候会有java.util.Date这个类型的时间对象，这时JSONObject默认会将Date属性转换成这样的格式： {"nanos":0,"time":-27076233600000,
JavaScript语言精粹读书笔记 braveCS JavaScript
【经典用法】： //①定义新方法 Function .prototype.method=function(name, func){ this.prototype[name]=func; return this; } //②给Object增加一个create方法，这个方法创建一个使用原对
编程之美-找符合条件的整数用字符串来表示大整数避免溢出 bylijinnan 编程之美
import java.util.LinkedList; public class FindInteger { /** * 编程之美找符合条件的整数用字符串来表示大整数避免溢出 * 题目：任意给定一个正整数N，求一个最小的正整数M(M>1)，使得N*M的十进制表示形式里只含有1和0 * * 假设当前正在搜索由0，1组成的K位十进制数
读书笔记 chengxuyuancsdn 读书笔记
1、Struts访问资源 2、把静态参数传递给一个动作 3、<result>type属性 4、s:iterator、s:if c:forEach 5、StringBuilder和StringBuffer 6、spring配置拦截器 1、访问资源 (1)通过ServletActionContext对象和实现ServletContextAware,ServletReque
[通讯与电力]光网城市建设的一些问题 comsci 问题
信号防护的问题,前面已经说过了,这里要说光网交换机与市电保障的关系我们过去用的ADSL线路,因为是电话线,在小区和街道电力中断的情况下,只要在家里用笔记本电脑+蓄电池,连接ADSL,同样可以上网........
oracle 空间RESUMABLE daizj oracle 空间不足 RESUMABLE 错误挂起
空间RESUMABLE操作转 Oracle从9i开始引入这个功能，当出现空间不足等相关的错误时，Oracle可以不是马上返回错误信息，并回滚当前的操作，而是将操作挂起，直到挂起时间超过RESUMABLE TIMEOUT，或者空间不足的错误被解决。这一篇简单介绍空间RESUMABLE的例子。第一次碰到这个特性是在一次安装9i数据库的过程中，在利用D
重构第一次写的线程池 dieslrae 线程池 python
最近没有什么学习欲望,修改之前的线程池的计划一直搁置,这几天比较闲,还是做了一次重构,由之前的2个类拆分为现在的4个类. 1、首先是工作线程类:TaskThread,此类为一个工作线程,用于完成一个工作任务,提供等待(wait),继续(proceed),绑定任务(bindTask)等方法 #!/usr/bin/env python # -*- coding:utf8 -*-
C语言学习六指针 dcj3sjt126com c
初识指针，简单示例程序： /* 指针就是地址，地址就是指针地址就是内存单元的编号指针变量是存放地址的变量指针和指针变量是两个不同的概念但是要注意：通常我们叙述时会把指针变量简称为指针，实际它们含义并不一样 */ # include <stdio.h> int main(void) { int * p; // p是变量的名字， int *
yii2 beforeSave afterSave beforeDelete dcj3sjt126com delete
public function afterSave($insert, $changedAttributes) { parent::afterSave($insert, $changedAttributes); if($insert) { //这里是新增数据 } else { //这里是更新数据 } }
timertask shuizhaosi888 timertask
java.util.Timer timer = new java.util.Timer(true); // true 说明这个timer以daemon方式运行（优先级低， // 程序结束timer也自动结束），注意，javax.swing // 包中也有一个Timer类，如果import中用到swing包， // 要注意名字的冲突。 TimerTask task = new
Spring Security（13）——session管理 234390216 session Spring Security 攻击保护超时
session管理目录 1.1 检测session超时 1.2 concurrency-control 1.3 session 固定攻击保护
公司项目NODEJS实践0.3[ mongo / session ...] 逐行分析JS源代码 mongodb session nodejs
http://www.upopen.cn 一、前言书接上回，我们搭建了WEB服务端路由、模板等功能，完成了register 通过ajax与后端的通信，今天主要完成数据与mongodb的存取，实现注册 / 登录 /
pojo.vo.po.domain区别 LiaoJuncai java VO POJO javabean domain
　　POJO = "Plain Old Java Object"，是MartinFowler等发明的一个术语，用来表示普通的Java对象，不是JavaBean, EntityBean 或者 SessionBean。POJO不但当任何特殊的角色，也不实现任何特殊的Java框架的接口如，EJB， JDBC等等。　　　　即POJO是一个简单的普通的Java对象，它包含业务逻辑
Windows Error Code OhMyCC windows
0 操作成功完成. 1 功能错误. 2 系统找不到指定的文件. 3 系统找不到指定的路径. 4 系统无法打开文件. 5 拒绝访问. 6 句柄无效. 7 存储控制块被损坏. 8 存储空间不足, 无法处理此命令. 9 存储控制块地址无效. 10 环境错误. 11 试图加载格式错误的程序. 12 访问码无效. 13 数据无效. 14 存储器不足, 无法完成此操作. 15 系
在storm集群环境下发布Topology roadrunners 集群 storm topology spout bolt
storm的topology设计和开发就略过了。本章主要来说说如何在storm的集群环境中，通过storm的管理命令来发布和管理集群中的topology。 1、打包打包插件是使用maven提供的maven-shade-plugin，详细见maven-shade-plugin。 <plugin> <groupId>org.apache.maven.
为什么不允许代码里出现“魔数” tomcat_oracle java
　　在一个新项目中，我最先做的事情之一，就是建立使用诸如Checkstyle和Findbugs之类工具的准则。目的是制定一些代码规范，以及避免通过静态代码分析就能够检测到的bug。　　迟早会有人给出案例说这样太离谱了。其中的一个案例是Checkstyle的魔数检查。它会对任何没有定义常量就使用的数字字面量给出警告，除了-1、0、1和2。　　很多开发者在这个检查方面都有问题，这可以从结果
zoj 3511 Cake Robbery(线段树) 阿尔萨斯线段树
题目链接：zoj 3511 Cake Robbery 题目大意：就是有一个N边形的蛋糕，切M刀，从中挑选一块边数最多的，保证没有两条边重叠。解题思路：有多少个顶点即为有多少条边，所以直接按照切刀切掉点的个数排序，然后用线段树维护剩下的还有哪些点。 #include <cstdio> #include <cstring> #include <vector&