今天我将带大家从 MYSQL 的执行顺序（FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER BY → LIMIT）上，一步步通过 Pandas 向大家展示具体的执行过程，并借助 Python 基础编码，详解更细节的过程。

MySQL 分组统计的原理

其实上面给的示例代码等价于：

1
2
3
4
5
6
7
8

SELECT
  deal_date,
  COUNT(IF(area= 'A区', order_id, NULL)) 'A区',
  COUNT(IF(area= 'B区', order_id, NULL)) 'B区',
  COUNT(IF(area= 'C区', order_id, NULL)) 'C区'
FROM
  order_info
GROUP BY deal_date;

对于 mysql 标准的执行顺序是：

FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER BY → LIMIT

上面这个 sql 只涉及到 FROM → GROUP BY → SELECT ，可以调整一下 sql 的阅读顺序：

1
2
3
4
5
6
7

FROM order_info
GROUP BY deal_date
SELECT
  deal_date,
  COUNT(IF(area= 'A区', order_id, NULL)) 'A区',
  COUNT(IF(area= 'B区', order_id, NULL)) 'B区',
  COUNT(IF(area= 'C区', order_id, NULL)) 'C区';

1. FROM

首先FROM order_info表示读取 order_info 表的数据

1. GROUP BY

GROUP BY deal_date表示按照 deal_date 分组

1. SELECT

对每个分组选取指定的字段，并根据聚合函数对每个分组结果进行集合

Pandas 分组统计的过程

From

FROM order_info本质就是读取数据：

1
2
3
4

import pandas as pd

data = pd.read_csv("data.csv", encoding="gb18030")
data

结果：

对于 Mysql 的任何 InnoDB 引擎表来说都存在一个主键索引，在没有指定任何字段作为主键时，InnoDB 表会生成一个 6 字节空间的自增主键 row_id 作为主键。上面的 Pandas 表的 Index(data.index)就相当于 mysql 表的自增主键 row_id。

当然这张 MySQL 表指定 order_id 为主键时：

1

ALTER TABLE order_info ADD PRIMARY KEY (order_id);

就相当于：

1

data.set_index("order_id")

结果：

GROUP BY

GROUP BY deal_date表示按照 deal_date 分组，即：

1
2

df_group = data.groupby("deal_date")
df_group

结果：

1

<pandas.core.groupby.generic.DataFrameGroupBy object at 0x0000000016CE8278>

其实这步的本质是获取每个分组对应的主键 id 列表，可以通过DataFrameGroupBy对象的groups方法查看：

1

df_group.groups

结果：

1

{'2019/1/1': [0, 1, 2], '2019/1/2': [3, 4, 5], '2019/1/3': [6, 7]}

Pandas 返回的是每个分组对应的索引列表，它等价于 MySQL 的主键 id 列表。

SELECT

我们拿到每个分组对应的索引列表后，就可以拿到每个分组对应的全部数据：

1
2
3

for deal_date, ids in df_group.groups.items():
    print(deal_date)
    display(data.loc[ids])

结果：

当然，由于 Pandas 本身有现成的 API，我们实际并不会这样遍历每个分区，而是：

1
2
3

for deal_date, split in df_group:
    print(deal_date)
    display(split)

这段 Pandas 遍历每个分区的本质就是上面的代码，返回结果也与上面完全相同。

对于 MySQL 的 select 这步：

1
2
3
4
5

SELECT
  deal_date,
  COUNT(IF(AREA= 'A区', 1, NULL)) 'A区',
  COUNT(IF(AREA= 'B区', 1, NULL)) 'B区',
  COUNT(IF(AREA= 'C区', 1, NULL)) 'C区'

由于前面分组的存在，count()聚合函数将作用于每一个分组，用 Pandas 表达就是：

1
2
3
4
5
6
7
8

for deal_date, split in df_group:
    split.loc[split.area == 'A区', 'A区'] = split.order_id
    split.loc[split.area == 'B区', 'B区'] = split.order_id
    split.loc[split.area == 'C区', 'C区'] = split.order_id
    split = split.set_index('deal_date')
    split = split[['A区', 'B区', 'C区']]
    display(split)
    display(split.count().to_frame(deal_date).T)

结果：

Return

最后 MySQL 计算完成后，就会合并每个分组的结果集，用 Pandas 表达就是：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

result = []
for deal_date, split in df_group:
    split.loc[split.area == 'A区', 'A区'] = split.order_id
    split.loc[split.area == 'B区', 'B区'] = split.order_id
    split.loc[split.area == 'C区', 'C区'] = split.order_id
    split = split.set_index('deal_date')
    split = split[['A区', 'B区', 'C区']]
    result.append(split.count().to_frame(deal_date).T)
result = pd.concat(result)
result

结果：

Pandas 分组聚合的执行过程

对于上面完整 MySQL 语句，整体执行流程等价于 Pandas 的：

1
2
3
4
5
6
7
8

def group_func(split):
    split.loc[split.area == 'A区', 'A区'] = split.order_id
    split.loc[split.area == 'B区', 'B区'] = split.order_id
    split.loc[split.area == 'C区', 'C区'] = split.order_id
    split = split[['A区', 'B区', 'C区']]
    return split.count()

data.groupby('deal_date', as_index=False).apply(group_func)

Python 演示分组的具体原理

上面的演示中：

1

data.groupby("deal_date").groups

结果：

1

{'2019/1/1': [0, 1, 2], '2019/1/2': [3, 4, 5], '2019/1/3': [6, 7]}

可以看到 Pandas 和 MySQL 分组这步其实都是计算出了每个分组对应的主键 id（索引 id）。但它们具体又是怎么实现的呢？

这时候，我用纯 python 来给大家演示一下。

不管是 MySQL 还是 Pandas，都带有主键索引，只不过 Pandas 的索引不会因为重复而报错，而 MySQL 的索引是肯定唯一的，会覆盖前面索引相同的数据。

虽然 MySQL 将带有索引的数据存储到了磁盘上面，但为了方便，我只在内存上演示索引构建的过程。另外 MySQL 主键索引的数据结构一般是 B+树，这里我用 hash 表（字典）来简单演示。

首先，读取数据并构建索引：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

import csv

data = {}
columns = None
with open("data.csv", encoding="gb18030") as f:
    f_csv = csv.reader(f)
    columns = next(f_csv)
    columns = dict(zip(columns, range(len(columns))))
    for i, row in enumerate(f_csv):
        data[i] = row
print(columns)
display(data)

结果：

1
2
3
4
5
6
7
8
9

{'order_id': 0, 'price': 1, 'deal_date': 2, 'area': 3}
{0: ['S001', '10', '2019/1/1', 'A区'],
 1: ['S002', '20', '2019/1/1', 'B区'],
 2: ['S003', '30', '2019/1/1', 'C区'],
 3: ['S004', '40', '2019/1/2', 'A区'],
 4: ['S005', '10', '2019/1/2', 'B区'],
 5: ['S006', '20', '2019/1/2', 'C区'],
 6: ['S007', '30', '2019/1/3', 'A区'],
 7: ['S008', '40', '2019/1/3', 'C区']}

这样我们就读取数据并构建了主键索引，以及表的列名元信息。

下面我们开始实现分组：

1
2
3
4
5
6
7
8

# 获取分组数据所在的列
group_num = columns['deal_date']
id_groups = {}
for index, row in data.items():
    group_key = row[group_num]
    ids = id_groups.setdefault(group_key, [])
    ids.append(index)
id_groups

结果：

1

{'2019/1/1': [0, 1, 2], '2019/1/2': [3, 4, 5], '2019/1/3': [6, 7]}

最后完成聚合计算：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

result = {}
for deal_date, ids in id_groups.items():
    areas = result.setdefault(deal_date, [0, 0, 0])
    for index in ids:
        area = data[index][columns['area']]
        if area == 'A区':
            areas[0] += 1
        elif area == 'B区':
            areas[1] += 1
        elif area == 'C区':
            areas[2] += 1
result

结果：

1

{'2019/1/1': [1, 1, 1], '2019/1/2': [1, 1, 1], '2019/1/3': [1, 0, 1]}

借助 Pandas 展示一下最终结果：

1

pd.DataFrame.from_dict(result, 'index', columns=["A区", "B区", "C区"])

Key 1. SQL 和 NoSQL

SQL

SQL 是一种 结构性查询语言，用于在关系数据库管理系统（RDBMS）中检索和管理数据。

关系型数据库侧重于以二维表格的形式组织数据。 在实际的关系数据库中的关系也称表，一个关系数据库就是由若干个表组成，每个关系表是一个如下形式的二维数组：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

常见的以 SQL 作为标准数据库语言的关系型数据库有：MySQL、PostgreSQL、DB2、SQL Server 等。有关 SQL 语句的教程网上有很多，有兴趣的可以看看 SQL 教程，比较全面。

Nosql

Nosql (Not Only SQL) 指一系列旨在实现数据库模型的方法和项目，与传统的通过 SQL 访问数据的关系型数据库有很大的不同。 使用 NoSQL 的情况下，现实中实体之间的复杂关系可以通过使用不同的数据结构来存储，如：哈希表、数组、树等。

这两天主要学习了 MongoDB 和 Redis 的基本语法及其 Python 实现，有关语法可以参考 MongoDB 教程 和 Redis 教程。

总结 - 中文教程

• SQL
• MongoDB
• Redis

Key 2. Python 操作数据库

使用 Python 操作数据库主要有两种方式，以 MySQL 为例：

1. 使用原生模块：pymysql
2. ORM 框架：SQLAchemy

SQLAlchemy 是 python 编程语言下的一款 ORM 框架，面向对象编程把所有实体看成对象（object），关系型数据库则是采用实体之间的关系（relation）连接数据。很早就有人提出，关系也可以用对象表达，这样的话，就能使用面向对象编程，来操作关系型数据库。

简单说，ORM 就是通过实例对象的语法，完成关系型数据库的操作的技术，是"对象-关系映射"（Object/Relational Mapping） 的缩写，ORM 把数据库映射成对象：

• 数据库的表（table） –> 类（class）
• 记录（record，行数据）–> 对象（object）
• 字段（field）–> 对象的属性（attribute）

1

函数名() OVER() AS xx

• 窗口函数就是将表以窗口为单位进行分割，并在其中进行分组排序的函数。

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

  1 2 3 4 5 6 7 8

  mysql> SELECT -> RANK() OVER w AS rk, -> PERCENT_RANK() OVER w AS prk, -> stu_id, lesson_id, score -> FROM t_score -> WHERE stu_id < 3 -> WINDOW w AS (PARTITION BY stu_id ORDER BY score) -> ;

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

  • partition by 子句：窗口按照哪些字段进行分组，窗口函数在不同的分组上分别执行

  • order by 子句：按照哪些字段进行排序，窗口函数将按照排序后的记录顺序进行编号

  • frame 子句：frame 是当前分区的一个子集，子句用来定义子集的规则，通常用来作为滑动窗口使用，这样的统计方法称为移动平均

    1 2 3 4 5 6 7 8 9

    --指定“最靠近的3行”作为汇总对象 --使用 ROWS（行）和 PRECEDING(之前)两个关键字，将框架指定为“截止到之前~行” SELECT product_id, product_name, sale_price, AVG(sale_price) OVER (ORDER BY product_id ROWS 2 PRECEDING) AS moving_avg FROM Product;

    使用关键字 FOLLOWING(之后)替换 PRECEDING，就可以指定“截止到之后~行”作为框架。如果希望将当前记录的前后行作为汇总对象，可以同时使用 PRECEDING(之前)和 FOLLOWING（之后）关键字来实现。

    1 2 3 4 5 6 7 8 9

    --将当前记录的前后行作为汇总对象 --当前记录的前后行的具体含义就是：之前1行的记录 + 自身（当前记录）+ 之后1行的记录 SELECT product_id, product_name, sale_price, AVG(sale_price) OVER (ORDER BY product_id ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING) AS moving_avg FROM Product;

窗口函数的执行顺序

原理：窗口函数的执行顺序（逻辑上的）是在 FROM, JOIN, WHERE, GROUP BY, HAVING 之后，在 ORDER BY, LIMIT, SELECT DISTINCT 之前。它执行时 GROUP BY 的聚合过程已经完成了，所以不会再产生数据聚合。

注：窗口函数是在 where 之后执行的，所以如果 where 子句需要用窗口函数作为条件，需要多一层查询，在子查询外面进行

1
2
3
4
5
6
7
8

select user_id, avg(diff)
from
(
	select user_id, lead(log_time) over(partition user_id order by log_time) - log_time as diff
	from user_log
) t
where datediff(now(), t.log_time) <= 30
group by user_id

窗口函数和普通聚合函数的区别

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

2. 所有的聚合函数都能用作窗口函数，起到类似累加/累乘的效果

   1 2 3 4 5 6 7 8 9

   --将SUM函数作为窗口函数使用 --使用聚合函数作为窗口函数时，需要在其括号内指定相应的列 SELECT product_id, product_name, sale_price, SUM(sale_price) OVER (ORDER BY product_id) AS current_sum FROM Product;

3. 目前为止我们学过的函数大多数都没有使用位置的限制，最多也就是在 WHERE 子句不能使用聚合函数。但是，使用窗口函数的位置却有很大的限制，确切的说，窗口函数只能在 SELECT 子句中使用。

常用窗口函数

序号函数

row_number(), rank(), dense_rank()

应用场景：【排名问题】 - 如，各科的第一名分别是谁？

• ROW_NUMBER()：顺序排序——1、2、3

• RANK()：并列排序，跳过重复序号——1、1、3

• DENSE_RANK()：并列排序，不跳过重复序号——1、1、2

分布函数

percent_rank(), cume_dist()

应用场景：【比例问题】 - 如，小于等于当前成绩的比例？

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

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

  --给窗口指定别名：WINDOW w AS (PARTITION BY stu_id ORDER BY score) --此例中 rows = 7 mysql> SELECT -> RANK() OVER w AS rk, -> PERCENT_RANK() OVER w AS prk, -> stu_id, lesson_id, score -> FROM t_score -> WHERE stu_id < 3 -> 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 | | 1 | 0 | 2 | L006 | 82 | | 2 | 1 | 2 | L007 | 99 | +----+------+--------+-----------+-------+

• cume_dist()：分组内小于、等于当前 rank 值的行数 / 分组内总行数 eg:查询小于等于当前成绩（score）的比例

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

  --cd1：没有分区，则所有数据均为一组，总行数为 8 --cd2：按照 lesson_id 分成了两组，行数各为 4 mysql> 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 | +--------+-----------+-------+-------+------+

前后函数

lag(expr, n), lead(expr, n)

作用：返回位于当前行的前 n 行（LAG(expr,n)）或后 n 行（LEAD(expr,n)）的 expr 的值

应用场景：查询前 1 名同学的成绩和当前同学成绩的差值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

mysql> 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 |
+--------+-----------+-------+-----------+------+

头尾函数

FIRST_VALUE(expr), LAST_VALUE(expr)

作用：返回第一个（FIRST_VALUE(expr)）或最后一个（LAST_VALUE(expr)）expr 的值

应用场景：截止到当前成绩，按照日期排序查询第 1 个和最后 1 个同学的分数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

mysql> 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 |         99 |
|      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 |
+--------+-----------+-------+-------------+-------------+------------+

NULL 函数

ISNULL()、NVL()、IFNULL() 和 COALESCE() 函数

日期函数

MySQL 使用下列数据类型在数据库中存储日期或日期/时间值：

• DATE - 格式：YYYY-MM-DD
• DATETIME - 格式：YYYY-MM-DD HH:MM:SS
• TIMESTAMP - 格式：YYYY-MM-DD HH:MM:SS
• YEAR - 格式：YYYY 或 YY

Aggregate 函数

SQL Aggregate 函数计算从列中取得的值，返回一个单一的值。

Scalar 函数

SQL Scalar 函数基于输入值，返回一个单一的值。

有关上述函数的具体使用，可以参考：https://www.runoob.com/sql/sql-function.html

• DQL - Data Query Language：数据查询语言，用来查询记录（数据）。select
• DDL - Data Definition Language：数据定义语言，用来定义数据库对象；create/drop/alter
• DML - Data Manipulation Language：数据操作语言，用来定义数据库记录；Insert/delete/update
• DCL - Data Control Language：数据控制语言，用来定义访问权限和安全级别；

DQL：数据查询语言

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

SELECT [DISTINCT]
	<select_list> /*要查询的列名称*/
FROM
	<left_table> <join_type>
	JOIN <right_table> ON <join_condition>/*要查询的表名称*/
WHERE
	<where_condition> /*行条件*/
GROUP BY
	<group_by_list> /*对结果分组*/
HAVING
	<having_condition> /*分组后的行条件*/
ORDER BY
	<sorting_columns> [ASC|DESC] /*对结果排序*/
LIMIT
	<offset_start, row_length> /*结果限定*/

MySQL - 执行顺序

随着 Mysql 版本的更新换代，其优化器也在不断的升级，优化器会分析不同执行顺序产生的性能消耗不同而动态调整 执行顺序。下面是经常出现的查询顺序：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

FROM <left_table>
ON <join_condition>
<join_type> JOIN <right_table>
WHERE <where_condition>
GROUP BY <group_by_list>
HAVING <having_condition>
SELECT
[DISTINCT] <select_list>
ORDER BY <sorting_columns> [ASC|DESC]
LIMIT <offset_start, row_length>

Condition - 行筛选条件

IN - 多值匹配

1
2
3

SELECT column_name(s)
FROM table_name
WHERE column_name IN (value1,value2,...);

LIKE - 字符匹配

1
2
3

SELECT column_name(s)
FROM table_name
WHERE column_name LIKE pattern;

BETWEEN - 范围匹配

1
2
3

SELECT column_name(s)
FROM table_name
WHERE column_name BETWEEN value1 AND value2;

• AND & OR 运算符

如果第一个条件和第二个条件都成立，则 AND 运算符显示一条记录。

如果第一个条件和第二个条件中只要有一个成立，则 OR 运算符显示一条记录。

HAVING - 分组筛选

在 SQL 中增加 HAVING 子句原因是，WHERE 关键字无法与聚合函数 GROUP BY 一起使用。HAVING 子句可以让我们筛选分组后的各组数据。

1
2
3
4
5

SELECT column_name, aggregate_function(column_name)
FROM table_name
WHERE column_name operator value
GROUP BY column_name
HAVING aggregate_function(column_name) operator value;

TOP/LIMIT/ROWNUM - 结果限定

• SQL Server / MS Access 语法

1
2

SELECT TOP number|percent column_name(s)
FROM table_name;

• Oracle 语法

1
2
3

SELECT column_name(s)
FROM table_name
WHERE ROWNUM <= number;

• MySQL 语法

1
2
3

SELECT column_name(s)
FROM table_name
LIMIT number;

附注：OFFSET

为了与 PostgreSQL 兼容，MySQL 也支持句法： LIMIT # OFFSET #

1. selete * from testtable limit 2,1;

2. selete * from testtable limit 2 offset 1;

注意：

1. 数据库数据计算是从 0 开始的

2. offset X 是跳过 X 个数据，limit Y 是选取 Y 个数据

3. limit X, Y 中 X 表示跳过 X 个数据，读取 Y 个数据

AS - 别名

• 列的 SQL 别名语法

1
2

SELECT column_name AS alias_name
FROM table_name;

• 表的 SQL 别名语法

1
2

SELECT column_name(s)
FROM table_name AS alias_name;

在下面的情况下，使用别名很有用：

1. 在查询中涉及超过一个表

2. 在查询中使用了函数

3. 列名称很长或者可读性差

4. 需要把两个列或者多个列结合在一起

JOIN - 多表连接

SQL JOIN 语法：

1. INNER JOIN：如果表中有至少一个匹配，则返回行

2. LEFT JOIN：即使右表中没有匹配，也从左表返回所有的行

3. RIGHT JOIN：即使左表中没有匹配，也从右表返回所有的行

4. FULL JOIN：只要其中一个表中存在匹配，则返回行

AUTO INCREMENT - 自增序列

在每次插入新记录时，自动地创建主键字段的值。

下面的 SQL 语句把 “Persons” 表中的 “ID” 列定义为 auto-increment 主键字段：

1
2
3
4
5
6
7
8
9

CREATE TABLE Persons
(
ID int NOT NULL AUTO_INCREMENT,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255),
PRIMARY KEY (ID)
)

MySQL 使用 AUTO_INCREMENT 关键字来执行 auto-increment 任务。

默认地，AUTO_INCREMENT 的开始值是 1，每条新记录递增 1。

要让 AUTO_INCREMENT 序列以其他的值起始，请使用下面的 SQL 语法：

1

ALTER TABLE Persons AUTO_INCREMENT=100

要在 “Persons” 表中插入新记录，我们不必为 “ID” 列规定值（会自动添加一个唯一的值）：

1
2

INSERT INTO Persons (FirstName,LastName)
VALUES ('Lars','Monsen')

DML：数据操作语言

INSERT INTO - 插入纪录

有两种编写形式，第一种形式无需指定要插入数据的列名，只需提供被插入的值即可：

1
2

INSERT INTO table_name
VALUES (value1,value2,value3,...);

第二种形式需要指定列名及被插入的值：

1
2

INSERT INTO table_name (column1,column2,column3,...)
VALUES (value1,value2,value3,...);

• insert into select 和 select into from 的区别

1
2
3
4
5

--插入一行,要求表scorebak 必须存在
insert into scorebak select * from socre where neza='neza'

--也是插入一行,要求表scorebak 不存在
select *  into scorebak from score  where neza='neza'

UPDATE - 更新记录

1
2
3

UPDATE table_name
SET column1=value1,column2=value2,...
WHERE some_column=some_value;

请注意 SQL UPDATE 语句中的 WHERE 子句！

WHERE 子句规定哪条记录或者哪些记录需要更新。如果您省略了 WHERE 子句，所有的记录都将被更新！

DELETE - 删除记录

1
2

DELETE FROM table_name
WHERE some_column=some_value;

请注意 SQL DELETE 语句中的 WHERE 子句！

WHERE 子句规定哪条记录或者哪些记录需要删除。

如果您省略了 WHERE 子句，所有的记录都将被删除！当然，这意味着表结构、属性、索引将保持不变。

DDL：数据定义语言

CREATE DATABASE - 创建数据库

1

CREATE DATABASE dbname;

CREATE TABLE - 创建数据表

1
2
3
4
5
6
7

CREATE TABLE table_name
(
column_name1 data_type(size),
column_name2 data_type(size),
column_name3 data_type(size),
....
);

• column_name 参数规定表中列的名称。
• data_type 参数规定列的数据类型（例如 varchar、integer、decimal、date 等等）。
• size 参数规定表中列的最大长度。

**提示：**如需了解 MySQL 和 SQL Server 中的数据类型，可以访问：数据类型参考手册

Constraints - 约束规则

• SQL CREATE TABLE + CONSTRAINT 语法

1
2
3
4
5
6
7

CREATE TABLE table_name
(
column_name1 data_type(size) constraint_name,
column_name2 data_type(size) constraint_name,
column_name3 data_type(size) constraint_name,
....
);

在 SQL 中，我们有如下约束：

• NOT NULL - 指示某列不能存储 NULL 值

  1 2 3 4 5 6 7 8 9 10 11 12 13 14

  CREATE TABLE Persons ( ID int NOT NULL, LastName varchar(255) NOT NULL, FirstName varchar(255) NOT NULL, Age int ); -- 添加 NOT NULL 约束 ALTER TABLE Persons MODIFY Age int NOT NULL; -- 删除 NOT NULL 约束 ALTER TABLE Persons MODIFY Age int NULL;

• UNIQUE - 保证某列的每行必须有唯一的值

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56

  -- CREATE TABLE 时的 SQL UNIQUE 约束 -- MySQL： CREATE TABLE Persons ( P_Id int NOT NULL, LastName varchar(255) NOT NULL, FirstName varchar(255), Address varchar(255), City varchar(255), UNIQUE (P_Id) ) -- SQL Server / Oracle / MS Access： CREATE TABLE Persons ( P_Id int NOT NULL UNIQUE, LastName varchar(255) NOT NULL, FirstName varchar(255), Address varchar(255), City varchar(255) ) -- 多个列的 UNIQUE 约束 CREATE TABLE Persons ( P_Id int NOT NULL, LastName varchar(255) NOT NULL, FirstName varchar(255), Address varchar(255), City varchar(255), CONSTRAINT uc_PersonID UNIQUE (P_Id,LastName) ) -- uc_PersonID 是一个约束名！上面建的是唯一约束，为了方便区别约束名一般起得有规律点。 -- 比如 UC（就是 UNIQUE CONSTRAINT 的缩写意思是唯一约束） -- uc_PersonID 就是对表中的PersonID 建唯一约束，强制约束 Id_P 和 LastName 唯一。 -- ALTER TABLE 时的 SQL UNIQUE 约束 -- MySQL / SQL Server / Oracle / MS Access： ALTER TABLE Persons ADD UNIQUE (P_Id) -- 多个列的 UNIQUE 约束 ALTER TABLE Persons ADD CONSTRAINT uc_PersonID UNIQUE (P_Id,LastName) -- 撤销 UNIQUE 约束 -- MySQL： ALTER TABLE Persons DROP INDEX uc_PersonID -- SQL Server / Oracle / MS Access： ALTER TABLE Persons DROP CONSTRAINT uc_PersonID

• PRIMARY KEY - NOT NULL 和 UNIQUE 的结合

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

  -- CREATE TABLE 时的 SQL PRIMARY KEY 约束 -- MySQL： CREATE TABLE Persons ( P_Id int NOT NULL, LastName varchar(255) NOT NULL, FirstName varchar(255), Address varchar(255), City varchar(255), PRIMARY KEY (P_Id) ) -- SQL Server / Oracle / MS Access： CREATE TABLE Persons ( P_Id int NOT NULL PRIMARY KEY, LastName varchar(255) NOT NULL, FirstName varchar(255), Address varchar(255), City varchar(255) ) -- 定义多个列的 PRIMARY KEY 约束： -- 注释：在下面的实例中，只有一个主键 PRIMARY KEY（pk_PersonID）。 -- 然而，pk_PersonID 的值是由两个列（P_Id 和 LastName）组成的。 CREATE TABLE Persons ( P_Id int NOT NULL, LastName varchar(255) NOT NULL, FirstName varchar(255), Address varchar(255), City varchar(255), CONSTRAINT pk_PersonID PRIMARY KEY (P_Id,LastName) ) -- ALTER TABLE 时的 SQL PRIMARY KEY 约束 -- 注释：如果您使用 ALTER TABLE 语句添加主键，必须把主键列声明为不包含 NULL 值（在表首次创建时）。 -- MySQL / SQL Server / Oracle / MS Access： ALTER TABLE Persons ADD PRIMARY KEY (P_Id) -- 定义多个列的 PRIMARY KEY 约束： ALTER TABLE Persons ADD CONSTRAINT pk_PersonID PRIMARY KEY (P_Id,LastName) -- 撤销 PRIMARY KEY 约束 -- MySQL： ALTER TABLE Persons DROP PRIMARY KEY -- SQL Server / Oracle / MS Access： ALTER TABLE Persons DROP CONSTRAINT pk_PersonID

• FOREIGN KEY - 保证一个表中的数据匹配另一个表中的值的参照完整性

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52

  -- CREATE TABLE 时的 SQL PRIMARY KEY 约束 -- MySQL： CREATE TABLE Orders ( O_Id int NOT NULL, OrderNo int NOT NULL, P_Id int, PRIMARY KEY (O_Id), FOREIGN KEY (P_Id) REFERENCES Persons(P_Id) ) -- SQL Server / Oracle / MS Access： CREATE TABLE Orders ( O_Id int NOT NULL PRIMARY KEY, OrderNo int NOT NULL, P_Id int FOREIGN KEY REFERENCES Persons(P_Id) ) -- 定义多个列的 PRIMARY KEY 约束： CREATE TABLE Orders ( O_Id int NOT NULL, OrderNo int NOT NULL, P_Id int, PRIMARY KEY (O_Id), CONSTRAINT fk_PerOrders FOREIGN KEY (P_Id) REFERENCES Persons(P_Id) ) -- ALTER TABLE 时的 SQL PRIMARY KEY 约束 -- MySQL / SQL Server / Oracle / MS Access： ALTER TABLE Orders ADD FOREIGN KEY (P_Id) REFERENCES Persons(P_Id) -- 定义多个列的 PRIMARY KEY 约束： ALTER TABLE Orders ADD CONSTRAINT fk_PerOrders FOREIGN KEY (P_Id) REFERENCES Persons(P_Id) -- 撤销 PRIMARY KEY 约束 -- MySQL： ALTER TABLE Orders DROP FOREIGN KEY fk_PerOrders -- SQL Server / Oracle / MS Access： ALTER TABLE Orders DROP CONSTRAINT fk_PerOrders

• CHECK - 保证列中的值符合指定的条件

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52

  -- CREATE TABLE 时的 SQL PRIMARY KEY 约束 -- MySQL： CREATE TABLE Persons ( P_Id int NOT NULL, LastName varchar(255) NOT NULL, FirstName varchar(255), Address varchar(255), City varchar(255), CHECK (P_Id>0) ) -- SQL Server / Oracle / MS Access： CREATE TABLE Persons ( P_Id int NOT NULL CHECK (P_Id>0), LastName varchar(255) NOT NULL, FirstName varchar(255), Address varchar(255), City varchar(255) ) -- 定义多个列的 PRIMARY KEY 约束： CREATE TABLE Persons ( P_Id int NOT NULL, LastName varchar(255) NOT NULL, FirstName varchar(255), Address varchar(255), City varchar(255), CONSTRAINT chk_Person CHECK (P_Id>0 AND City='Sandnes') ) -- ALTER TABLE 时的 SQL PRIMARY KEY 约束 -- MySQL / SQL Server / Oracle / MS Access： ALTER TABLE Persons ADD CHECK (P_Id>0) -- 定义多个列的 PRIMARY KEY 约束： ALTER TABLE Persons ADD CONSTRAINT chk_Person CHECK (P_Id>0 AND City='Sandnes') -- 撤销 PRIMARY KEY 约束 -- MySQL： ALTER TABLE Persons DROP CHECK chk_Person -- SQL Server / Oracle / MS Access： ALTER TABLE Persons DROP CONSTRAINT chk_Person

• DEFAULT - 规定没有给列赋值时的默认值

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

  -- CREATE TABLE 时的 SQL PRIMARY KEY 约束 -- My SQL / SQL Server / Oracle / MS Access： CREATE TABLE Persons ( P_Id int NOT NULL, LastName varchar(255) NOT NULL, FirstName varchar(255), Address varchar(255), City varchar(255) DEFAULT 'Sandnes' ) -- ALTER TABLE 时的 SQL PRIMARY KEY 约束 -- MySQL： ALTER TABLE Persons ALTER City SET DEFAULT 'SANDNES' -- SQL Server / MS Access： ALTER TABLE Persons ADD CONSTRAINT ab_c DEFAULT 'SANDNES' for City -- Oracle： ALTER TABLE Persons MODIFY City DEFAULT 'SANDNES' -- 撤销 PRIMARY KEY 约束 -- MySQL： ALTER TABLE Persons ALTER City DROP DEFAULT -- SQL Server / Oracle / MS Access： ALTER TABLE Persons ALTER COLUMN City DROP DEFAULT

CREATE INDEX - 创建索引

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

-- 在表上创建一个简单的索引，允许使用重复的值：
CREATE INDEX index_name
ON table_name (column_name)

-- 在表上创建一个唯一的索引，不允许使用重复的值：
CREATE UNIQUE INDEX index_name
ON table_name (column_name)

-- 多列索引，可以在括号中列出这些列的名称，用逗号隔开：
CREATE INDEX PIndex
ON Persons (LastName, FirstName)

ALTER TABLE - 修改表

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

-- 如需在表中添加列，请使用下面的语法:
ALTER TABLE table_name
ADD column_name datatype

-- 如需删除表中的列，请使用下面的语法
-- （请注意，某些数据库系统不允许这种在数据库表中删除列的方式）：
ALTER TABLE table_name
DROP COLUMN column_name

-- 要改变表中列的数据类型，请使用下面的语法：
-- SQL Server / MS Access：
ALTER TABLE table_name
ALTER COLUMN column_name datatype
-- My SQL / Oracle：
ALTER TABLE table_name
MODIFY COLUMN column_name datatype
-- Oracle 10G 之后版本:
ALTER TABLE table_name
MODIFY column_name datatype;

DROP - 删除

DROP INDEX - 撤销索引

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

-- 用于 MS Access 的 DROP INDEX 语法：
DROP INDEX index_name ON table_name

-- 用于 MS SQL Server 的 DROP INDEX 语法：
DROP INDEX table_name.index_name

-- 用于 DB2/Oracle 的 DROP INDEX 语法：
DROP INDEX index_name

-- 用于 MySQL 的 DROP INDEX 语法：
ALTER TABLE table_name DROP INDEX index_name

DROP TABLE - 撤销表

1

DROP TABLE table_name

DROP DATABASE - 撤销数据库

1

DROP DATABASE database_name

涉及资源列表：
《SQL必知必会》（豆瓣）
PDF 资源（GitHub）

数据查询语句

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

SELECT [DISTINCT/ALL]
  <select_list>
FROM
  <left_table> <join_type> JOIN <right_table>
  ON <join_condition>
WHERE
  <where_condition>
GROUP BY
  <group_by_list>
HAVING
  <having_condition>
ORDER BY
  <sorting_columns> [ASC|DESC]
LIMIT
  <offset_start, row_length>

易错点

• 多条 SQL 语句必须以分号（;）作分隔
• 注释语法 – 和 /**/，#大多数不行
• 检索数据（SELECT、LIMIT、ORDER BY）
  • DISTINCT 作用于所有的列，而不仅仅是跟在其后的那一列
  • 与 DISTINCT 不同，DESC 关键字只应用到直接位于其前面的列名
• 过滤数据（WHERE）
  • 由于 AND 操作符比 OR 操作符优先级高，需要使用圆括号对操作符进行明确分组
  • IN 操作符最大的优点在于可以包含其他 SELECT 语句
  • 通配符搜索只能用于文本字段（字符串），非文本数据类型字段不能使用通配符搜索
  • 通配符 % 代表匹配任意字符，甚至可以匹配 0 个字符，但不可匹配 null
• 计算字段
  • CONUT() 函数中如果指定列名，则会忽略指定列的值为空 NULL 的行；如果用 * 则不忽略
  • 对于文本数据，MIN() 返回排序后最前面的行， MAX() 返回排序后最后面的行
• 汇总数据
  • 5个聚集函数（AVG、COUNT、MIN、MAX、SUM）都可用于指定 DISTINCT 参数的列，但唯独 COUNT(*) 不可以
• 分组数据（GROUP BY、HAVING）
  • 分组统计：GROUP BY 分组后进行聚集函数运算；分组排序：利用窗口函数及 OVER 子句
  • 除聚集计算语句外，SELECT 语句中的每一列都必须在 GROUP BY 子句中给出
  • Having 支持所有 Where 操作符，区别在于 having 用于过滤分组，而 where 用于过滤行
• 子查询
  • 两种使用方法
    • WHERE 子句的 IN 操作符中
    • 用来填充计算字段
  • 作为子查询的 SELECT 语句只能查询单个列
• 联结表：自联结的实现需要用到表别名
• 组合查询（UNION）
  • UNION 中的每个查询必须包括相同的列、表达式或聚集函数，但各个列不需要以相同的次序列出
  • UNION 默认会从查询结果中自动去掉重复的行，如果想返回全部的行，可以使用 UNION ALL
  • 在用 UNION 组合查询时，只能使用一条 ORDER BY 子句，它只能位于最后一条 SELECT 语句之后
  • UNION 在需要组合多个表的数据时也很有用，当列名写法不一致时可以借助别名来实现组合查询，检索到一个结果集

背诵点

• 不同平台差异点：
  • 限制结果语句 - 不同平台实现起来并不一样——TOP、FETCH、ROWNUM、LIMIT
  • 通配符 #（%/*、_/？、[]、^/!）
  • 拼接字段（+/||）
  • 函数
• WHERE 子句的条件操作符（=、<>/!=、>、<、>=/!<、<=/!>、between、is null）、AND/OR/IN/NOT/LIKE 操作符
• 函数（文本、数值、时间、系统、聚集、窗口）

数据操作语言

数据定义语言