路飞学城Python-Day36

24-记录的增删改查

1. 插入完整数据（顺序插入）

语法一：

INSERT INTO 表名(字段1,字段2,字段3…字段n) VALUES(值1,值2,值3…值n);

语法二：

INSERT INTO 表名 VALUES (值1,值2,值3…值n);

2. 指定字段插入数据

语法：

INSERT INTO 表名(字段1,字段2,字段3…) VALUES (值1,值2,值3…);

3. 插入多条记录

语法：

INSERT INTO 表名 VALUES

(值1,值2,值3…值n),

(值1,值2,值3…值n);

4. 插入查询结果

语法：

INSERT INTO 表名(字段1,字段2,字段3…字段n)

SELECT (字段1,字段2,字段3…字段n) FROM 表2

WHERE …;

语法：

UPDATE 表名 SET

字段1=值1,

字段2=值2,

WHERE CONDITION;

示例：

UPDATE mysql.user SET password=password(‘123’)

where user=’root’ and host=’localhost’;

语法：

DELETE FROM 表名

WHERE CONITION;

示例：

DELETE FROM mysql.user

WHERE password=’’;

练习：

更新MySQL root用户密码为mysql123

删除除从本地登录的root用户以外的所有用户

单表查询

查询语法

SELECT 字段1,字段2... FROM 表名

WHERE 条件

GROUP BY field

HAVING 筛选

ORDER BY field

LIMIT 限制条数

25-简单查询

#简单查询 SELECT id,name,sex,age,hire_date,post,post_comment,salary,office,depart_id

FROM employee;

SELECT * FROM employee;

SELECT name,salary FROM employee;

#避免重复DISTINCT SELECT DISTINCT post FROM employee;

#通过四则运算查询

SELECT name, salary*12 FROM employee;

SELECT name, salary*12 AS Annual_salary FROM employee;

SELECT name, salary*12 Annual_salary FROM employee;

#定义显示格式 CONCAT() 函数用于连接字符串

SELECT CONCAT('姓名: ',name,' 年薪: ', salary*12) AS Annual_salary

FROM employee;

CONCAT_WS() 第一个参数为分隔符

SELECT CONCAT_WS(':',name,salary*12) AS Annual_salary

FROM employee;

结合CASE语句：

SELECT

(

CASE

WHEN NAME = 'egon' THEN

NAME

WHEN NAME = 'alex' THEN

CONCAT(name,'_BIGSB')

ELSE

concat(NAME, 'SB')

END

) as new_name

FROM

emp;

26-where约束

where就是过滤使用的

where的原理

先存在表，然后再表里查询记录，遍历记录去查条件，整个表全部遍历完

1. 比较运算符：> < >= <= <> !=

2. between 80 and 100 值在10到20之间

3. in(80,90,100) 值是10或20或30

4. like 'egon%'

pattern可以是%或_，

%表示任意多字符

_表示一个字符

5. 逻辑运算符：在多个条件直接可以使用逻辑运算符 and or not

#1:单条件查询

SELECT name FROM employee

WHERE post='sale';

#2:多条件查询

SELECT name,salary FROM employee

WHERE post='teacher' AND salary>10000;

#3:关键字BETWEEN AND

SELECT name,salary FROM employee

WHERE salary BETWEEN 10000 AND 20000;

SELECT name,salary FROM employee

WHERE salary NOT BETWEEN 10000 AND 20000;

#4:关键字IS NULL(判断某个字段是否为NULL不能用等号，需要用IS)

SELECT name,post_comment FROM employee

WHERE post_comment IS NULL;

SELECT name,post_comment FROM employee

WHERE post_comment IS NOT NULL;

SELECT name,post_comment FROM employee

WHERE post_comment=''; 注意''是空字符串，不是null

ps：

执行

update employee set post_comment='' where id=2;

再用上条查看，就会有结果了

#5:关键字IN集合查询

SELECT name,salary FROM employee

WHERE salary=3000 OR salary=3500 OR salary=4000 OR salary=9000 ;

SELECT name,salary FROM employee

WHERE salary IN (3000,3500,4000,9000) ;

SELECT name,salary FROM employee

WHERE salary NOT IN (3000,3500,4000,9000) ;

#6:关键字LIKE模糊查询

通配符’%’

SELECT * FROM employee

WHERE name LIKE 'eg%';

通配符’_’

SELECT * FROM employee

WHERE name LIKE 'al__';

27-group by分组

group by是在where运行之后才运行的，也就是写的时候就要把group by写在where之后

到目前为止，执行的优先级是先找表，按照where的查询条件找到记录，然后再运行group by

分组就是把一张表的记录按照相同的字段进行归类

一旦听到每这个字就需要进行分组

分组之后只能取分组的字段和每个组的聚合函数的结果

没有group by 则整体算为一组

#1、首先明确一点：分组发生在where之后，即分组是基于where之后得到的记录而进行的

#2、分组指的是：将所有记录按照某个相同字段进行归类，比如针对员工信息表的职位分组，或者按照性别进行分组等

#3、为何要分组呢？

取每个部门的最高工资

取每个部门的员工数

取男人数和女人数

小窍门：‘每’这个字后面的字段，就是我们分组的依据

#4、大前提：

可以按照任意字段分组，但是分组完毕后，比如group by post，只能查看post字段，如果想查看组内信息，需要借助于聚合函数

28-having过滤

having的过滤是在分组之后进行的，where是在分组之前进行的

#！！！执行优先级从高到低：where > group by > having

#1. Where 发生在分组group by之前，因而Where中可以有任意字段，但是绝对不能使用聚合函数。

#2. Having发生在分组group by之后，因而Having中可以使用分组的字段，无法直接取到其他字段,可以使用聚合函数

29-order by排序

如果不指定排序的话，表中是默认id排序的

按单列排序

SELECT * FROM employee ORDER BY salary;

SELECT * FROM employee ORDER BY salary ASC;

SELECT * FROM employee ORDER BY salary DESC;

按多列排序:先按照age排序，如果年纪相同，则按照薪资排序

SELECT * from employee

ORDER BY age,

salary DESC;

30-limit限制条数

从语法层面和执行层面都是最后执行的

限制条数的目的是为了显示的时候不要密密麻麻的所有的数据全部都罗列出来

示例：

SELECT * FROM employee ORDER BY salary DESC

LIMIT 3; #默认初始位置为0

SELECT * FROM employee ORDER BY salary DESC

LIMIT 0,5; #从第0开始，即先查询出第一条，然后包含这一条在内往后查5条

SELECT * FROM employee ORDER BY salary DESC

LIMIT 5,5; #从第5开始，即先查询出第6条，然后包含这一条在内往后查5条

31-单表查询的语法顺序与执行顺序总结

语法顺序

SELECT 字段1,字段2... FROM 表名

WHERE 条件

GROUP BY field

HAVING 筛选

ORDER BY field

LIMIT 限制条数

执行顺序

重点中的重点：关键字的执行优先级

from

where

group by

having

select

distinct

order by

limit

32-正则查询

SELECT * FROM employee WHERE name REGEXP '^ale';

SELECT * FROM employee WHERE name REGEXP 'on$';

SELECT * FROM employee WHERE name REGEXP 'm{2}';

小结：对字符串匹配的方式

WHERE name = 'egon';

WHERE name LIKE 'yua%';

WHERE name REGEXP 'on$'

33-连表操作

由于数据不应该存放在一个表里，而是应该把多个数据存放在不同的表中，所以一定会有多表查询的机制，由于方便管理，数据虽然被拆分了，但是必须要找到方法能把数据多表合并连表查询

本质上是基于笛卡尔积进行筛选

1 交叉连接：不适用任何匹配条件。生成笛卡尔积

mysql> select * from employee,department;

+----+------------+--------+------+--------+------+--------------+

| id | name | sex | age | dep_id | id | name |

+----+------------+--------+------+--------+------+--------------+

| 1 | egon | male | 18 | 200 | 200 | 技术 |

| 1 | egon | male | 18 | 200 | 201 | 人力资源 |

| 1 | egon | male | 18 | 200 | 202 | 销售 |

| 1 | egon | male | 18 | 200 | 203 | 运营 |

| 2 | alex | female | 48 | 201 | 200 | 技术 |

| 2 | alex | female | 48 | 201 | 201 | 人力资源 |

| 2 | alex | female | 48 | 201 | 202 | 销售 |

| 2 | alex | female | 48 | 201 | 203 | 运营 |

| 3 | wupeiqi | male | 38 | 201 | 200 | 技术 |

| 3 | wupeiqi | male | 38 | 201 | 201 | 人力资源 |

| 3 | wupeiqi | male | 38 | 201 | 202 | 销售 |

| 3 | wupeiqi | male | 38 | 201 | 203 | 运营 |

| 4 | yuanhao | female | 28 | 202 | 200 | 技术 |

| 4 | yuanhao | female | 28 | 202 | 201 | 人力资源 |

| 4 | yuanhao | female | 28 | 202 | 202 | 销售 |

| 4 | yuanhao | female | 28 | 202 | 203 | 运营 |

| 5 | liwenzhou | male | 18 | 200 | 200 | 技术 |

| 5 | liwenzhou | male | 18 | 200 | 201 | 人力资源 |

| 5 | liwenzhou | male | 18 | 200 | 202 | 销售 |

| 5 | liwenzhou | male | 18 | 200 | 203 | 运营 |

| 6 | jingliyang | female | 18 | 204 | 200 | 技术 |

| 6 | jingliyang | female | 18 | 204 | 201 | 人力资源 |

| 6 | jingliyang | female | 18 | 204 | 202 | 销售 |

| 6 | jingliyang | female | 18 | 204 | 203 | 运营 |

+----+------------+--------+------+--------+------+--------------+

2 内连接：只连接匹配的行

#找两张表共有的部分，相当于利用条件从笛卡尔积结果中筛选出了正确的结果

#department没有204这个部门，因而employee表中关于204这条员工信息没有匹配出来

mysql> select employee.id,employee.name,employee.age,employee.sex,department.name from employee inner join department on employee.dep_id=department.id;

+----+-----------+------+--------+--------------+

| id | name | age | sex | name |

+----+-----------+------+--------+--------------+

| 1 | egon | 18 | male | 技术 |

| 4 | yuanhao | 28 | female | 销售 |

| 5 | liwenzhou | 18 | male | 技术 |

+----+-----------+------+--------+--------------+

#上述sql等同于

mysql> select employee.id,employee.name,employee.age,employee.sex,department.name from employee,department where employee.dep_id=department.id;

3 外链接之左连接：优先显示左表全部记录

#以左表为准，即找出所有员工信息，当然包括没有部门的员工

#本质就是：在内连接的基础上增加左边有右边没有的结果

mysql> select employee.id,employee.name,department.name as depart_name from employee left join department on employee.dep_id=department.id;

+----+------------+--------------+

| id | name | depart_name |

+----+------------+--------------+

| 1 | egon | 技术 |

| 5 | liwenzhou | 技术 |

| 2 | alex | 人力资源 |

| 3 | wupeiqi | 人力资源 |

| 4 | yuanhao | 销售 |

| 6 | jingliyang | NULL |

+----+------------+--------------+

4 外链接之右连接：优先显示右表全部记录

#以右表为准，即找出所有部门信息，包括没有员工的部门

#本质就是：在内连接的基础上增加右边有左边没有的结果

mysql> select employee.id,employee.name,department.name as depart_name from employee right join department on employee.dep_id=department.id;

+------+-----------+--------------+

| id | name | depart_name |

+------+-----------+--------------+

| 1 | egon | 技术 |

| 2 | alex | 人力资源 |

| 3 | wupeiqi | 人力资源 |

| 4 | yuanhao | 销售 |

| 5 | liwenzhou | 技术 |

| NULL | NULL | 运营 |

+------+-----------+--------------+

5 全外连接：显示左右两个表全部记录

全外连接：在内连接的基础上增加左边有右边没有的和右边有左边没有的结果

#注意：mysql不支持全外连接 full JOIN

#强调：mysql可以使用此种方式间接实现全外连接

select * from employee left join department on employee.dep_id = department.id

union

select * from employee right join department on employee.dep_id = department.id

;

#查看结果

+------+------------+--------+------+--------+------+--------------+

| id | name | sex | age | dep_id | id | name |

+------+------------+--------+------+--------+------+--------------+

| 1 | egon | male | 18 | 200 | 200 | 技术 |

| 5 | liwenzhou | male | 18 | 200 | 200 | 技术 |

| 2 | alex | female | 48 | 201 | 201 | 人力资源 |

| 3 | wupeiqi | male | 38 | 201 | 201 | 人力资源 |

| 4 | yuanhao | female | 28 | 202 | 202 | 销售 |

| 6 | jingliyang | female | 18 | 204 | NULL | NULL |

+------+------------+--------+------+--------+------+--------------+

#注意 union与union all的区别：union会去掉相同的纪录

34-SELECT语句关键字执行优先级

一 SELECT语句关键字的定义顺序

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 <order_by_condition>

LIMIT <limit_number>

二 SELECT语句关键字的执行顺序

(7) SELECT

(8) DISTINCT <select_list>

(1) FROM <left_table>

(3) <join_type> JOIN <right_table>

(2) ON <join_condition>

(4) WHERE <where_condition>

(5) GROUP BY <group_by_list>

(6) HAVING <having_condition>

(9) ORDER BY <order_by_condition>

(10) LIMIT <limit_number>

35-子查询

子查询就是把一条查询语句放入另一条查询语句里当做查询的条件来使用

#1：子查询是将一个查询语句嵌套在另一个查询语句中。

#2：内层查询语句的查询结果，可以为外层查询语句提供查询条件。

#3：子查询中可以包含：IN、NOT IN、ANY、ALL、EXISTS 和 NOT EXISTS等关键字

#4：还可以包含比较运算符：= 、 !=、> 、<等

1 带IN关键字的子查询

#查询平均年龄在25岁以上的部门名

select id,name from department

where id in

(select dep_id from employee group by dep_id having avg(age) > 25);

#查看技术部员工姓名

select name from employee

where dep_id in

(select id from department where name='技术');

#查看不足1人的部门名(子查询得到的是有人的部门id)

select name from department where id not in (select distinct dep_id from employee);

2 带比较运算符的子查询

#比较运算符：=、!=、>、>=、<、<=、<>

#查询大于所有人平均年龄的员工名与年龄

mysql> select name,age from emp where age > (select avg(age) from emp);

+---------+------+

| name | age |

+---------+------+

| alex | 48 |

| wupeiqi | 38 |

+---------+------+

2 rows in set (0.00 sec)

#查询大于部门内平均年龄的员工名、年龄

select t1.name,t1.age from emp t1

inner join

(select dep_id,avg(age) avg_age from emp group by dep_id) t2

on t1.dep_id = t2.dep_id

where t1.age > t2.avg_age;

3 带EXISTS关键字的子查询

#department表中存在dept_id=203，Ture

mysql> select * from employee

-> where exists

-> (select id from department where id=200);

+----+------------+--------+------+--------+

| id | name | sex | age | dep_id |

+----+------------+--------+------+--------+

| 1 | egon | male | 18 | 200 |

| 2 | alex | female | 48 | 201 |

| 3 | wupeiqi | male | 38 | 201 |

| 4 | yuanhao | female | 28 | 202 |

| 5 | liwenzhou | male | 18 | 200 |

| 6 | jingliyang | female | 18 | 204 |

+----+------------+--------+------+--------+

#department表中存在dept_id=205，False

mysql> select * from employee

-> where exists

-> (select id from department where id=204);

Empty set (0.00 sec)