MySQL

目录

• 1 简单查询
• 2 条件查询
• 3 区间查询
• 4 集合查询
• 5 模糊查询
• 6 排序查询
• 7 聚合函数
• 8 分组查询
• 9 分页查询
• 10 正则表达式
• 11 SQL 语句关键字的执行顺序

1 简单查询

• 准备表和数据

-- 创建表
DROP TABLE IF EXISTS `person`;
CREATE TABLE `person` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(50) NOT NULL,
  `age` tinyint(4) DEFAULT '0',
  `sex` enum('男','女','人妖') NOT NULL DEFAULT '人妖',
  `salary` decimal(10,2) NOT NULL DEFAULT '250.00',
  `hire_date` date NOT NULL,
  `dept_id` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=13 DEFAULT CHARSET=utf8;

-- 创建数据

-- 教学部
INSERT INTO `person` VALUES ('1', 'alex', '28', '人妖', '53000.00', '2010-06-21', '1');
INSERT INTO `person` VALUES ('2', 'wupeiqi', '23', '男', '8000.00', '2011-02-21', '1');
INSERT INTO `person` VALUES ('3', 'egon', '30', '男', '6500.00', '2015-06-21', '1');
INSERT INTO `person` VALUES ('4', 'jingnvshen', '18', '女', '6680.00', '2014-06-21', '1');

-- 销售部
INSERT INTO `person` VALUES ('5', '歪歪', '20', '女', '3000.00', '2015-02-21', '2');
INSERT INTO `person` VALUES ('6', '星星', '20', '女', '2000.00', '2018-01-30', '2');
INSERT INTO `person` VALUES ('7', '格格', '20', '女', '2000.00', '2018-02-27', '2');
INSERT INTO `person` VALUES ('8', '周周', '20', '女', '2000.00', '2015-06-21', '2');

-- 市场部
INSERT INTO `person` VALUES ('9', '月月', '21', '女', '4000.00', '2014-07-21', '3');
INSERT INTO `person` VALUES ('10', '安琪', '22', '女', '4000.00', '2015-07-15', '3');

-- 人事部
INSERT INTO `person` VALUES ('11', '周明月', '17', '女', '5000.00', '2014-06-21', '4');
-- 鼓励部
INSERT INTO `person` VALUES ('12', '苍老师', '33', '女', '1000000.00', '2018-02-21', null);

#查询语法: 
select [distinct]*(所有)|字段名,...字段名 from 表名;
 
#查询所有字段信息
select * from person;
 
#查询指定字段信息
select id,name,age,sex,salary from person;
 
#别名查询，使用的as关键字，as可以省略的
select name,age as'年龄',salary '工资' from person;
 
#直接对列进行运算,查询出所有人工资,并每人增加100块.
select (5/2);
select name, salary+100 from person;
 
#剔除重复查询
select distinct age from person;

2 条件查询

• 条件查询:使用 WHERE 关键字 对简单查询的结果集 进行过滤
  • 1. 比较运算符: > < >= <= = <>(!=)
  • 2. null 关键字: is null , not null
  • 3.逻辑运算符: 与 and 或 or (多个条件时,需要使用逻辑运算符进行连接)

#查询格式:
select [distinct]*(所有)|字段名,...字段名 from 表名 [where 条件过滤]
 
#比较运算符: > < >= <= = <>(!=)    is null 是否为null
select * from person where age = 23;
select * from person where age <> 23;
select * from person where age is null;
select * from person where age is not null;
 
#逻辑运算符: 与 and 或 or
select * from person where age = 23 and salary =29000;
select * from person where age = 23 or salary =29000;

3 区间查询

• 关键字 between 10 and 20 :表示 获得10 到 20 区间的内容

# 使用  between...and  进行区间 查询
select * from person where salary between 4000 and 8000;
ps: between...and 前后包含所指定的值
等价于 select * from person where salary >= 4000 and salary <= 8000;

4 集合查询

• 关键字: in, not null

#使用 in 集合(多个字段)查询
select * from person where age in(23,32,18);
等价于: select * from person where  age =23 or age = 32 or age =18;
 
#使用 in 集合 排除指定值查询
select * from person where age not in(23,32,18);

5 模糊查询

• 关键字 like , not like
  • %: 任意多个字符
  • _ : 只能是单个字符

#模糊查询  like %:任意多个字符,  _:单个字符
 
#查询姓名以"张"字开头的
select * from person where name like '张%';
#查询姓名以"张"字结尾的
select * from person where name like '%张';
#查询姓名中含有"张"字的
select * from person where name like '%张%';
 
#查询 name 名称 是四个字符的人
select * from person where name like '____';
#查询 name 名称 的第二个字符是 'l'的人
select * from person where name like '_l%';
 
#排除名字带 a的学生
select * from student where name not like 'a%'

6 排序查询

• 关键字: ORDER BY 字段1 DESC, 字段2 ASC

#排序查询格式:
select 字段|* from 表名 [where 条件过滤] [order by 字段[ASC][DESC]]
 
升序:ASC 默认为升序
降序:DESC
PS:排序order by 要写在select语句末尾
 
#按人员工资正序排列,注意:此处可以省略 ASC关键字
select * from person order by salary ASC;
select * from person order by salary;
 
#工资大于5000的人,按工资倒序排列
select * from person where salary >5000 order by salary DESC;
 
#按中文排序
select * from person order by name;
 
#强制中文排序
select * from person order by CONVERT(name USING gbk);
ps:UTF8 默认校对集是 utf8_general_ci , 它不是按照中文来的。你需要强制让MySQL按中文来排序

7 聚合函数

• 聚合: 将分散的聚集到一起.
• 聚合函数: 对列进行操作,返回的结果是一个单一的值,除了 COUNT 以外，都会忽略空值
• COUNT：统计指定列不为NULL的记录行数；
• SUM：计算指定列的数值和，如果指定列类型不是数值类型，那么计算结果为0；
• MAX：计算指定列的最大值，如果指定列是字符串类型，那么使用字符串排序运算；
• MIN：计算指定列的最小值，如果指定列是字符串类型，那么使用字符串排序运算；
• AVG：计算指定列的平均值，如果指定列类型不是数值类型，那么计算结果为0；

#格式:
select 聚合函数(字段) from 表名;
 
#统计人员中最大年龄、最小年龄，平均年龄分别是多少
select max(age),min(age),avg(age) from person;

8 分组查询

• 分组的含义: 将一些具有相同特征的数据 进行归类.比如:性别,部门,岗位等等
• 怎么区分什么时候需要分组呢?
  • 套路: 遇到 "每" 字,一般需要进行分组操作.
  • 例如:
    • 1. 公司每个部门有多少人.
    • 2. 公司中有 多少男员工 和 多少女员工.

#分组查询格式:
select 被分组的字段 from 表名 group by 分组字段 [having 条件字段]
ps: 分组查询可以与 聚合函数 组合使用.

#查询每个部门的平均薪资
select avg(salary),dept from person  GROUP BY dept;

#查询每个部门的平均薪资 并且看看这个部门的员工都有谁?
select avg(salary),dept,GROUP_CONCAT(name) from person GROUP BY dept;
#GROUP_CONCAT(expr):按照分组，将expr字符串按逗号分隔，组合起来

#查询平均薪资大于10000的部门, 并且看看这个部门的员工都有谁?  
select avg(salary),dept,GROUP_CONCAT(name) from person GROUP BY dept; having avg(salary)>10000;

• where 与 having区别:
  • 执行优先级从高到低：where > group by > having
  • 1 Where 发生在分组group by之前，因而Where中可以有任意字段，但是绝对不能使用聚合函数。
  • 2 Having发生在分组group by之后，因而Having中可以使用分组的字段，无法直接取到其他字段,可以使用聚合函数

9 分页查询

• 好处:限制查询数据条数,提高查询效率

#查询前5条数据
select * from person limit 5;
 
#查询第5条到第10条数据
select * from person limit 5,5;
 
#查询第10条到第15条数据
select * from person limit 10,5;
 
ps: limit (起始条数),(查询多少条数);

10 正则表达式

• 正则表达式用来描述或者匹配符合规则的字符串。它的用法和like比较相似，但是它又比like更强大，能够实现一些很特殊的规则匹配；正则表达式需要使用REGEXP命令，匹配上返回"1"匹配不上返回"0"，默认不加条件REGEXP相当于like '%%'。在前面加上NOT相当于NOT LIKE。

命令	说明
^	在字符的开启处进行匹配
$	在字符的末尾处进行匹配
.	匹配任何字符（包括回车和新行）
[….]	匹配括号内的任意单个字符
[m-n]	匹配m到n之间的任意单个字符，例如[0-9],[a-z],[A-Z]
[^..]	不能匹配括号内的任意单个字
a*	匹配0个或多个a,包括空,可以作为占位符使用.
a+	匹配一个或多个a,不包括空
a?	匹配一个或0个a
a1| a2	匹配a1或a2
a{m}	匹配m个a
a{m,}	匹配m个或者更多个a
a{m,n}	匹配m到n个a
a{,n}	匹配0到n个a
(….)	将模式元素组成单一元素，例如（do）*意思是匹配0个多或多个do

• ^：在字符串开始处进行匹配

mysql> SELECT  'abc' REGEXP '^a';
+-------------------+
| 'abc' REGEXP '^a' |
+-------------------+
|                 1 |
+-------------------+
row in set (0.00 sec)

• $：在字符串末尾开始匹配

mysql> SELECT  'abc' REGEXP 'a$';
+-------------------+
| 'abc' REGEXP 'a$' |
+-------------------+
|                 0 |
+-------------------+
row in set (0.01 sec)
 
mysql> SELECT  'abc' REGEXP 'c$';
+-------------------+
| 'abc' REGEXP 'c$' |
+-------------------+
|                 1 |
+-------------------+
row in set (0.00 sec)　

• .：匹配任意字符

mysql> SELECT  'abc' REGEXP '.a';
+-------------------+
| 'abc' REGEXP '.a' |
+-------------------+
|                 0 |
+-------------------+
row in set (0.00 sec)
 
mysql> SELECT  'abc' REGEXP '.b';
+-------------------+
| 'abc' REGEXP '.b' |
+-------------------+
|                 1 |
+-------------------+
row in set (0.00 sec)
 
mysql> SELECT  'abc' REGEXP '.c';
+-------------------+
| 'abc' REGEXP '.c' |
+-------------------+
|                 1 |
+-------------------+
row in set (0.00 sec)
 
mysql> SELECT  'abc' REGEXP 'a.';
+-------------------+
| 'abc' REGEXP 'a.' |
+-------------------+
|                 1 |
+-------------------+
row in set (0.00 sec)

• [...]：匹配括号内的任意单个字符

mysql> SELECT  'abc' REGEXP '[xyz]';
+----------------------+
| 'abc' REGEXP '[xyz]' |
+----------------------+
|                    0 |
+----------------------+
row in set (0.00 sec)
 
mysql> SELECT  'abc' REGEXP '[xaz]';
+----------------------+
| 'abc' REGEXP '[xaz]' |
+----------------------+
|                    1 |
+----------------------+
row in set (0.00 sec)

• [^...] ：注意^符合只有在[]内才是取反的意思，在别的地方都是表示开始处匹配；注意：REGEXP 前的匹配字符作为一个整体

mysql> SELECT  'a' REGEXP '[^abc]';
+---------------------+
| 'a' REGEXP '[^abc]' |
+---------------------+
|                   0 |
+---------------------+
row in set (0.00 sec)
 
mysql> SELECT  'x' REGEXP '[^abc]';
+---------------------+
| 'x' REGEXP '[^abc]' |
+---------------------+
|                   1 |
+---------------------+
row in set (0.00 sec)
 
 
mysql> SELECT  'abc' REGEXP '[^a]';
+---------------------+
| 'abc' REGEXP '[^a]' |
+---------------------+
|                   1 |
+---------------------+
row in set (0.00 sec)
# 注意:　'abc'作为一个整体，所以它匹配不了a

• a*：匹配0个或多个a,包括空字符串。 可以作为占位符使用.有没有指定字符都可以匹配到数据

mysql> SELECT 'stab' REGEXP '.ta*b';
+-----------------------+
| 'stab' REGEXP '.ta*b' |
+-----------------------+
|                     1 |
+-----------------------+
row in set (0.00 sec)
mysql> SELECT 'stb' REGEXP '.ta*b';
+----------------------+
| 'stb' REGEXP '.ta*b' |
+----------------------+
|                    1 |
+----------------------+
 
mysql> SELECT '' REGEXP 'a*';
+----------------+
| '' REGEXP 'a*' |
+----------------+
|              1 |
+----------------+
1 row in set (0.00 sec)

• a+：匹配1个或者多个a,但是不包括空字符

mysql> SELECT 'stab' REGEXP '.ta+b';
+-----------------------+
| 'stab' REGEXP '.ta+b' |
+-----------------------+
|                     1 |
+-----------------------+
row in set (0.00 sec)
 
mysql> SELECT 'stb' REGEXP '.ta+b';
+----------------------+
| 'stb' REGEXP '.ta+b' |
+----------------------+
|                    0 |
+----------------------+
row in set (0.00 sec)

• a?：匹配0个或者1个a

mysql> SELECT 'stb' REGEXP '.ta?b';
+----------------------+
| 'stb' REGEXP '.ta?b' |
+----------------------+
|                    1 |
+----------------------+
row in set (0.00 sec)
 
mysql> SELECT 'stab' REGEXP '.ta?b';
+-----------------------+
| 'stab' REGEXP '.ta?b' |
+-----------------------+
|                     1 |
+-----------------------+
row in set (0.00 sec)
 
mysql> SELECT 'staab' REGEXP '.ta?b';
+------------------------+
| 'staab' REGEXP '.ta?b' |
+------------------------+
|                      0 |
+------------------------+
row in set (0.00 sec)

• a1|a2：匹配a1或者a2

mysql> SELECT 'a' REGEXP 'a|b';
+------------------+
| 'a' REGEXP 'a|b' |
+------------------+
|                1 |
+------------------+
row in set (0.00 sec)
 
mysql> SELECT 'b' REGEXP 'a|b';
+------------------+
| 'b' REGEXP 'a|b' |
+------------------+
|                1 |
+------------------+
row in set (0.00 sec)
 
mysql> SELECT 'b' REGEXP '^(a|b)';
+---------------------+
| 'b' REGEXP '^(a|b)' |
+---------------------+
|                   1 |
+---------------------+
row in set (0.00 sec)
 
mysql> SELECT 'a' REGEXP '^(a|b)';
+---------------------+
| 'a' REGEXP '^(a|b)' |
+---------------------+
|                   1 |
+---------------------+
row in set (0.00 sec)
 
mysql> SELECT 'c' REGEXP '^(a|b)';
+---------------------+
| 'c' REGEXP '^(a|b)' |
+---------------------+
|                   0 |
+---------------------+
row in set (0.00 sec)
# 注意：^符合只有在[]内才是取反的意思，在别的地方都是表示开始处匹配　

• a{m}：匹配m个a

mysql> SELECT 'auuuuc' REGEXP 'au{4}c';
+--------------------------+
| 'auuuuc' REGEXP 'au{4}c' |
+--------------------------+
|                        1 |
+--------------------------+
row in set (0.00 sec)
 
mysql> SELECT 'auuuuc' REGEXP 'au{3}c';
+--------------------------+
| 'auuuuc' REGEXP 'au{3}c' |
+--------------------------+
|                        0 |
+--------------------------+
row in set (0.00 sec)

• a{m,}：匹配m个或者更多个a

mysql> SELECT 'auuuuc' REGEXP 'au{3,}c';
+---------------------------+
| 'auuuuc' REGEXP 'au{3,}c' |
+---------------------------+
|                         1 |
+---------------------------+
row in set (0.00 sec)
 
mysql> SELECT 'auuuuc' REGEXP 'au{4,}c';
+---------------------------+
| 'auuuuc' REGEXP 'au{4,}c' |
+---------------------------+
|                         1 |
+---------------------------+
row in set (0.00 sec)
 
mysql> SELECT 'auuuuc' REGEXP 'au{5,}c';
+---------------------------+
| 'auuuuc' REGEXP 'au{5,}c' |
+---------------------------+
|                         0 |
+---------------------------+
row in set (0.00 sec)

• a{m,n}：匹配m到n个a,包含m和n

mysql> SELECT 'auuuuc' REGEXP 'au{3,5}c';
+----------------------------+
| 'auuuuc' REGEXP 'au{3,5}c' |
+----------------------------+
|                          1 |
+----------------------------+
row in set (0.00 sec)
 
mysql> SELECT 'auuuuc' REGEXP 'au{4,5}c';
+----------------------------+
| 'auuuuc' REGEXP 'au{4,5}c' |
+----------------------------+
|                          1 |
+----------------------------+
row in set (0.00 sec)
 
mysql> SELECT 'auuuuc' REGEXP 'au{5,10}c';
+-----------------------------+
| 'auuuuc' REGEXP 'au{5,10}c' |
+-----------------------------+
|                           0 |
+-----------------------------+
row in set (0.00 sec)

• (abc)：将abc作为一个序列匹配，不用括号括起来都是用单个字符去匹配，如果要把多个字符作为一个整体去匹配就需要用到括号，所以括号适合上面的所有情况。

mysql> SELECT 'xababy' REGEXP 'x(abab)y';
+----------------------------+
| 'xababy' REGEXP 'x(abab)y' |
+----------------------------+
|                          1 |
+----------------------------+
row in set (0.00 sec)
 
mysql> SELECT 'xababy' REGEXP 'x(ab)*y';
+---------------------------+
| 'xababy' REGEXP 'x(ab)*y' |
+---------------------------+
|                         1 |
+---------------------------+
row in set (0.00 sec)
 
mysql> SELECT 'xababy' REGEXP 'x(ab){1,2}y';
+-------------------------------+
| 'xababy' REGEXP 'x(ab){1,2}y' |
+-------------------------------+
|                             1 |
+-------------------------------+
row in set (0.00 sec)

• 总结
  • 特别要注意最后的()的命令，如果不使用()那么所有的都是指单个字符去做匹配，如果需要使用多个字符作为一个整体去匹配,就需要将多个字符使用（）给括起来
    • 1.使用REGEXP和NOT REGEXP操作符(类似LIKE和NOT LIKE)；
    • 2.REGEXP默认也是不区分大小写，可以使用BINARY关键词强制区分大小写； WHERE NAME REGEXP BINARY ‘^[1]’;
    • 3.REGEXP默认是部分匹配原则，即有一个匹配上则返回真。例如：SELECT 'Abc' REGEXP BINARY '[A-Z]';

11 SQL 语句关键字的执行顺序

• 查询:姓名不同人员的最高工资,并且要求大于5000元,同时按最大工资进行排序并取出前5条.

select name, max(salary)
   
from person  
   
where name is not null  
   
group by name  
   
having max(salary) > 5000
   
order by max(salary)
 
limit 0,5

• 在上面的示例中 SQL 语句的执行顺序如下:

  • (1) 首先执行 FROM 子句, 从 person 表 组装数据源的数据
  • (2) 执行 WHERE 子句, 筛选 person 表中 name 不为 NULL 的数据
  • (3) 执行 GROUP BY 子句, 把 person 表按 "name" 列进行分组
  • (4) 计算 max() 聚集函数, 按 "工资" 求出工资中最大的一些数值
  • (5) 执行 HAVING 子句, 筛选工资大于 5000的人员.
  • (7) 执行 ORDER BY 子句, 把最后的结果按 "Max 工资" 进行排序.
  • (8) 最后执行 LIMIT 子句, . 进行分页查询

• 执行顺序: FROM -> WHERE -> GROUP BY -> HAVING -> SELECT -> ORDER BY ->limit

• 转自：http://www.cnblogs.com/wangfengming/articles/8064956.html

---

1. A-Z ↩︎