今天我将带大家从 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 |
+--------+-----------+-------+-------------+-------------+------------+

Shell 编程跟 JavaScript、php 编程一样，只要有一个能编写代码的文本编辑器和一个能解释执行的脚本解释器就可以了。

Linux 的 Shell 种类众多，本教程关注的是 Bash，也就是 Bourne Again Shell，由于易用和免费，Bash 在日常工作中被广泛使用。同时，Bash 也是大多数Linux 系统默认的 Shell。

在一般情况下，人们并不区分 Bourne Shell 和 Bourne Again Shell，所以，像 #!/bin/sh，它同样也可以改为 #!/bin/bash。

#! 是一个约定的标记，它告诉系统这个脚本需要什么解释器来执行，即使用哪一种 Shell。

Shell 脚本（shell script），是一种为 shell 编写的脚本程序。业界所说的 shell 通常都是指 shell 脚本，但读者朋友要知道，shell 和 shell script 是两个不同的概念。由于习惯的原因，简洁起见，本文出现的 “shell编程” 都是指 shell 脚本编程，不是指开发 shell 自身。

1
2

#!/bin/bash
echo "Hello World !"

echo 命令用于向窗口输出文本。

变量与数据

Shell 变量

定义变量

定义变量时，变量名不加美元符号$，且变量名和等号之间不能有空格：

1

your_name="runoob.com"

除了显式地直接赋值，还可以用语句给变量赋值，如：

1
2
3

for file in `ls /etc`
或
for file in $(ls /etc)

以上语句将 /etc 下目录的文件名循环出来。

变量命名

同时，变量名的命名须遵循如下规则：

• 命名只能使用英文字母，数字和下划线，首个字符不能以数字开头
• 中间不能有空格，可以使用下划线（_）
• 不能使用标点符号
• 不能使用 bash 里的关键字（可用 help 命令查看保留关键字）

变量类型

运行shell时，会同时存在三种变量：

• 局部变量

  在脚本或命令中定义，仅在当前 shell 实例中有效，其他 shell 启动的程序不能访问局部变量。

• 环境变量

  所有的程序，包括 shell 启动的程序，都能访问环境变量，有些程序需要环境变量来保证其正常运行。必要的时候 shell 脚本也可以定义环境变量。

• shell 变量

  shell 变量是由 shell 程序设置的特殊变量。shell 变量中有一部分是环境变量，有一部分是局部变量，这些变量保证了 shell 的正常运行。

使用变量

使用一个定义过的变量，只要在变量名前面加美元符号即可，如：

1
2
3

your_name="qinjx"
echo $your_name
echo ${your_name}

变量名外面的花括号是可选的，加不加都行，加花括号是为了帮助解释器识别变量的边界，推荐给所有变量加上花括号，这是个好的编程习惯。

只读变量

使用 readonly 命令可以将变量定义为只读变量，只读变量的值不能被改变。

1
2
3

#!/bin/bash
myUrl="https://www.google.com"
readonly myUrl

删除变量

使用 unset 命令可以删除变量。语法：

1

unset variable_name

变量被删除后不能再次使用，unset 命令不能删除只读变量。

数据类型

注释

以 #开头的行就是注释，会被解释器忽略。多行注释还可以使用以下格式：

1
2
3
4
5

:<<EOF
注释内容...
注释内容...
注释内容...
EOF

EOF 也可以使用其他符号：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

:<<'
注释内容...
注释内容...
注释内容...
'

:<<!
注释内容...
注释内容...
注释内容...
!

字符串

字符串可以用单引号，也可以用双引号，也可以不用引号。

• 单引号

  1	str='this is a string'

  • 单引号里的任何字符都会原样输出，单引号字符串中的变量是无效的；
  • 单引号字串中不能出现单独一个的单引号（对单引号使用转义符后也不行），但可成对出现，作为字符串拼接使用。

• 双引号

  1 2 3

  your_name='runoob' str="Hello, I know you are \"$your_name\"! \n" echo -e $str

  • 双引号里可以有变量；
  • 双引号里可以出现转义字符。

拼接字符串

1
2
3
4
5
6
7
8
9

your_name="runoob"
## 使用双引号拼接
greeting="hello, "$your_name" !"
greeting_1="hello, ${your_name} !"
echo $greeting  $greeting_1
## 使用单引号拼接
greeting_2='hello, '$your_name' !'
greeting_3='hello, ${your_name} !'
echo $greeting_2  $greeting_3

输出结果为：

1
2

hello, runoob ! hello, runoob !
hello, runoob ! hello, ${your_name} !

获取字符串长度

1
2

string="abcd"
echo ${#string} #输出 4

提取子字符串

1
2

string="runoob is a great site"
echo ${string:1:4} ## 输出 unoo

注意：第一个字符的索引值为 0。

查找子字符串

查找字符 i 或 o 的位置(哪个字母先出现就计算哪个)：

1
2

string="runoob is a great site"
echo `expr index "$string" io`  ## 输出 4

注意： 以上脚本中 ` 是反引号，而不是单引号 ’

数组

• bash支持一维数组（不支持多维数组），并且没有限定数组的大小；
• 类似于 C 语言，数组元素的下标由 0 开始编号；
• 获取数组中的元素要利用下标，下标可以是整数或算术表达式，其值应大于或等于 0。

定义数组

在 Shell 中，用括号来表示数组，数组元素用"空格"符号分割开。定义数组的一般形式为：

1

array_name=(value0 value1 value2 value3)

还可以单独定义数组的各个分量：

1
2
3

array_name[0]=value0
array_name[1]=value1
array_name[n]=valuen

可以不使用连续的下标，而且下标的范围没有限制。

读取数组

读取数组元素值的一般格式是：

1

valuen=${array_name[n]}

使用 @ 符号可以获取数组中的所有元素，例如：

1

echo ${array_name[@]}

获取数组的长度

获取数组长度的方法与获取字符串长度的方法相同：

1
2
3
4
5
6

## 取得数组元素的个数
length=${#array_name[@]}
## 或者
length=${#array_name[*]}
## 取得数组单个元素的长度
lengthn=${#array_name[n]}

命令与函数

运算符

基本命令

自定义函数

流程与文件

流程控制

脚本执行

1. 作为可执行程序

   将上面的代码保存为 test.sh，并 cd 到相应目录：

   1 2	chmod +x ./test.sh #使脚本具有执行权限 ./test.sh #执行脚本

   注意，一定要写成 ./test.sh，而不是 test.sh，运行其它二进制的程序也一样，直接写 test.sh，linux 系统会去 PATH 里寻找有没有叫 test.sh 的，而只有 /bin, /sbin, /usr/bin，/usr/sbin 等在 PATH 里，你的当前目录通常不在 PATH 里，所以写成 test.sh 是会找不到命令的，要用 ./test.sh 告诉系统说，就在当前目录找。

2. 作为解释器参数

   这种运行方式是，直接运行解释器，其参数就是 shell 脚本的文件名，如：

   1 2	/bin/sh test.sh /bin/php test.php

   这种方式运行的脚本，不需要在第一行指定解释器信息，写了也没用。

文件包含

和其他语言一样，Shell 也可以包含外部脚本。这样可以很方便的封装一些公用的代码作为一个独立的文件。

Shell 文件包含的语法格式如下：

1
2
3
4
5

. filename   ## 注意点号(.)和文件名中间有一空格

或

source filename

实例

创建两个 shell 脚本文件。

test1.sh 代码如下：

1
2
3
4
5

#!/bin/bash
## author:菜鸟教程
## url:www.runoob.com

url="https://www.runoob.com"

test2.sh 代码如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

#!/bin/bash
## author:菜鸟教程
## url:www.runoob.com

#使用 . 号来引用test1.sh 文件
. ./test1.sh

## 或者使用以下包含文件代码
## source ./test1.sh

echo "菜鸟教程官网地址：$url"

接下来，我们为 test2.sh 添加可执行权限并执行：

1
2
3

$ chmod +x test2.sh
$ ./test2.sh
菜鸟教程官网地址：https://www.runoob.com

**注：**被包含的文件 test1.sh 不需要可执行权限。

输入/输出重定向

基本命令

文件描述符 0 通常是标准输入（STDIN），1 是标准输出（STDOUT），2 是标准错误输出（STDERR）

深入讲解

一般情况下，每个 Unix/Linux 命令运行时都会打开三个文件：

• 标准输入文件(stdin)：stdin的文件描述符为0，Unix程序默认从stdin读取数据；
• 标准输出文件(stdout)：stdout 的文件描述符为1，Unix程序默认向stdout输出数据；
• 标准错误文件(stderr)：stderr的文件描述符为2，Unix程序会向stderr流中写入错误信息。

默认情况下，command > file 将 stdout 重定向到 file，command < file 将stdin 重定向到 file。

如果希望 stderr 重定向到 file，可以这样写：

1

$ command 2 > file

如果希望将 stdout 和 stderr 合并后重定向到 file，可以这样写：

1
2
3

$ command > file 2>&1
## 或者
$ command >> file 2>&1

如果希望对 stdin 和 stdout 都重定向，可以这样写：

1

$ command < file1 >file2

command 命令将 stdin 重定向到 file1，将 stdout 重定向到 file2。

Here Document

Here Document 是 Shell 中的一种特殊的重定向方式，用来将输入重定向到一个交互式 Shell 脚本或程序。

它的基本的形式如下：

1
2
3

command << delimiter
    document
delimiter

它的作用是将两个 delimiter 之间的内容(document) 作为输入传递给 command。

• 结尾的 delimiter 一定要顶格写，前面不能有任何字符，后面也不能有任何字符，包括空格和 tab 缩进。
• 开始的 delimiter 前后的空格会被忽略掉。

例如，在命令行中通过 wc -l 命令计算 Here Document 的行数：

1
2
3
4
5
6

$ wc -l << EOF
    欢迎来到
    菜鸟教程
    www.runoob.com
EOF
3          ## 输出结果为 3 行

/dev/null 文件

如果希望执行某个命令，但又不希望在屏幕上显示输出结果，那么可以将输出重定向到 /dev/null：

1

$ command > /dev/null

/dev/null 是一个特殊的文件，写入到它的内容都会被丢弃；如果尝试从该文件读取内容，那么什么也读不到。但是 /dev/null 文件非常有用，将命令的输出重定向到它，会起到"禁止输出"的效果。

如果希望屏蔽 stdout 和 stderr，可以这样写：

1

$ command > /dev/null 2>&1

参考文献

• Shell 教程|菜鸟教程

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