Python Web（九）Mysql数据库的条件查询与高级使用

聚合函数

-聚合函数的介绍
    聚合函数又叫组函数，通常是对表中的数据进行统计和计算，
    一般结合分组(group by)来使用，用于统计和计算分组数据。
-常用的聚合函数:
    count(col): 表示求指定列的总行数
    max(col): 表示求指定列的最大值
    min(col): 表示求指定列的最小值
    sum(col): 表示求指定列的和
    avg(col): 表示求指定列的平均值
-求总行数
返回非NULL数据的总行数

select count(height) from students; 

返回总行数，包含null值记录;

select count(*) from students;

-求最大值
查询女生的编号最大值

select max(id) from students where gender = 2;

-求最小值
查询未删除的学生最小编号

select min(id) from students where is_del = 0;

-求和
查询男生的总身高

select sum(height) from students where gender = 1;

-平均身高

select sum(height) / count(*) from students where gender = 1;

-求平均值
求男生的平均身高, 聚合函数不统计null值，平均身高有误

select avg(height) from students where gender = 1;

求男生的平均身高, 包含身高是null的

select avg(ifnull(height,0)) from students where gender = 1;

说明:
    ifnull函数: 表示判断指定字段的值是否为null，如果为空使用自己提供的值。
-聚合函数的特点
    聚合函数默认忽略字段为null的记录 要想列值为null的记录也参与计算，必须使用ifnull函数对null值做替换。

分组查询

-分组查询介绍
    分组查询就是将查询结果按照指定字段进行分组，字段中数据相等的分为一组。
-分组查询基本的语法格式如下：
    GROUP BY 列名 [HAVING 条件表达式] [WITH ROLLUP]
-说明:
    列名: 是指按照指定字段的值进行分组。
    HAVING 条件表达式: 用来过滤分组后的数据。
    WITH ROLLUP：在所有记录的最后加上一条记录，显示select查询时聚合函数的统计和计算结果
-group by的使用
    group by可用于单个字段分组，也可用于多个字段分组
根据gender字段来分组

select gender from students group by gender;

根据name和gender字段进行分组

select name, gender from students group by name, gender;

-group by + group_concat()的使用
    group_concat(字段名): 统计每个分组指定字段的信息集合，每个信息之间使用逗号进行分割

根据gender字段进行分组， 查询gender字段和分组的name字段信息

select gender,group_concat(name) from students group by gender;

-group by + 聚合函数的使用
统计不同性别的人的平均年龄

select gender,avg(age) from students group by gender;

统计不同性别的人的个数

select gender,count(*) from students group by gender;

-group by + having的使用
    having作用和where类似都是过滤数据的，但having是过滤分组数据的，只能用于group by
根据gender字段进行分组，统计分组条数大于2的

select gender,count(*) from students group by gender having count(*)>2;

-group by + with rollup的使用
    with rollup的作用是：在最后记录后面新增一行，显示select查询时聚合函数的统计和计算结果

根据gender字段进行分组，汇总总人数

select gender,count(*) from students group by gender with rollup;

根据gender字段进行分组，汇总所有人的年龄

select gender,group_concat(age) from students group by gender with rollup;

连接查询-内连接

-连接查询的介绍
    连接查询可以实现多个表的查询，当查询的字段数据来自不同的表就可以使用连接查询来完成。
-连接查询可以分为:
    内连接查询
    左连接查询
    右连接查询
    自连接查询
-内连接查询
    查询两个表中符合条件的共有记录
-内连接查询语法格式:
    select 字段 from 表1 inner join 表2 on 表1.字段1 = 表2.字段2
-说明:
    inner join 就是内连接查询关键字
    on 就是连接查询条件
-例1：使用内连接查询学生表与班级表:

select * from students as s inner join classes as c on s.cls_id = c.id;

连接查询-左连接

-左连接查询
    以左表为主根据条件查询右表数据，如果根据条件查询右表数据不存在使用null值填充
-左连接查询语法格式:
    select 字段 from 表1 left join 表2 on 表1.字段1 = 表2.字段2
-说明:
    left join 就是左连接查询关键字
    on 就是连接查询条件
    表1 是左表
    表2 是右表
-例1：使用左连接查询学生表与班级表:

select * from students as s left join classes as c on s.cls_id = c.id;

连接查询-右连接

-右连接查询
    以右表为主根据条件查询左表数据，如果根据条件查询左表数据不存在使用null值填充
-右连接查询语法格式:
    select 字段 from 表1 right join 表2 on 表1.字段1 = 表2.字段2
-说明:
    right join 就是右连接查询关键字
    on 就是连接查询条件
    表1 是左表
    表2 是右表
-例1：使用右连接查询学生表与班级表:

select * from students as s right join classes as c on s.cls_id = c.id;

连接查询-自连接

-自连接查询
    左表和右表是同一个表，根据连接查询条件查询两个表中的数据。
-区域表效果图

-区域表

-例1：查询省的名称为“山西省”的所有城市
-创建areas表:

create table areas(
    id varchar(30) not null primary key, 
    title varchar(30), 
    pid varchar(30)
);

-执行sql文件给areas表导入数据:
    这里自行百度全国省市sql，复制保存到文件中，必须要在文件所在路径执行命令。

source areas.sql;

-说明:
    source 表示执行的sql文件
-自连接查询的用法:

select c.id, c.title, c.pid, p.title from areas as c 
    inner join areas as p 
        on c.pid = p.id where p.title = '四川省';

子查询

-子查询的介绍
    在一个 select 语句中,嵌入了另外一个 select 语句, 
    那么被嵌入的 select 语句称之为子查询语句，外部那个select语句则称为主查询.
-主查询和子查询的关系:
    子查询是嵌入到主查询中
    子查询是辅助主查询的,要么充当条件,要么充当数据源
    子查询是可以独立存在的语句,是一条完整的 select 语句
-子查询的使用
例1. 查询大于平均年龄的学生:

select * from students where age > (select avg(age) from students);

例2. 查询学生在班的所有班级名字:

select name from classes where id in (select c_id from students where c_id is not null);

例3. 查找年龄最大,身高最高的学生:

select * from students where (age, height) =  (select max(age), max(height) from students);

数据库设计之三范式

-数据库设计之三范式的介绍
    范式: 对设计数据库提出的一些规范，目前有迹可寻的共有8种范式，一般遵守3范式即可。
    第一范式（1NF）: 强调的是列的原子性，即列不能够再分成其他几列。
    第二范式（2NF）: 满足 1NF，另外包含两部分内容，一是表必须有一个主键；
    二是非主键字段 必须完全依赖于主键，而不能只依赖于主键的一部分。
    第三范式（3NF）: 满足 2NF，另外非主键列必须直接依赖于主键，不能存在传递依赖。
    即不能存在：非主键列 A 依赖于非主键列 B，非主键列 B 依赖于主键的情况。
-第一范式的介绍
如图所示的表结构:

说明:
这种表结构设计就没有达到 1NF，要符合 1NF 我们只需把列拆分，即：把 contact 字段拆分成 name 、tel、addr 等字段。
-第二范式的介绍
如图所示的表结构:

说明:
    这种表结构设计就没有达到 2NF，
    因为 Discount（折扣），
    Quantity（数量）完全依赖于主键（OrderID），
    而 UnitPrice单价，ProductName产品名称只依赖于 ProductID, 
    所以 OrderDetail 表不符合 2NF。
    我们可以把【OrderDetail】表拆分为【OrderDetail】（OrderID，ProductID，Discount，Quantity）和
    【Product】（ProductID，UnitPrice，ProductName）这样就符合第二范式了。
-第三范式的介绍
如图所示的表结构:

说明:
    这种表结构设计就没有达到 3NF，因为 OrderDate，CustomerID，CustomerName，CustomerAddr，CustomerCity 
    等非主键列都完全依赖于主键（OrderID），所以符合 2NF。
    不过问题是 CustomerName，CustomerAddr，CustomerCity 直接依赖的是 CustomerID（非主键列），
    而不是直接依赖于主键，它是通过传递才依赖于主键，所以不符合 3NF。
    我们可以把【Order】表拆分为【Order】（OrderID，OrderDate，CustomerID）
    和【Customer】（CustomerID，CustomerName，CustomerAddr，CustomerCity）从而达到 3NF。
-E-R模型的介绍
    E-R模型即实体-关系模型，E-R模型就是描述数据库存储数据的结构模型。
-E-R模型的使用场景:
    对于大型公司开发项目，我们需要根据产品经理的设计，我们先使用建模工具, 如:power designer，db desinger等这些软件来画出实体-关系模型(E-R模型)
    然后根据三范式设计数据库表结构
-E-R模型的效果图:

说明:
    实体: 用矩形表示，并标注实体名称
    属性: 用椭圆表示，并标注属性名称，
    关系: 用菱形表示，并标注关系名称
        一对一
        一对多
        多对多
一对一的关系:

说明:
    关系也是一种数据，需要通过一个字段存储在表中
    1对1关系，在表A或表B中创建一个字段，存储另一个表的主键值
一对多的关系:

说明:
    1对多关系，在多的一方表(学生表)中创建一个字段，存储班级表的主键值
多对多的关系:

说明:
    多对多关系，新建一张表C，这个表只有两个字段，一个用于存储A的主键值，一个用于存储B的主键值

小结

范式就是设计数据库的一些通用规范。
    1NF强调字段是最小单元，不可再分
    2NF强调在1NF基础上必须要有主键和非主键字段必须完全依赖于主键，也就是说 不能部分依赖
    3MF强调在2NF基础上 非主键字段必须直接依赖于主键，也就是说不能传递依赖(间接依赖)。
E-R模型由 实体、属性、实体之间的关系构成，主要用来描述数据库中表结构。
开发流程是先画出E-R模型，然后根据三范式设计数据库中的表结构

外键约束SQL语句的编写

-外键约束作用
    外键约束:对外键字段的值进行更新和插入时会和引用表中字段的数据进行验证，
    数据如果不合法则更新和插入会失败，保证数据的有效性

-对于已经存在的字段添加外键约束
为cls_id字段添加外键约束

alter table students add foreign key(cls_id) references classes(id);

-在创建数据表时设置外键约束
创建学校表

create table school(
    id int not null primary key auto_increment, 
    name varchar(10)
);

创建老师表

create table teacher(
    id int not null primary key auto_increment, 
    name varchar(10), 
    s_id int not null, 
    foreign key(s_id) references school(id)
);

-删除外键约束
    需要先获取外键约束名称,该名称系统会自动生成,可以通过查看表创建语句来获取名称

show create table teacher;

获取名称之后就可以根据名称来删除外键约束
    alter table teacher drop foreign key 外键名;

练习（分组和聚合函数的组合使用）

-数据准备

-- 创建 "商城" 数据库
create database net_mall charset=utf8;

-- 使用 "商城" 数据库
use net_mall;

-- 创建一个商品goods数据表
create table goods(
    id int unsigned primary key auto_increment not null,
    name varchar(150) not null,
    cate_name varchar(40) not null,
    brand_name varchar(40) not null,
    price decimal(10,3) not null default 0,
    is_show bit not null default 1,
    is_saleoff bit not null default 0
);

-- 向goods表中插入数据

insert into goods values(0,'r510vc 15.6英寸笔记本','笔记本','华硕','3399',default,default); 
insert into goods values(0,'y400n 14.0英寸笔记本电脑','笔记本','联想','4999',default,default);
insert into goods values(0,'g150th 15.6英寸游戏本','游戏本','雷神','8499',default,default); 
insert into goods values(0,'x550cc 15.6英寸笔记本','笔记本','华硕','2799',default,default); 
insert into goods values(0,'x240 超极本','超级本','联想','4880',default,default); 
insert into goods values(0,'u330p 13.3英寸超极本','超级本','联想','4299',default,default); 
insert into goods values(0,'svp13226scb 触控超极本','超级本','索尼','7999',default,default); 
insert into goods values(0,'ipad mini 7.9英寸平板电脑','平板电脑','苹果','1998',default,default);
insert into goods values(0,'ipad air 9.7英寸平板电脑','平板电脑','苹果','3388',default,default); 
insert into goods values(0,'ipad mini 配备 retina 显示屏','平板电脑','苹果','2788',default,default); 
insert into goods values(0,'ideacentre c340 20英寸一体电脑 ','台式机','联想','3499',default,default); 
insert into goods values(0,'vostro 3800-r1206 台式电脑','台式机','戴尔','2899',default,default); 
insert into goods values(0,'imac me086ch/a 21.5英寸一体电脑','台式机','苹果','9188',default,default); 
insert into goods values(0,'at7-7414lp 台式电脑 linux ）','台式机','宏碁','3699',default,default); 
insert into goods values(0,'z220sff f4f06pa工作站','服务器/工作站','惠普','4288',default,default); 
insert into goods values(0,'poweredge ii服务器','服务器/工作站','戴尔','5388',default,default); 
insert into goods values(0,'mac pro专业级台式电脑','服务器/工作站','苹果','28888',default,default); 
insert into goods values(0,'hmz-t3w 头戴显示设备','笔记本配件','索尼','6999',default,default); 
insert into goods values(0,'商务双肩背包','笔记本配件','索尼','99',default,default); 
insert into goods values(0,'x3250 m4机架式服务器','服务器/工作站','ibm','6888',default,default); 
insert into goods values(0,'商务双肩背包','笔记本配件','索尼','99',default,default);

-表结构说明:
    id 表示主键 自增
    name 表示商品名称
    cate_name 表示分类名称
    brand_name 表示品牌名称
    price 表示价格
    is_show 表示是否显示
    is_saleoff 表示是否售完
-SQL语句练习
查询类型cate_name为 '超极本' 的商品名称、价格

select name,price from goods where cate_name = '超级本';

显示商品的分类

select cate_name from goods group by cate_name;

求所有电脑产品的平均价格,并且保留两位小数

select round(avg(price),2) as avg_price from goods;

显示每种商品的平均价格

select cate_name,avg(price) from goods group by cate_name;

查询每种类型的商品中 最贵、最便宜、平均价、数量

select cate_name,max(price),min(price),avg(price),count(*) 
from goods group by cate_name;

查询所有价格大于平均价格的商品，并且按价格降序排序

select id,name,price from goods 
where price > (select round(avg(price),2) as avg_price from goods) 
order by price desc;

将查询结果插入到其他表中

-思考
目前只有一个goods表，我们想要增加一个商品分类信息，比如：移动设备这个分类信息，
只通过goods表无法完成商品分类的添加，那么如何实现添加商品分类信息的操作?
答案:
    创建一个商品分类表，把goods表中的商品分类信息添加到该表中。
    将goods表中的分类名称更改成商品分类表中对应的分类id
-创建商品分类表

create table good_cates(
    id int not null primary key auto_increment, 
    name varchar(50) not null
);

-把goods表中的商品分类添加到商品分类表
查询goods表中商品的分类信息

select cate_name from goods group by cate_name;

将查询结果插入到good_cates表中

insert into good_cates(name) select cate_name from goods group by cate_name;

添加移动设备分类信息

insert into good_cates(name) values('移动设备');

说明:
    insert into .. select .. 表示: 把查询结果插入到指定表中，也就是表复制。

使用连接更新表中某个字段数据

-更新goods表中的商品分类信息
    上面我们已经创建了一个商品分类表(good_cates)，并完成了商品分类信息的插入，
    现在需要更新goods表中的商品分类信息，把商品分类名称改成商量分类id。

-接下来我们实现第二步操作:
    将goods表中的分类名称更改成商品分类表中对应的分类id
查看goods表中的商品分类名称对应的商品分类id

select * from goods inner join good_cates on goods.cate_name = good_cates.name;

把该语句中from 后的语句理解为一张虚表  

update goods g inner join good_cates gc on g.cate_name=gc.name set g.cate_name=gc.id;

创建表并给某个字段添加数据

-思考
    上面我们完成了商品分类表(good_cates)的创建和商品分类信息的添加以及把商品表(goods)中的商品分类名称改成了对应的商品分类id，
    假如我们想要添加一个品牌，比如：双飞燕这个品牌信息，只通过goods表无法完成品牌信息的添加，那么如何实现添加品牌信息的操作?
-答案:
    创建一个品牌表，把goods表中的品牌信息添加到该表中。
    将goods表中的品牌名称更改成品牌表中对应的品牌id
-创建品牌表
查询品牌信息 

select brand_name from goods group by brand_name;

通过create table ...select来创建数据表并且同时插入数据
创建商品分类表，注意: 需要对brand_name 用as起别名，否则name字段就没有值

create table good_brands (     
id int unsigned primary key auto_increment,     
name varchar(40) not null) select brand_name as name from goods group by brand_name;

说明:
    create table .. select 列名 .. 表示创建表并插入数据

-更新goods表中的品牌信息
将goods表中的品牌名称更改成品牌表中对应的品牌id

update goods as g inner join good_brands gb on g.brand_name = gb.name set g.brand_name = gb.id;

修改goods表结构

-修改goods表结构
    目前我们已经把good表中的商品分类和品牌信息已经更改成了商品分类id和品牌id，
    接下来需要把 cate_name 和 brand_name 字段分别改成 cate_id和 brand_id 字段，类型都改成int类型
查看表结构

desc goods;

通过alter table语句修改表结构

alter table goods change cate_name cate_id int not null, change brand_name brand_id int not null;

说明:
    alert table 可以同时修改多个字段信息

PyMysql的使用

-如何实现将100000条数据插入到MySQL数据库?
-答案:
    如果使用之前学习的MySQL客户端来完成这个操作，那么这个工作量无疑是巨大的，
    我们可以通过使用程序代码的方式去连接MySQL数据库，然后对MySQL数据库进行增删改查的方式，
    实现10000条数据的插入，像这样使用代码的方式操作数据库就称为数据库编程。

-Python程序操作MySQL数据库
-安装pymysql第三方包:
    sudo pip3 install pymysql
-说明:
    安装命令使用 sudo pip3 install 第三方包名
    卸载命令使用 sudo pip3 uninstall 第三方包
    大家现在使用的虚拟机已经安装了这个第三方包，可以使用： pip3 show pymysql 命令查看第三方包的信息
    pip3 list 查看使用pip命令安装的第三方包列表
-pymysql的使用:
导入 pymysql 包

import pymysql

-创建连接对象
    调用pymysql模块中的connect()函数来创建连接对象,代码如下:

import pymysql

conn = pymysql.connect(host="localhost",
                       port=3306,
                       user="root",
                       password="123456",
                       database="wj_test",
                       charset="utf8")
# 参数host：连接的mysql主机，如果本机是'localhost'
# 参数port：连接的mysql主机的端口，默认是3306
# 参数user：连接的用户名
# 参数password：连接的密码
# 参数database：数据库的名称
# 参数charset：通信采用的编码方式，推荐使用utf8

-连接对象操作说明:
    关闭连接 conn.close()
    提交数据 conn.commit()
    撤销数据 conn.rollback()
-获取游标对象
    获取游标对象的目标就是要执行sql语句，完成对数据库的增、删、改、查操作。代码如下:

 # 调用连接对象的cursor()方法获取游标对象   
 cur =conn.cursor()

-游标操作说明:
    使用游标执行SQL语句: execute(operation [parameters ]) 执行SQL语句，返回受影响的行数，主要用于执行insert、update、delete、select等语句
    获取查询结果集中的一条数据:cur.fetchone()返回一个元组, 如 (1,'张三')
    获取查询结果集中的所有数据: cur.fetchall()返回一个元组,如((1,'张三'),(2,'李四'))
    关闭游标: cur.close(),表示和数据库操作完成
-pymysql完成数据的查询操作

import pymysql

# 创建连接对象
conn = pymysql.connect(host="localhost",
                       port=3306,
                       user="root",
                       password="123456",
                       database="wj_test",
                       charset="utf8")
# 获取游标对象
cursor = conn.cursor()

# 查询 SQL 语句
sql = "select * from students;"
# 执行 SQL 语句 返回值就是 SQL 语句在执行过程中影响的行数
row_count = cursor.execute(sql)
print("SQL 语句执行影响的行数%d" % row_count)

# 取出结果集中一行数据,　例如:(1, '张三')
# print(cursor.fetchone())

# 取出结果集中的所有数据, 例如:((1, '张三'), (2, '李四'), (3, '王五'))
for line in cursor.fetchall():
    print(line)

# 关闭游标
cursor.close()

# 关闭连接
conn.close()

-pymysql完成对数据的增删改

import pymysql

# 创建连接对象
conn = pymysql.connect(host="localhost",
                       port=3306,
                       user="root",
                       password="123456",
                       database="wj_test",
                       charset="utf8")
# 获取游标对象
cursor = conn.cursor()

try:
    # 添加 SQL 语句
    # sql = "insert into students(name) values('刘璐'), ('王美丽');"
    # 删除 SQ L语句
    # sql = "delete from students where id = 5;"
    # 修改 SQL 语句
    sql = "update students set name = '王铁蛋' where id = 6;"
    # 执行 SQL 语句
    row_count = cursor.execute(sql)
    print("SQL 语句执行影响的行数%d" % row_count)
    # 提交数据到数据库
    conn.commit()
except Exception as e:
    # 回滚数据， 即撤销刚刚的SQL语句操作
    conn.rollback()

# 关闭游标
cursor.close()

# 关闭连接
conn.close()

-说明:
    conn.commit() 表示将修改操作提交到数据库
    conn.rollback() 表示回滚数据
-防止SQL注入
    什么是SQL注入?
    用户提交带有恶意的数据与SQL语句进行字符串方式的拼接，
    从而影响了SQL语句的语义，最终产生数据泄露的现象。
    如何防止SQL注入?
        SQL语句参数化
            SQL语言中的参数使用%s来占位，此处不是python中的字符串格式化操作
            将SQL语句中%s占位所需要的参数存在一个列表中，把参数列表传递给execute方法中第二个参数
-防止SQL注入的示例代码:

from pymysql import connect

def main():

    find_name = input("请输入物品名称：")

    # 创建Connection连接
    conn = connect(host='localhost',port=3306,user='root',password='mysql',database='jing_dong',charset='utf8')
    # 获得Cursor对象
    cs1 = conn.cursor()

    # 非安全的方式
    # 输入 ' or 1 = 1 or '   (单引号也要输入)
    # sql = "select * from goods where name='%s'" % find_name
    # print("""sql===>%s<====""" % sql)
    # # 执行select语句，并返回受影响的行数：查询所有数据
    # count = cs1.execute(sql)

    # 安全的方式
    # 构造参数列表
    params = [find_name]
    # 执行select语句，并返回受影响的行数：查询所有数据
    count = cs1.execute("select * from goods where name=%s", params)
    # 注意：
    # 如果要是有多个参数，需要进行参数化
    # 那么params = [数值1, 数值2....]，此时sql语句中有多个%s即可
    # %s 不需要带引号

    # 打印受影响的行数
    print(count)
    # 获取查询的结果
    # result = cs1.fetchone()
    result = cs1.fetchall()
    # 打印查询的结果
    print(result)
    # 关闭Cursor对象
    cs1.close()
    # 关闭Connection对象
    conn.close()

if __name__ == '__main__':
    main()

-说明:
    execute方法中的 %s 占位不需要带引号

小结

   导包
   import pymysql
   创建连接对象
   pymysql.connect(参数列表)
   获取游标对象
   cursor =conn.cursor()
   执行SQL语句
   row_count = cursor.execute(sql)
   获取查询结果集
   result = cursor.fetchall()
   将修改操作提交到数据库
   conn.commit()
   回滚数据
   conn.rollback()
   关闭游标
   cursor.close()
   关闭连接
   conn.close()

事务

-事务的介绍
    事务就是用户定义的一系列执行SQL语句的操作, 这些操作要么完全地执行，
    要么完全地都不执行， 它是一个不可分割的工作执行单元。

-事务的使用场景:
    在日常生活中，有时我们需要进行银行转账，这个银行转账操作背后就是需要执行多个SQL语句，
    假如这些SQL执行到一半突然停电了，那么就会导致这个功能只完成了一半，这种情况是不允许出现，
    要想解决这个问题就需要通过事务来完成。

-事务的四大特性
    原子性(Atomicity)
    一致性(Consistency)
    隔离性(Isolation)
    持久性(Durability)
原子性:
    一个事务必须被视为一个不可分割的最小工作单元，整个事务中的所有操作要么全部提交成功，
    要么全部失败回滚，对于一个事务来说，不可能只执行其中的一部分操作，这就是事务的原子性
一致性:
    数据库总是从一个一致性的状态转换到另一个一致性的状态。
    （在前面的例子中，一致性确保了，即使在转账过程中系统崩溃，
    支票账户中也不会损失200美元，因为事务最终没有提交，
    所以事务中所做的修改也不会保存到数据库中。）
隔离性:
    通常来说，一个事务所做的修改操作在提交事务之前，对于其他事务来说是不可见的。
    （在前面的例子中，当执行完第三条语句、第四条语句还未开始时，
    此时有另外的一个账户汇总程序开始运行，
    则其看到支票帐户的余额并没有被减去200美元。）
持久性:
    一旦事务提交，则其所做的修改会永久保存到数据库。

-说明:
    事务能够保证数据的完整性和一致性，让用户的操作更加安全。

-事务的使用
    在使用事务之前，先要确保表的存储引擎是 InnoDB 类型, 只有这个类型才可以使用事务，
    MySQL数据库中表的存储引擎默认是 InnoDB 类型。

表的存储引擎说明:
    表的存储引擎就是提供存储数据一种机制，不同表的存储引擎提供不同的存储机制。
说明:
    不同的汽车引擎，提供的汽车动力也是不同的。
-查看MySQL数据库支持的表的存储引擎:

-- 查看MySQL数据库支持的表的存储引擎
show engines;

说明:
    常用的表的存储引擎是 InnoDB 和 MyISAM
    InnoDB 是支持事务的
    MyISAM 不支持事务，优势是访问速度快，对事务没有要求或者以select、insert为主的都可以使用该存储引擎来创建表
查看goods表的创表语句:

-- 选择数据库
use net_mall;
-- 查看goods表
show create table goods;

Table	Create Table
goods	CREATE TABLE goods (
	id int(10) unsigned NOT NULL AUTO_INCREMENT,
	name varchar(150) NOT NULL,
	cate_id int(10) unsigned NOT NULL,
	brand_id int(10) unsigned NOT NULL,
	price decimal(10,3) NOT NULL DEFAULT ‘0.000’,
	is_show bit(1) NOT NULL DEFAULT b’1’,
	is_saleoff bit(1) NOT NULL DEFAULT b’0’,
	PRIMARY KEY (id)
	) ENGINE=InnoDB AUTO_INCREMENT=25 DEFAULT CHARSET=utf8

说明:
    通过创表语句可以得知，goods表的存储引擎是InnoDB。
    修改表的存储引擎使用: alter table 表名 engine = 引擎类型;
比如: alter table students engine = 'MyISAM';
开启事务:
    begin;
    或者
    start transaction;
说明:
    开启事务后执行修改命令，变更数据会保存到MySQL服务端的缓存文件中，而不维护到物理表中
    MySQL数据库默认采用自动提交(autocommit)模式，如果没有显示的开启一个事务,那么每条sql语句都会被当作一个事务执行提交的操作
    当设置autocommit=0就是取消了自动提交事务模式，直到显示的执行commit和rollback表示该事务结束。

set autocommit = 0 表示取消自动提交事务模式，需要手动执行commit完成事务的提交

set autocommit = 0;
insert into students(name) values('刘三峰');
-- 需要执行手动提交，数据才会真正添加到表中, 验证的话需要重新打开一个连接窗口查看表的数据信息，因为是临时关闭自动提交模式
commit

-- 重新打开一个终端窗口，连接MySQL数据库服务端
mysql -uroot -p

-- 然后查询数据,如果上个窗口执行了commit，这个窗口才能看到数据
select * from students;

提交事务:
    将本地缓存文件中的数据提交到物理表中，完成数据的更新。

commit;

回滚事务:
    放弃本地缓存文件中的缓存数据, 表示回到开始事务前的状态

rollback;

事务练习的SQL语句:

begin;
insert into students(name) values('李白');
-- 查询数据，此时有新增的数据, 注意: 如果这里后续没有执行提交事务操作，那么数据是没有真正的更新到物理表中
select * from students;
-- 只有这里提交事务，才把数据真正插入到物理表中
commit;

-- 新打开一个终端，重新连接MySQL数据库，查询students表,这时没有显示新增的数据，说明之前的事务没有提交，这就是事务的隔离性
-- 一个事务所做的修改操作在提交事务之前，对于其他事务来说是不可见的
select * from students;

小结

事务的特性:
    原子性: 强调事务中的多个操作时一个整体
    一致性: 强调数据库中不会保存不一致状态
    隔离性: 强调数据库中事务之间相互不可见
    持久性: 强调数据库能永久保存数据，一旦提交就不可撤销
MySQL数据库默认采用自动提交(autocommit)模式, 也就是说修改数据(insert、update、delete)的操作会自动的触发事务,完成事务的提交或者回滚
开启事务使用 begin 或者 start transaction;
回滚事务使用 rollback;
pymysql 里面的 conn.commit() 操作就是提交事务
pymysql 里面的 conn.rollback() 操作就是回滚事务

索引

-索引的介绍
    索引在MySQL中也叫做“键”，它是一个特殊的文件，它保存着数据表里所有记录的位置信息，
    更通俗的来说，数据库索引好比是一本书前面的目录，能加快数据库的查询速度。
-应用场景:
    当数据库中数据量很大时，查找数据会变得很慢，我们就可以通过索引来提高数据库的查询效率。

-索引的使用
    查看表中已有索引:
        show index from 表名;
    说明:
        主键列会自动创建索引
-索引的创建:
    创建索引的语法格式
        alter table 表名 add index 索引名[可选](列名, ..)
给name字段添加索引

alter table classes add index my_name (name);

说明:
    索引名不指定，默认使用字段名
-索引的删除:
    删除索引的语法格式
        alter table 表名 drop index 索引名
如果不知道索引名，可以查看创表sql语句

show create table classes;
alter table classes drop index my_name;

-案例-验证索引查询性能
创建测试表testindex:

create table test_index(title varchar(10));

-向表中插入十万条数据:

from pymysql import connect

def main():
    # 创建Connection连接
    conn = connect(host='localhost',port=3306,database='python',user='root',password='mysql',charset='utf8')
    # 获得Cursor对象
    cursor = conn.cursor()
    # 插入10万次数据
    for i in range(100000):
        cursor.execute("insert into test_index values('ha-%d')" % i)
    # 提交数据
    conn.commit()

if __name__ == "__main__":
    main()

-验证索引性能操作：

-- 开启运行时间监测：
set profiling=1;
-- 查找第1万条数据ha-99999
select * from test_index where title='ha-99999';
-- 查看执行的时间：
show profiles;
-- 给title字段创建索引：
alter table test_index add index (title);
-- 再次执行查询语句
select * from test_index where title='ha-99999';
-- 再次查看执行的时间
show profiles;

-联合索引
    联合索引又叫复合索引，即一个索引覆盖表中两个或者多个字段，一般用在多个字段一起查询的时候。

创建teacher表

create table teacher
(
    id int not null primary key auto_increment,
    name varchar(10),
    age int
);

创建联合索引

alter table teacher add index (name,age);

联合索引的好处:
    减少磁盘空间开销，因为每创建一个索引，其实就是创建了一个索引文件，那么会增加磁盘空间的开销。
-联合索引的最左原则
    在使用联合索引的时候，我们要遵守一个最左原则,即index(name,age)支持 name 、name 和 age 组合查询,
    而不支持单独 age 查询，因为没有用到创建的联合索引。
最左原则示例:

-- 下面的查询使用到了联合索引
select * from stu where name='张三'; -- 这里使用了联合索引的name部分
select * from stu where name='李四' and age=10; -- 这里完整的使用联合索引，包括 name 和 age 部分 
-- 下面的查询没有使用到联合索引
select * from stu where age=10; -- 因为联合索引里面没有这个组合，只有 name | name age 这两种组合

说明:
    在使用联合索引的查询数据时候一定要保证联合索引的最左侧字段出现在查询条件里面，否则联合索引失效
-MySQL中索引的优点和缺点和使用原则
    优点：
        加快数据的查询速度
    缺点：
        创建索引会耗费时间和占用磁盘空间，并且随着数据量的增加所耗费的时间也会增加
    使用原则：
        通过优缺点对比，不是索引越多越好，而是需要自己合理的使用。
        对经常更新的表就避免对其进行过多索引的创建，对经常用于查询的字段应该创建索引，
        数据量小的表最好不要使用索引，因为由于数据较少，可能查询全部数据花费的时间比遍历索引的时间还要短，索引就可能不会产生优化效果。
        在一字段上相同值比较多不要建立索引，比如在学生表的"性别"字段上只有男，女两个不同值。相反的，在一个字段上不同值较多可是建立索引。

小结

索引是加快数据库的查询速度的一种手段
创建索引使用: alter table 表名 add index 索引名[可选] (字段名, xxx);
删除索引使用: alter table 表名 drop index 索引名;