MySQL

Posted 2020-11-22 唐雪成

# -*- coding: utf-8 -*-
# Version: mysql 8.0.15
# Tools: Sublime Test 3.2.1
__date__ = "2019年11月18日11:15:59"
__author__ = "唐雪成"

1.MySQL概述
1.数据库概述:
DB (database): DB就是数据库,存储数据的仓库
DBMS(database management system)数据库管理软件 -- MySQL,SQL_Server,Oracle,Mariadb,DB2,MongoDB
DBS(database system)数据库系统=DB(存储)+DBMS(数据库软件)+数据库应用(财务管理系统,人事管理系统)+用户
2.如何选择数据库
开源软件: MySQL,Mariadb,MongoDB -- 游戏网站,购物网站,论坛网站
商业软件: Oracle,DB2,SQL_Server -- 政府部门,金融机构
不跨平台: SQL_Server
跨平台: MySQL,Oracle,Mariadb,DB2,MongoDB
关系型数据库: MySQL,Oracle,Mariadb,SQL_Server
非关系型数据库: MongoDB,Redis,Hbase,Neo4j
3.MySQL的特点
1.关系型数据库
1.数据是以行和列的形式去存储的
2.这一系列的行和列称为表
3.表中的每一行叫一条记录
4.表中的每一列叫一个字段
5.表和表之间的逻辑关联叫关系
示例:
1.关系型数据库存储
表1学生信息表
姓名 年龄 班级
武大郎 25 CLS01
潘金莲 23 CLS01
mysql> select * from students;
+------+-----------+------+-------+
| id | name | age | class |
+------+-----------+------+-------+
| 1 | 武大郎 | 25 | CLS01 |
| 2 | 潘金莲 | 23 | CLS01 |
+------+-----------+------+-------+
2 rows in set (0.00 sec)
表2班级信息表
班级 班主任
CLS01 卢俊义
CLS02 宋江
mysql> select * from classes;
+------+-------+------------+
| id | class | headmaster |
+------+-------+------------+
| 1 | CLS01 | 卢俊义 |
| 2 | CLS02 | 宋江 |
+------+-------+------------+
2 rows in set (0.00 sec)
2.非关系型数据库中存储(MongoDB)
{"姓名":"武大郎","年龄":25,"班级":"CLS01","班主任":"卢俊义"}
{"姓名":"潘金莲","年龄":23,"班级":"CLS01"}
2.跨平台: 可以在Unix,Linux,Windows上运行数据库服务
3.支持多种编程语言: Python,Java,php等
4.MySQL的安装和配置
1.Windows环境
pass
2.Mac环境
pass
3.Ubuntu环境
pass
4.CentOS环境
pass
5.Linux平台查找配置文件命令
mysqld --verbose --help|grep -A 1 ‘Default options‘
mysql --verbose --help|grep -A 1 ‘Default options‘
/etc/my.cnf
/etc/mysql/my.cnf
/usr/etc/my.cnf
~/.my.cnf
5.启动连接和退出MySQL服务
1.查看MySQL服务状态
sudo /etc/init.d/mysql status
2.启动,停止,重启MySQL服务
net start mysql
net stop mysql
net restart mysql
sudo /etc/init.d/mysql start
sudo /etc/init.d/mysql stop
sudo /etc/init.d/mysql restart
3.客户端连接(本地连接可省略-h选项)
myslq -h主机地址 -u用户名 -p密码
mysql -hlocalhost -uroot -paotx4869
4.退出数据库
exit quit Ctrl+d q
6.SQL命令使用规则
1.每条SQL命令必须以;结尾
2.SQL命令不区分字母大小写
3.有-连接的时候在名字前后加``表示一个整体(键盘数字1左边的按键),例如use `Python-01`
4.使用c来终止命令的执行(Linux平台Ctrl+c)
5.--注释符
2.MySQL基本命令
1.查看数据库版本: select version();
2.显示数据库时间: select now();
3.更改库,表的默认字符集
1.方法: 通过更改MySQL服务的配置文件来实现
2.步骤
1.获取root权限: sudo -i
2.切换到配置文件所在路径: cd /etc/mysql/my.conf
3.备份文件(-p选项连同源文件权限一起复制): cp -p my.conf my.cnf.bak
4.用vi或vim打开my.conf插入到[mysqld]下
[mysqld]
character-set-server=utf8
5.重启MySQL服务
/etc/init.d/mysql restart
/etc/init.d/mysql reload -- 重载配置文件
6.退出超级用户: exit
7.登录mysql验证
mysql -uroot -paptx4869
create database 库名;
show create database 库名;
4.配置文件常用配置
[mysqld]
# 设置3306端口
port=3306
# 设置mysql的安装目录
basedir=D:Program FilesMySQL
# 设置mysql数据库的数据的存放目录
datadir=D:Program FilesMySQLData
# 允许最大连接数
max_connections=200
# 允许连接失败的次数。
max_connect_errors=10
# 服务端使用的字符集默认为UTF8
character-set-server=utf8
# 创建新表时将使用的默认存储引擎
default-storage-engine=INNODB
# 默认使用“mysql_native_password”插件认证
#mysql_native_password
default_authentication_plugin=mysql_native_password
# 设置导入导出的默认路径
secure_file_priv=D:Program FilesMySQLlibmysql-files
[mysql]
# 设置mysql客户端默认字符集
default-character-set=utf8
[client]
# 设置mysql客户端连接服务端时默认使用的端口
port=3306
default-character-set=utf8
3.数据库的操作
1.数据库的命名规则
1.可以使用数字,字母,_,但是不能使用纯数字
2.库名区分大小写
3.库名具有唯一性
4.不能使用特殊字符和MySQL关键字命名库名
2.查看所有数据库: show databases;
3.常见数据库(可选指定默认字符集)
create databases 库名 default charset=utf8;
示例:
create database `Python-01`;
create database indexdb default charset=utf8;
4.查看数据库的创建过程
show create database 库名;
示例: show create database `Python-01`;
5.使用(切换)数据库
use 库名;
示例: use indexdb;
6.查看当前使用的数据库: select database();
7.删除数据库
drop database 库名
示例: drop database `Python-01`;
4.数据表的操作(增删改查)
1.查看当前使用的库中所有的表: show tables;
2.创建表(可选制定字符集create table)
create table 表名(
字段名 数据类型 约束,
字段名 数据类型 约束
)default charset=utf8;
示例1:
create table t1(
id int primary key not null auto_increment,
name varchar(20),
age tinyint unsigned default 0,
high decimal(5, 2),
gender enum("男", "女", "保密") default "保密"
)default charset=utf8;
示例2:
create table students(
id int unsigned primary key not null auto_increment,
name varchar(30),
age tinyint unsigned default 0,
hight decimal(5, 2),
gender enum("男", "女", "中性", "保密") default "保密",
cls_id int unsigned
);
示例3:
create table classes(
id int unsigned primary key not null auto_increment,
name varchar(30)
);
3.查看创建表的语句(查看表的字符集 show create table)
show create table 表名;
示例: show create table t1;
4.查看表结构(desc)
desc 表名;
示例: desc t1;
5.表的重命名(alter rename)
alter table 表名 rename 新表名;
示例: alter table t1 rename t2;
6.删除表(drop)
drop tables 表名;
示例: drop tables t2;
7.修改表-添加字段(add)
末尾插入: alter table 表名 add 字段名 数据类型; -- 在表的末尾插入字段
开头插入: alter table 表名 add 字段名 数据类型 first; -- 在表的开头位置插入字段
指定插入: alter table 表名 add 字段名 数据类型 after 指定字段名; -- 在指定字段后插入字段
示例: alter table students add birthday datetime;
8.修改表-修改字段(modify/change)
1.不重命名字段
alter table 表名 modify 列名 类型及约束;
示例: alter table students modify birthday date;
2.重命名字段
alter table 表名 change 原列名 新列名 类型及约束;
示例: alter table students change birthday birth date default "1900-01-01";
9.修改表-删除字段(drop)
alter table 表名 drop 列名;
示例: alter table students drop hight;
10.数据类型(数值/字符/枚举/日期时间)
1.数值类型(有符号signed和无符号unsigned)
1.整数
1.大整型int(4个字节),取值范围(0~2**32-1)
2.微小整型tinyint(1个字节),默认有符号signed取值范围(-128~127),无符号unsigned取值范围(0~255)
3.小整数smallint(2个字节),取值范围(0~65535)
4.极大整数bigint(8个字节),取值范围(0~2**64-1)
2.浮点型
float
4个字节最多显示7个有效位,浮点型插入整数时会自动补全小数位位数,如果小数位超出会四舍五入
语法: 字段名 float(m, n) -- m表示总位数,n表示小数位数
double
8个字节最多显示15个有效位
语法: 字段名 double(m, n)
decimal
m+2个字节,最多显示28个有效位
语法: decimal(m, n)
2.字符类型
char
定长,不给定宽度默认为1,浪费存储空间,但是性能高
取值范围: 1~255
varchar
变长,没有默认宽度,必须给定一个宽度值,节省存储空间,但是性能低
取值范围: 1~65535
字符类型的宽度与数值类型宽度区别
数值类型的宽度仅仅为显示宽度,只用于select查询显示,和占用存储空间大小无关,可用zerofill查看效果
字符类型的宽度超过则无法存储
3.枚举类型
字段值只能在列举的范围内选择
enum(...)
单选,最多有65535个值
语法: enum(值1, 值2, ..., 值n)
set(...)
多选,最多有64个不同的值
语法: set(值1, 值2, ..., 值n)
4.日期时间类型
year: 年 YYYY
date: 日期 YYYYMMDD
tame: 时间 HHMMSS
datetime: 日期时间 YYYYMMDDHHMMSS -- 插入记录datetime字段不给值默认返回null
timestamp: 日期时间 YYYYMMDDHHMMSS -- 插入记录timestamp字段不给值默认返回系统当前时间
11.约束(default/null)
为了保证数据的完整性,一致性,有效性,可以限制无效的数据插入到数据表中
1.默认约束
在插入记录时,如果不给该字段赋值,则使用默认值
语法: 字段名 数据类型 default 默认值
2.非空约束
不允许该字段的值有空值NULL记录
语法: 字段名 数据类型 not null
5.数据表记录操作(增删改查)
1.表记录-插入记录(insert into)
1.全列插入
insert into 表名 values(字段信息);
主字段可以用0 null default来占位,枚举中的下标从1开始
示例:
insert into students values(0, "Coco", 18, "男", 1, "2000-01-01");
insert into students values(null, "Coco", 18, "男", 1, "1988-06-06");
insert into students values(0, "Coco", 18, 1, 1, "2006-01-01");
insert into classes values(default, "Python全站");
2.部分插入
insert into students (name, gender) values("大乔", 2);
3.多行插入
insert into students (name, gender) values("小乔", 2), ("貂蝉", 2);
insert into students values(0, "西施", 16, 1, 2, "2006-01-01"), (0, "昭君", 16, 1, 2, "2006-01-01");
2.表记录-修改记录(update set)
update 表名 set 列1=值1, 列2=值2 ... where 条件;
示例:
update students set gender=1; -- 性别全部修改为男
update students set gender=1 where name="Coco"; -- name是Coco的性别全部改为男
update students set age=18, gender=1 where id=3; -- id为3的进行修改
3.表记录-删除记录(delete)
1.物理删除
delete from 表名 where 条件;
示例:
delete from students; -- 整个数据表中的所有记录全部删除
delete from students where name="Coco"; -- name是Coco的记录全部删除
2.逻辑删除
用一个字段表示这条信息是否已经不能再使用了,给表添加一个is_delete字段bit类型
示例:
alter table students add is_delete bit default 0;
update students set is_delete=1 where id=7;
4.表记录-查询记录(select/where/as/distinct)
1.查询表中所有记录
select * from 表名;
示例: select * from students;
2.定条件查询
select * from 表名 where 条件;
示例:
select * from students where name="Coco"; -- 查询name为Coco的所有记录
select * from students where id>3; -- 查询id大于3的所有记录
3查询指定记录
select 列1, 列2, ... from 表名;
select 表名.字段, ... from 表名;
示例:
select name, gender from students;
select students.name, students.age from students;
4.使用as为字段指定别名
select 字段 as 别名, ... from 数据表 where ...;
示例: select name as 姓名, gender as 性别 from students;
5.使用as为表指定别名
select 别名.字段, ... from 表名 as 别名;
示例: select s.name, s.age from students as s;
6.消除重复记录(不显示字段的重复值)
distinct 字段名
示例: select distinct gender from students;
7.字段顺序
语法概述: 字段的显示顺序是可以无序的,显示的字段也可以是虚拟字段
示例: select id as 序号, gender as 性别, name as 姓名 from students;
5.表记录-查询记录(条件/模糊/分组/聚合/分页/运算)
1.SQL执行顺序总结
2.from 表名
2.where ...
3.group by ...
4.select ... 聚合函数 ...
5.having ...
6.order by ...
7.limit ...
2.数据准备
create database Python_test charset=utf8;
use Python_test;
create table students(
id int unsigned primary key auto_increment not null,
name varchar(20) default ‘‘,
age tinyint unsigned default 0,
height decimal(5, 2),
gender enum("男", "女", "中性", "保密") default "保密",
cls_id int unsigned default 0,
is_delete bit default 0
);
create table classes(
id int unsigned auto_increment primary key not null,
name varchar(30) not null
);
insert into students values
(0,‘小明‘,18,180.00,2,1,0),
(0,‘小月月‘,18,180.00,2,2,1),
(0,‘彭于晏‘,29,185.00,1,1,0),
(0,‘刘德华‘,59,175.00,1,2,1),
(0,‘黄蓉‘,38,160.00,2,1,0),
(0,‘凤姐‘,28,150.00,4,2,1),
(0,‘王祖贤‘,18,172.00,2,1,1),
(0,‘周杰伦‘,36,NULL,1,1,0),
(0,‘程坤‘,27,181.00,1,2,0),
(0,‘刘亦菲‘,25,166.00,2,2,0),
(0,‘金星‘,33,162.00,3,3,1),
(0,‘静香‘,12,180.00,2,4,0),
(0,‘郭靖‘,12,170.00,1,4,0),
(0,‘周杰‘,34,176.00,2,5,0);
insert into classes values (0, "python_01期"), (0, "python_02期"), (0, "python_04期");
3.条件查询(数值/字符/逻辑/范围/空)
1.数值比较运算符: < <= > >= = != <>
select * from students where age > 18;
select * from students where age < 18;
select * from students where age = 18;
select * from students where age != 18;
2.字符比较运算符: = !=
select * from students where name = "";
select * from students where name != "";
3.逻辑比较运算符: and or not
select * from students where age > 18 and age < 30;
select * from students where age > 18 or height > 180;
select * from students where not (gender=‘男‘ and age > 20);
4.范围比较运算符: between and, in, not in
between 值1 and 值2 -- 表示在一个连续范围内
-- 查询年龄在18到34岁之间的信息
select name, age from students where age between 18 and 34;
not between 值1 and 值2 -- 表示不再一个连续的范围内
-- 查询年龄不在18到34之间的信息
select name, age from students where age not between 18 and 34;
in(值1, 值2, ..., 值n) -- 表示在一个非连续的范围内
-- 查询年龄为12 18 34的姓名和年龄
select name, age from students where age=12 or age=18 or age=34;
select name, age from students where age in(12, 18, 34);
not in(值1, 值2, ..., 值n) -- 不是非连续的范围之内
-- 查询年龄不是12 18 34岁的姓名和年龄
select name, age from students where age not in(12, 18, 34);
5.匹配空/非空(空判断): is null, is not null
1.空(is null)
-- 查询身高为空的信息
select * from students where height is null;
2.非空(is not null)
-- 查询身高不为空的信息
select * from students where height is not null;
4.模糊查询(like/rlike/regexp)
like
-- %匹配0到多个字符,_匹配单个字符
-- 查询姓名中以小开始的名字
select name from students where name like "小%";
-- 查询名字中有小的名字
select name from students where name like "%小%";
-- 查询有2个字的名字
select name from students where name like "__";
-- 查询至少有2个字的名字
select name from students where name like "__%";
正则rlike
-- 查询以周开始的姓名
select name from students where name rlike "^周.*";
-- 查询以周开始以伦结尾的名字
select name from students where name rlike "^周.*伦$";
正则regexp
pass
5.分组(group by)
1.语法概述: group by之后的字段必须为select之后的字段名,如果select之后的字段没有在group by语句之后则必须要对该字段进行聚合处理
2.执行过程: 先分组(此时未去重),再聚合,最后去重
示例:
-- 按性别分组,查询所有的性别
select gender from students group by gender;
-- 计算每种性别的人数
select gender, count(*) from students group by gender;
-- 计算男性的人数
select gender, count(*) from students where gender="男" group by gender;
3.显示分组集合(group_concat)
语法概述: group_concat(字段名)可以作为一个输出字段使用表示分组之后根据分组结果使用group_concat()来放置每一组的某个字段值的集合
示例:
-- 查询同种性别中的姓名
select gender, group_concat(name) from students group by gender;
select gender, group_concat(name, "-", age) from students group by gender;
4.显示当前列所有记录总和(with rollup)
-- 按性别分组查询所有的性别对应分布人数和总人数
select gender, count(*) from students group by gender with rollup;
6.聚合函数(count/max/min/avg/round)
1.总数(count)
字段值NULL不会被统计
-- 查询男性有多少人,女性有多少人
select gender, count(*) from students where gender in ("男", "女") group by gender;
2.最大/最小(max/min)
-- 查询最大的年龄
select max(age) as 年龄 from students;
-- 查询女性最矮身高
select min(height) as 身高 from students where gender=2;
3.求和(sum)
-- 计算所有人的年龄总和
select sum(age) from students;
4.平均值(avg)
-- 计算平均年龄
select avg(age) from students;
select sum(age)/count(*) from students;
5.四舍五入(round)
-- 计算所有人的平均年龄保留2位小数
select round(avg(age), 2) from students;
-- 计算男性的平均身高保留2位小数
select round(sum(height)/count(height), 2) from students where gender=1;
select round(avg(height), 2) from students where gender=1;
7.筛选(having)
语法概述
having是对查询结果的进一步筛选,having语句通常与group by语句联合使用,用来过滤有group by语句返回的记录集
having语句的存在弥补了where条件子句不能与聚合函数联合联合使用的不足,where操作的是表中实际存在的字段,having操作的是聚合函数生成的显示列
示例:
-- 查询每种性别的平均年龄超过30岁的性别,姓名集合和性别组的平均年龄值 having avg(age) > 30
select gender, group_concat(name) from students group by gender having avg(age) > 30;
-- 查询每种性别中人数多于2个的信息
select gender, group_concat(name) from students group by gender having count(*) > 2;
8.排序(order by)
语法概述
asc: 默认缺省按升序排序,从小到大
desc: 降序,从大到小
示例:
-- 查看年龄在18到34岁之间的男性,按年龄从小到大排序
select * from students where gender="男" and (age between 18 and 34) order by age;
-- 查询年龄在18到34岁之间的女性,按年龄从大到小排序
select * from students where gender=2 and (age between 18 and 34) order by age desc;
-- 查询年龄在18到34岁之间的女性,按身高从高到底,身高相同按年龄从小到大排序
select * from students where gender=2 and (age between 18 and 34) order by height desc, age asc;
-- 按年龄从小到大身高从高到矮排序
select * from students order by age, height desc;
9.分页(limit)
语法概述
limit永远放在SQL语句的最后,限制显示查询记录的个数
limit n: 显示n条记录
limit m, n: 从第m+1条开始显示n条记录,m的值是从0开始计数的
limit (m-1)*n, n: 第m个页面,每页显示n条记录
示例:
-- 查询前5条记录
select * from students limit 5;
-- 查询id [6, 10]的记录
select * from students limit 5, 5;
-- 每页显示2个,第一个页面
select * from students limit 0, 2;
-- 每页显示2个,第二个页面
select * from students limit 2, 2;
-- 每页显示2个,第三个页面
select * from students limit 4, 2;
-- 每页显示2个,第四个页面
select * from students limit 6, 2; -- limit(第m页-1)*每页个数n, 每页显示个数n
-- 每页显示2个,显示第六页信息,按年龄从小到大排序
select * from students order by age limit 10, 2;
10.查询表记录时可以做数学运算(+ - * / %)
运算符: + - * / %
-- 查询时以米显示身高,保留2位小数
select name, round(height/100, 2) from students;
6.表记录-查询记录(连接/自关联/子查询/多表查询)
1.内连接(inner join on)
语法概述
从表中删除与其他被连接的表中没有匹配到的行,查询的结果为两个表匹配到的数据
select 字段名列表 from 表1 inner join 表2 on 条件 inner join 表3 on 条件;
示例:
-- 查询有能够对应班级的学生及班级信息
select * from students inner join classes on students.cls_id=classes.id;
-- 查询姓名和班级
select students.name, classes.name from students inner join classes on students.cls_id=classes.id;
-- 给数据表起别名简化SQL语句查询姓名和班级
select s.name, c.name as class from students as s inner join classes as c on s.cls_id=c.id;
-- 查询有对应班级的学生信息及对应班级
select s.*, c.name as class from students as s inner join classes as c on s.cls_id=c.id;
2.外连接-左/右连接(left/right join on)
语法概述
左连接查询: 查询的结果为两个表匹配到的数据,左表特有的数据,对于右表中不存在的数据使用null填充
右连接查询: 查询的结果为两个表匹配到的数据,右表特有的数据,对于左表中不存在的数据使用null填充
select 字段名列表 from 表1 left join 表2 on 条件;
select 字段名列表 from 表1 right join 表2 on 条件;
示例:
-- 查询每位学生对于的班级信息
select s.name, c.name from students as s left join classes as c on s.cls_id=c.id;
-- 查询没有对应班级的学生信息
select s.*, c.name from students as s left join classes as c on s.cls_id=c.id having c.name is null;
-- 查询每个班级中的学生集合
select c.name, group_concat(s.name) from students as s right join classes as c on s.cls_id=c.id group by c.name;
3.自关联(inner join on)
语法概述: 表中的某一列关联了这个表中的另外一列,必须给表起别名才能关联
示例:
-- 查询id号等于班级号且性别为女的学生信息
select distinct s.* from students as s inner join students as c on s.id=c.cls_id having s.gender=2;
4.子查询(嵌套查询)
语法概述
把内层的查询结果作为外层的查询条件,主要查询的对象为第一条select语句,在一个select语句中嵌入了另一个select语句,那么背嵌入的select语句称之为子查询语句
语法: 主查询 where 条件 in (列子查询) -- in 范围 是子查询中特定关键字的使用
1.标量子查询: 子查询返回的结果是一个数据(一行一列)
示例:
-- 查询最高的男性信息
select * from students where height = (select max(height) from students);
2. 列级子查询: 返回的结果是一列(一列多行)
示例:
-- 查询学生的班级号能够对应的学生信息
select * from students where cls_id in (select id from classes);
3.行级子查询: 返回结果是一行(一行多列),行元素是将多个字段合成一行元素,在行级子查询中会使用到行元素
示例:
-- 查询班级年龄最大身高最高的学生
select * from students where (height, age) = (select max(height), max(age) from students);
5.多表查询
1.笛卡尔积: select 字段名列表 from 表名列表;
示例: select students.id, classes.id from students, classes;
2.多表查询在效果上等同于内连接(inner join on)
语法: select 字段名列表 from 表名列表 where 条件;
示例: select students.id, classes.id from students, classes where students.id=classes.id;
6.数据导入/导出/复制
1.Linux平台下导入/导出数据
1.数据导入
语法
load data infile "文件名"
into table 表名
fields terminated by "分隔符"
lines terminated by " "
示例:
1.在数据库中创建对应的表
create table userinfo(
username char(20),
password char(1),
uid int,
gid int,
comment varchar(50),
homedir varchar(50),
shell varchar(50)
);
2.将要导入的文件拷贝到数据库的默认搜索路径中
1.查看数据库的默认搜索路径
show variables like "secure_file_priv";
-- Linux下为 /var/lib/mysql-files
-- Windows下为 D:Program FilesMySQLlibmysql-files
2.Windows下没有默认路径时手动设置方法
1.找到配置文件my.ini
2.在[mysqld]节点下添加一条记录secure_file_priv=D:Program FilesMySQLlibmysql-files
3.Linux下没有默认路径时设置方法
1.用vi或vim打开/etc/mysql/my.conf
2.在[mysqld]节点下添加/var/lib/mysql-files
4.Linux命令行下拷贝文件
suod cp /etc/passwd /var/lib/mysql-files/
3.执行数据导入语句
load data infile "/var/lib/mysql-files/passwd"
into table userinfo
fileds terminated by ":"
lines terminated by " ";
2.数据导出
语法
导出的内容有SQL查询语句决定,执行导出命令时路径必须指定对应的数据库搜索路劲
select 显示字段 from 表名
into outfile "文件名"
fields terminated by "分隔符"
lines terminated by " ";
示例:
把userinfo表中的username,password,uid导出到文件user.txt
select username, password, uid from userinfo
into outfile "/var/lib/mysql-files/user.txt"
fields terminated by ","
lines terminated by " ";
2.Windows平台下导出/导入数据
1.数据准备
create database windb default charset=utf8;
use windb
create table t2(
id int,
name varchar(20)
);
insert into t2 values(1, "Coco");
insert into t2 values(2, "Angels");
2.数据导出
select * from t2 limit 2
into outfile "D:/Program Files/MySQL/lib/mysql-files/t2.txt"
fields terminated by ","
lines terminated by " ";
3.数据导入
load data infile "D:/Program Files/MySQL/lib/mysql-files/t2.txt"
into table t2
fields terminated by ","
lines terminated by " ";
3.表的复制
语法概述: 复制表的时候不会把原有表的key属性复制过来
复制表结构和数据: create table 表名 select 查询命令;
仅复制表结构: create table 表名 select 查询命令 where false;
示例:
create table t3 select * from t2;
create table t4 select * from t2 where false;
7.数据备份/恢复
1.数据备份
1.语法概述
Windows不指定路径默认备份到C:UsersAdministrator目录下
语法(命令模式下): mysqldump -p 源库名 > 路径/xxx.sql
示例(Windows平台):
-- 备份indexdb数据库
mysqldump -uroot -p indexdb > D:indexdb.sql
2.源库名的表示方式
1.可选参数
-- all-databases 备份所有库
库名 备份单个库
-B 库1 库2 备份多个库
库名 表1 表2 备份指定库的指定表
2.示例(Linux平台):
--备份所有库all_mysql.sql,放到用户主目录下的mydata目录中
mysqldump -uroot -paptx4869 --all-databases > ~/mydata/all_mysql.sql
--备份db2库中的sheng,city,xian三张表db2scx.sql
mysqldump -uroot -paptx4869 db2 sheng city xian > ~/mydata/db2scx.sql
--备份MOSHOU和db2库,MSdb2.sql
mysqldump -uroot -paptx4869 -B MOSHOU db2 > ~/mydata/MSdb2.sql
2.数据恢复
1.语法(命令模式下): mysql -u用户名 -p 目标库名 < 路径/xxx.sql
示例(Windows平台):
1.先备份库: mysqldump -uroot -p indexdb > D:indexdb.sql
2.删除原有的indexdb库(进入数据库下): drop database indexdb;
3.先创建一个空库: create database indexdb default charset=utf8;
4.执行恢复命令(命令模式下): mysql -uroot -p indexdb < D:indexdb.sql
2.从所有库的备份文件恢复某一个库(-- one-database)
1.语法概述
恢复库时库中新增的表不会删除,恢复时必须先创建空库
mysql -uroot -p --one-database 目标库名 < all_mysql.sql
2.示例:
mysql -uroot -paptx4869 --one-database db2 < all_mysql.sql
8.视图(视图的用途就是查询)
语法概述
视图是一条select语句执行后的结果集,对若干张基本表的引用,是查询语句执行的结果即一张虚拟的表
1.定义视图语法(建议用v_开头)
语法: create view 视图名称 as select 查询命令;
示例: create view v_t5_info as select t2.id, t3.name from t2 left join t3 on t2.id=t3.id;
2.查看视图语法: show tables;
3.使用视图语法: select * from 视图名称;
4.删除视图语法: drop view 视图名称;
9.事务
1.定义: 一件事从发生到结束的整个过程,这些操作要么都执行要么都不执行是一个不可分割的工作单位
2.事务特性
1.原子性(atomicity): 一个事务必须被视为一个不可分割的最小工作单位,整个事务中的所有操作要么全部提交成功要么全部失败回滚,对一个事务来说不可能只执行其中的一部分操作
2.一致性(consistency): 数据库总是从一个一致性的状态转换到另一个一致性的状态,一致性确保了即使在执行多条语句之间时系统崩溃因为事务最终没有提及所以事务中所作的修改也不会保持到数据库中
3.隔离性(isolation): 一个事务所作的修改在最终提交前对其他事务是不可见的,例如开启事务后A给B转账200元, A账户扣减200, B账号开始执行增加200, 则其看到A帐户的余额并没有被减去200元
4.持久性(durability): 一旦事务提交,则其所作的所有修改会永久保存到数据库,此时即使系统崩溃修改的数据也不会丢失
3.事务特性确作用
保数据的一致性,mysql中默认SQL语句会自动commit到数据库
查看事务语法: show variables like "autocommit";
4.事务应用
概述: 事务回滚rollback只针对于表记录的操作(增删改),对创建库,创建表的操作无效
1.开始事务: begin; 或 start transaction;
2.提交事务: commit;
3.回滚事务: rollback;
示例:
1.背景
你：建行卡
你朋友：工商卡
你在建行的自动提款机给你朋友工商卡转5000元
2. 转账中
1.先到建行的数据库把你的余额 -5000
2.再到工行的数据库把你朋友的余额 +5000
3.commit; 转账成功 rollback; 回滚,转账失败
3.过程
表1 CCB
create table CCB(
name varchar(20),
money int
);
insert into CCB values("Zhuanqian",10000);
表2 ICBC
create table ICBC(
name varchar(20),
money int
);
insert into ICBC values("Shouqian",4000);
开始转账
start transaction;
update CCB set money=5000 where name="Zhuanqian";
update ICBC set money= 断电了,宕机了...;
rollback;
10.索引
1.索引概述
对数据库中表的一列或者多列值进行排序的一种结构(MySQL中索引引用Btree算法),如果指定的字段是字符串,需要指定长度,建议长度与定义字段时的长度一致,字段类型不是字符串可以不填写长度部分
分类: 普通索引,唯一索引,主键索引,外键索引
优点: 可以加快数据的检索速度
缺点: 当对表中的数据进行添加,修改,删除的时候索引需要动态维护,降低了数据的维护速度,占用了物理存储空间
2.索引性能分析示例
1.数据准备(运行Python脚本)
import pymysql # 导入pymysql模块

# 创建connection连接
db = pymysql.connect("localhost", "root", "aptx4869")
# 获取游标对象
cursor = db.cursor()
# 执行SQL语句,创建库,创建表
cursor.execute("create database indexdb;")
cursor.execute("use indexdb;")
cursor.execute("create table t1(id int, name char(20));")
n = 1
name = "Lucy"
while n <= 1000000:
cursor.execute("insert into t1 value(‘%s‘, ‘%s‘)" % (n, name + str(n)))
n += 1
db.commit() # 提交
cursor.close() # 关闭Cursor对象
db.close() # 关闭Connection对象
2.开启性能分析
-- 查看性能分析是否开启
show variables like "%profiling%";
-- 设置性能分析为开启状态(ON/1/true)
set profiling=1;
3.执行查询语句: select name from t1 where name="Lucy99999";
4.查看性能分析结果: show Profiles;
5.在name字段创建索引: create index name on t1(name(20));
6.执行查询语句: select name from t1 where name="Lucy99999";
7.查看性能分析结果: show Profiles;
8.关闭性能分析: set profiling=0;
3.普通索引(index)
1.使用规则
1.一个表中可以有多个index字段
2.字段值可以重复,也可以为NULL值
3.通常把做查询条件的字段设置为index字段
4.index字段的KEY标志位: MUL
2.创建index字段
1.创建表时创建index字段
create table t4(
id int,
name varchar(20),
age tinyint,
index(id),
index(name(20))
);
2.在已有表中创建index字段
语法概述
如果指定字段是字符串需要指定长度,建议长度与定义字段时的长度一致,字段类型不是字符串可以不填写长度部分,索引名一般和字段名一样
create index 索引名称 on 表名(字段名称(长度));
示例: create index age on t4(age);
3.查看普通索引
语法概述
查看KEY标志为MUL
desc 表名;
show index from 表名;
show index from 表名G;
示例:
desc t4;
show index from t4;
show index from t4G;
4.删除普通索引
删除普通索引只能一个一个删除
语法: drop index 索引名 on 表名;
示例: drop index age on t4;
4.唯一索引(unique)
1.使用规则
1.一个表中可以有多个unique字段
2.unique字段的值不允许重复,可以为空值(NULL)
3.unique的KEY标志是UNI
2.创建unique字段
1.创建表时创建unique字段
create table t5(
id int,
name varchar(20),
age tinyint,
unique(id),
unique(name(20))
);
2.在已有标志创建unique字段
语法概述
如果指定的字段是字符串需要指定长度,建议长度与定义字段时的长度一致,字段类型不是字符串可以不填写疮毒部分,索引名一般和字段名一样
create unique index 索引名 on 表名(字段名(长度));
示例: create unique index age on t5(age);
3.查看唯一索引
语法概述
查看KEY标志为UNI
desc 表名;
show index from 表名;
show index from 表名G;
示例:
desc t5;
show index from t5;
show index from t5G;
4.删除唯一索引
删除唯一索引只能一个一个的删除
语法: drop index 索引名 on 表名;
示例: drop index age on t5;
5.主键索引(primary key)
1.使用规则
1.一个表只能有一个主键字段
2.对应字段不允许重复,且不能为空值NULL
3.主键字段的KYE标志为PRI
4.把表中能够唯一识别的一条记录的字段设置为主键,通常把表中记录编号的字段设置为主键
5.设置主键一般都会添加自增长属性auto_increment
2.创建主键(PRI)
1.创建表时创建primary key
语法: 字段名 数据类型 primary key auto_increment
示例:
create table t6(
id int primary key auto_increment,
name varchar(20),
age tinyint
);
2.在已有表中添加主键
语法:
alter table 表名 add primary key(字段名);
alter table 表名 modify 字段名 类型 auto_increment;
示例:
alter table t6 add primary key(id);
alter table t6 modify id int auto_increment;
3.查看主键索引
语法概述
查看KEY标志为PRI
desc 表名;
show index from 表名;
show index from 表名G;
示例:
desc t6;
show index from t6;
show index from t6G;
4.删除主键索引
1.先删除自增长属性(modify)
语法: alter table 表名 modify 字段名 数据类型及约束;
示例: alter table t6 modify id int;
2.删除主键
语法: alter table 表名 drop primary key;
示例: alter table t6 drop primary key;
6.外键索引
1.使用规则
让当前表字段值在另外一个表的范围内选择,两张表被参考字段和参考字段数据类型要一致,被参考字段必须是key的一种,通常是primary key
foreign key(参考字段名)
references 被参考表名(被参考字段名)
on delete 级联动作
on update 级联动作
2.创建外键
1.创建表时创建外键
-- 主表
create table t7(
id int primary key,
name varchar(20),
class varchar(20),
money int
);
-- 从表(创建时添加外键索引)
create table t8(
stu_id int,
name varchar(20),
money int,
foreign key(stu_id)
references t7(id)
on delete cascade
on update cascade
);
2.在已有表中添加外键
语法概述
会受到表中原有数据的限制
alter table 表名 add foreign key(参考字段名)
references 被参考表名(被参考字段名)
on delete 级联动作
on update 级联动作;
示例:
alter table t8 add foreign key(stu_id)
references t7(id)
on delete cascade
on update cascade;
3.查看外键索引
语法: show create table 表名;
示例:
show create table t8;
返回如下结果,其中t8_ibfk_1即为外键名
| t8 | CREATE TABLE `t8` (
`stu_id` int(11) DEFAULT NULL,
`name` varchar(20) DEFAULT NULL,
`money` int(11) DEFAULT NULL,
KEY `stu_id` (`stu_id`),
CONSTRAINT `t8_ibfk_1` FOREIGN KEY (`stu_id`) REFERENCES `t7` (`id`) ON DELETE
CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8 |
4.删除外键
语法: alter table 表名 drop foreign key 外键名;
示例: alter table t8 drop foreign key t8_ibfk_1;
5.级联动作
1.数据级联更新(cascade)
当主表删除记录时,从表中被参考字段的值也会删除
当主表更新记录时,从表中被参考字段的值也会更新
on delete cascade
on update cascade
2.默认检查外键限制(restrice)
当删除主表记录时,如果从表中有相关记录则不允许主表删除
当更新主表记录时,如果从表中有相关记录则不允许主表更新
on delete restrict
on update restrict
3.设置空值(set null)
当主表删除记录时,从表相关记录的参考字段值自动设置为UNLL
当主表更新记录时,从表相关记录的参考字段值自动设置为NULL
on delete set null
on update set null
4.检查外键限制(action 功能同restrict)
当删除主表记录时,如果从表中有相关记录则不允许主表删除
当更新主表记录时,如果从表中有相关记录则不允许主表更新
on delete action
on update action
11.账户管理
1.开启MySQL远程连接
1.获取root权限: sudo -i
2.移动到配置文件所在路径: cd /etc/mysql.conf.d/
3.编辑配置文件
vi mysqld.cnf 或 vim mysqld.cnf
#bind_address = 127.0.0.1 -- 在此行前加注释,默认没有注释
4.重启mysql服务
/etc/init.d/mysql restart
或 service mysql restart
5.远程连接异常原因
1.网络不通通过ping命令检查: ping www.baidu.com -t
2.查看数据库是否配置了bind_address参数
本地登录数据库查看my.cnf文件和数据库当前参数,如果设置了bind_address=127.0.0.1那么只能在本地登录
查看语法: show variables like ‘bind_address‘;
示例:
mysql> show variables like ‘bind_address‘;
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| bind_address | * |
+---------------+-------+
3.查看数据库是否设置了skip_networking参数
如果设置了该参数,那么只能本地登录mysql数据库
查看语法: show variables like ‘skip_networking‘;
示例:
mysql> show variables like ‘skip_networking‘;
+-----------------+-------+
| Variable_name | Value |
+-----------------+-------+
| skip_networking | OFF |
+-----------------+-------+
4.端口指定是否正确: port=3306
2.添加授权用户
1.使用root用户连接到服务器: mysql -uroot -paptx4869
2.添加新的授权用户
语法: create user ‘用户名‘@‘IP地址‘ identified by ‘密码‘;
示例: create user ‘Coco‘@‘%‘ identified by ‘123456‘;
IP地址的表示方式
%: 表示用户可以从任何地址连接到服务器
localhost: 表示用户只能从本地连接
指定一个IP: 表示用户只能从此IP连接到服务器
3.给用户授权
语法: grant 权限列表 on 库.表 to ‘用户名‘@‘IP地址‘ with grant option;
示例: grant all privileges on *.* to ‘Coco‘@‘%‘ with grant option;
所有用户及权限信息会写入到mysql库下的user表, user和host两个字段
权限列表: select, update, delete, insert, alter, drop, create ...,如果分配所有权限可以使用all privileges
库.表: *.*表示所有库的所有表
示例:
-- 添加一个授权用户monkey所有人都可以连接,只对indexdb库有查询权限
create user ‘monkey‘@‘%‘ identified by ‘123456‘; -- 添加授权用户 monkey
grant select on indexdb.* to ‘monkey‘@‘%‘ with grant option; -- 给monkey用户授权
mysql -umonkey -p123456 -- 登录mysql验证
4.查看用户
1.查看user表结构
所有的用户及权限信息都存储在mysql数据库的user表中
use mysql;
desc user;
Host: 表示允许访问的主机
User: 表示用户名
authentication_string: 表示密码,密码是加密后的值
2.查看所有用户
select Host,User,authentication_string from user;
3.查看用户有哪些权限
语法: show grants for ‘用户名‘@‘IP地址‘;
示例: show grants for ‘root‘@‘localhost‘;
4.修改密码
使用root登录,修改mysql数据库的user表
语法:
alter user ‘用户名‘@‘登录主机‘ identified by ‘密码‘;
或 set password for ‘用户名‘@‘登录主机‘ = ‘123456‘;
示例:
alter user ‘root‘@‘localhost‘ identified by ‘123456‘;
set password for ‘root‘@‘localhost‘=‘aptx4869‘;
修改完成后刷新权限: flush privileges;
5.删除授权用户
方法一:
语法: drop user ‘用户名‘@‘IP地址‘;
示例: drop user "Coco"@"%";
方法二:
语法: delete from user where user=‘用户名‘;
示例: delete from user where user=‘monkey‘;
刷新权限(不可省略): flush privileges;
3.忘记root密码
Windows平台
1.停止mysql服务: net stop mysql
2.进入无密码模式: mysqld --shared-memory --skip-grant-tables
3.无密码模式的命令提示符窗口处于锁定状态，我们重新以管理员权限打开新的命令提示符窗口
4.进入数据库(无需输入密码): mysql -uroot -p
5.切换到mysql数据库: use mysql
6.将root密码置空: update user set authentication_string=‘‘ where user=‘root‘;
7.从新设置root密码: alter user ‘root‘@‘localhost‘ identified by ‘新秘密‘;
8.如果设置新密码失败则关闭cmd命令行,从新开启一个cmd命令行,重复4,5,6,7操作
9.刷新权限: flush privileges;
10.退出cmd命令行,退出无密码模式命令行,重启mysql服务: net start mysql
12.存储引擎
1.定义: 是用来处理表的处理器
2.存储引擎的基本操作
1.查看已有表的存储引擎(ENGINE=)
语法: show create table 表名;
示例:
mysql> show create table t2G;
*************************** 1. row ***************************
Table: t2
Create Table: CREATE TABLE `t2` (
`id` int(11) DEFAULT NULL,
`name` varchar(20) DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8
1 row in set (0.00 sec)
2.创建表时指定存储引擎
语法: create table 表名(...)engine=myisam;
示例:
use indexdb;
create table t9(
id int primary key not null auto_increment,
name varchar(20)
)engine=myisam;
3.查看所有的存储引擎: show engines;
4.修改表的默认存储引擎
sudo -i
cd /etc/mysql/mysql.conf.d/
vim mysqld.conf
[mysqld]
default-storage-engine= = myisam
/etc/init.d/mysql reatart
3.工作中常用的存储引擎及特点
innodb引擎
1.共享表空间
表名.frm: 表结构
表名.ibd: 表记录&索引信息
2.支持行级锁
myisam引擎
1.独享表空间
表名.frm: 表结构
表名.myd: 表记录
表名.myi: 索引信息
2.支持表级锁
memory引擎
1.表记录存储在内存中
表名.frm: 表结构
2.服务器重启之后表结构在,表记录都消失
存储引擎选择
1.执行查询操作多的表使用myisam存储引擎(innodb浪费资源)
2.执行写操作比较多的表使用innodb存储引擎
4.锁粒度(行级锁&表级锁)
加锁目的: 解决客户端并发访问的冲突,锁在操作完成后会自动释放锁
表级锁: 当某用户修改数据时,会获取写锁,此时会锁住整张表,其他用户都不能读和写,myisam
行级锁: 当某用户修改某几行数据,会获取写锁,此时只是锁住那几行,那几行其他用户不能读和写;其他行没有影响,但是管理锁会消耗资源,innodb
5.锁类型
读锁(select)共享锁:
加读锁之后不能更改表中的内容,但是可以进行查询
读锁是共享的,它不会阻塞其他读锁,读读不互斥
写锁(insert,update,delete)互斥锁(排他锁):
允许事务删除或更新一行数据,它会阻塞其他读锁和写锁,读写互斥,写写互斥
13.MySQL调优
1.选择合适的存储引擎
1.经常用来读的表使用myisam存储引擎
2.其余的表用innodb存储引擎
2.SQL语句调优(尽量避免全表扫描)
1.在select where order by常涉及到的字段上建立索引
2.在while子句中不使用!=否则将会放弃索引进行全表扫描
3.尽量避免使用NULL值判断,否则会全表扫描
示例: select id from t1 where number is null;
优化: 在number字段设置默认值0
4.尽量避免or来连接条件,否则导致全表扫描
示例: select id from t1 where id=10 or id=20;
优化:
select id from t1 where id=10
union all
select id from id from t1 where id=20;
union操作符用于合并两个或多个 SELECT 语句的结果集选取不同的值
union all命令会列出所有的值
5.模糊查询尽量避免使用前置%否则导致全表扫描
示例: select id from t1 where name like "a%";
6.尽量避免in和not in否则导致全表扫描
示例: select id from t1 where id in(1, 2, 3);
优化: select id from t1 where id between 1 and 3;
7.尽量避免使用select * ...要使用具体字段列表代替*,不要返回用不到的字段
14.MySQL主从
1.主从定义
主从同步使得数据可以从一个数据库服务器复制到其他服务器上,在复制数据时一个服务器充当主服务器(master)其余服务器充当从服务器(slave)
因为复制是异步进行的所以从服务器不需要一直连接着主服务器,从服务器甚至可以通过拨号断断续续的连接主服务器,通过配置文件可以指定复制所有的数据库,某个数据库,甚至是某个数据库上的某个表
2.主从优点
1.通过增加从服务器来提高数据库性能,在主服务器上执行写入和更新,在从服务器上向外提供读功能,可以动态的调整从服务器的数量从而调整整个数据库的性能
2.提高数据安全,因为数据已复制到从服务器,从服务器可以终止复制进程所有可以在从服务器上备份而不破坏主服务器相应数据
3.在主服务器上生成实时数据,而在从服务器上分析这些数据从而提高主服务器的性能
3.同步机制
1.MySQL服务器之间的主从同步是基于二进制日志机制,至服务器使用二进制日志来记录数据库的变动情况,从服务器通过读取和执行该日志文件来保持和主服务器的数据一致
2.在使用二进制日志时,主服务器的所有操作都会被记录下来,然后从服务器会接收该日志的一个副本,从服务器可以指定该日志中的哪一类事件(如插入或更新数据),默认会执行日志中的所有语句
3.每一个从服务器都会记录关于二进制日志的信息有文件名和已处理过的语句,这样意味着不同的从服务器可以分别执行同一个二进制日志的不同部分,并且从服务器可以随时连接或者中断和主服务器的连接
4.主服务器和每一个从服务器都必须配置一个唯一的ID号(在my.cnf文件的[mysqld]模块下的一个server-id配置项),每一个从服务器还需要通过change master to语句来配置它要连接的主服务器的IP地址,日志文件名称和该日志里面的位置(这些信息存储在主服务器的数据库里)
4.配置主从同步的基本步骤
1.在主服务器上必须开启二进制日志机制和配置一个独立的ID
2.在每一个从服务器上配置一个唯一的ID,创建一个用来专门复制主服务器数据库的账号
3.在开始复制前在主服务器上记录二进制文件的位置信息
4.如果在开始复制前数据库中已有数据,就必须先创建一个数据快照(可以使用mysqldump导出数据库或者直接复制数据文件)
5.配置从服务器要连接的主服务器的IP地址和登录授权及二进制日志文件名和位置
5.主从示例(Ubuntu中MySQL作为主服务器Windows中的MySQL作为从服务器)
1.在主服务器Ubuntu上进行备份
mysqldump -uroot -paptx4869 --all-databases --lock-all-tables > ~/master_db.sql
语法说明:
-u: 用户名
-p: 密码
--all-databases: 导出所有数据库
--lock-all-tables: 执行操作时锁住所有表防止操作时数据被修改
~/master_db.sql: 导出的备份数据(sql文件)位置任意指定
2.在从服务器Windows上进行数据还原
将从服务器Ubuntu中导出的文件复制到从服务器Windows中,可以将sql文件放在sql命令所在的文件夹中方便还原
mysql -uroot -paptx4869 < master_db.sql
3.配置主服务器master
编辑配置mysqld的配置文件,设置log_bin和server-id
sudo vim /etc/mysql/mysql.conf.d/mysqld.cnf
插入两行:
server-id = 1
log_bin = /var/log/mysql/mysql-bin.log
重启mysql服务: sudo server mysql restart
4.登入主服务器Ubuntu中的mysql创建用于从服务器同步数据使用的账号
mysql -uroot -paptx4869
grant replication slave on *.* to ‘slave‘@‘%‘ identified by ‘slave‘;
flush privileges;
5.获取主服务器(Ubuntu)的二进制日志信息
语法概述
show master status;
File: 日志文件的名字
Position: 使用的文件位置
mysql> show master statusG;
*************************** 1. row ***************************
File: binlog.000262
Position: 155
Binlog_Do_DB:
Binlog_Ignore_DB:
Executed_Gtid_Set:
1 row in set (0.00 sec)
6.修改Windows中MySQL的配置文件
1.编辑my.ini文件,将server-id修改为2
2.重启mysql服务
先停止: net stop mysql
再启动: net start mysql
7.进入Windows中的mysql设置连接到master主服务器
change master to master_host=‘10.211.55.5‘,
master_user=‘slave‘, master_password=‘slave‘,
master_log_file=‘binlog.000262‘, master_log_pos=155;
-- master_host: 主服务器Ubuntu的IP地址
-- master_log_file: 主服务器查询出的日志文件名
-- master_log_pos: 主服务器查询出的日志文件位置
8.从服务器(Windows)上开启同步
start slave;
查看同步状态:
show slave statusG;
-- Slave_IO_Running: Yes
-- Slave_SQL_Running: Yes
-- 这两个属性表示同步正常
9.测试同步
在主服务器上创建爱你新的数据库: create database new_test;
查看从服务器上的数据库是否存在: show databases;
15.ER模型&ER图(待完善)
1.定义
ER模型即实体-关系模型
ER图即实体-关系图
2.三个概念
1.实体
2.属性
3.关系(实体之间的关系)
分类
一对一关系(1:1): 班级和班长
一对多关系(1:n): 公司和职工,班级和学生
多对多关系(m:n): 学生和课程
4.ER图的绘制
1.继续框代表实体,菱形框代表关系,椭圆形代表属性
16.Python与数据库交互
1.数据库准备:
-- 创建 "京东" 数据库
create database jing_dong charset=utf8;
-- 使用 "京东" 数据库
use jing_dong;
-- 创建 "商品分类" 表
create table goods_cates(
id int unsigned primary key auto_increment not null,
name varchar(40) not null
);
-- 向goods_cates表中插入数据
insert into goods_cates values(0,‘笔记本‘);
insert into goods_cates values(0,‘游戏本‘);
insert into goods_cates values(0,‘超极本‘);
insert into goods_cates values(0,‘平板电脑‘);
insert into goods_cates values(0,‘台式机‘);
insert into goods_cates values(0,‘服务器/工作站‘);
insert into goods_cates values(0,‘笔记本配件‘);
-- 创建 "商品品牌" 表
create table goods_brands (
id int unsigned primary key auto_increment not null,
name varchar(40) not null
);
-- 向goods_brands表中插入数据
insert into goods_brands values(0,‘华硕‘);
insert into goods_brands values(0,‘联想‘);
insert into goods_brands values(0,‘雷神‘);
insert into goods_brands values(0,‘索尼‘);
insert into goods_brands values(0,‘苹果‘);
insert into goods_brands values(0,‘戴尔‘);
insert into goods_brands values(0,‘宏碁‘);
insert into goods_brands values(0,‘ibm‘);
insert into goods_brands values(0,‘惠普‘);
-- 创建 "商品" 表
create table goods(
id int unsigned primary key auto_increment not null,
name varchar(40) default ‘‘,
price decimal(7,2),
cate_id int unsigned,
brand_id int unsigned,
is_show bit default 1,
is_saleoff bit default 0,
foreign key(cate_id) references goods_cates(id),
foreign key(brand_id) references goods_brands(id)
);
-- 向goods表中插入数据
insert into goods values(0,‘r510vc 15.6英寸笔记本‘,‘3399‘,‘1‘,‘1‘,default,default);
insert into goods values(0,‘y400n 14.0英寸笔记本电脑‘,‘4999‘,‘1‘,‘2‘,default,default);
insert into goods values(0,‘g150th 15.6英寸游戏本‘,‘8499‘,‘2‘,‘3‘,default,default);
insert into goods values(0,‘x550cc 15.6英寸笔记本‘,‘2799‘,‘1‘,‘1‘,default,default);
insert into goods values(0,‘x240 超极本‘,‘4880‘,‘3‘,‘2‘,default,default);
insert into goods values(0,‘u330p 13.3英寸超极本‘,‘4299‘,‘3‘,‘2‘,default,default);
insert into goods values(0,‘svp13226scb 触控超极本‘,‘7999‘,‘3‘,‘4‘,default,default);
insert into goods values(0,‘ipad mini 7.9英寸平板电脑‘,‘1998‘,‘4‘,‘5‘,default,default);
insert into goods values(0,‘ipad air 9.7英寸平板电脑‘,‘3388‘,‘4‘,‘5‘,default,default);
insert into goods values(0,‘ipad mini 配备 retina 显示屏‘,‘2788‘,‘4‘,‘5‘,default,default);
insert into goods values(0,‘ideacentre c340 20英寸一体电脑 ‘,‘3499‘,‘5‘,‘2‘,default,default);
insert into goods values(0,‘vostro 3800-r1206 台式电脑‘,‘2899‘,‘5‘,‘6‘,default,default);
insert into goods values(0,‘imac me086ch/a 21.5英寸一体电脑‘,‘9188‘,‘5‘,‘5‘,default,default);
insert into goods values(0,‘at7-7414lp 台式电脑 linux ）‘,‘3699‘,‘5‘,‘7‘,default,default);
insert into goods values(0,‘z220sff f4f06pa工作站‘,‘4288‘,‘6‘,‘9‘,default,default);
insert into goods values(0,‘poweredge ii服务器‘,‘5388‘,‘6‘,‘6‘,default,default);
insert into goods values(0,‘mac pro专业级台式电脑‘,‘28888‘,‘6‘,‘5‘,default,default);
insert into goods values(0,‘hmz-t3w 头戴显示设备‘,‘6999‘,‘7‘,‘4‘,default,default);
insert into goods values(0,‘商务双肩背包‘,‘99‘,‘7‘,‘4‘,default,default);
insert into goods values(0,‘x3250 m4机架式服务器‘,‘6888‘,‘6‘,‘8‘,default,default);
insert into goods values(0,‘商务双肩背包‘,‘99‘,‘7‘,‘4‘,default,default);
-- 创建 "顾客" 表
create table customer(
id int unsigned auto_increment primary key not null,
name varchar(30) not null,
addr varchar(100),
tel varchar(11) not null
);
-- 创建 "订单" 表
create table orders(
id int unsigned auto_increment primary key not null,
order_date_time datetime not null,
customer_id int unsigned,
foreign key(customer_id) references customer(id)
);
-- 创建 "订单详情" 表
create table order_detail(
id int unsigned auto_increment primary key not null,
order_id int unsigned not null,
goods_id int unsigned not null,
quantity tinyint unsigned not null,
foreign key(order_id) references orders(id),
foreign key(goods_id) references goods(id)
);
2.Python中操作MySQL步骤
1.创建connection建立数据库连接
2.获取cursor游标对象
3.执行查询/执行命令获取数据处理数据,使用游标对象的方法操作数据库
4.提交commit/回滚rollback,提交到数据库执行(表记录增删改)
5.关闭cursor游标对象
6.关闭connection数据库连接
3.数据库连接Connection对象
语法概述
用于创建数据库的连接,调用connect()方法创建对象
conn = connect(参数列表)
参数列表
host: 连接mysql主机如果本机是‘localhost‘
port: 连接的mysql主机端口,mysql服务默认端口是3306
database: 数据库名称
user: 连接的用户名
password: 连接的密码
charset: 通信采用的编码方式(推荐使用utf8)
对象方法
close(): 关闭连接
commit(): 提交
rollback(): 回滚
cursor(): 返回cursor对象用于执行SQL语句并获得返回结果
4.执行SQL语句Cursor对象
语法概述
用于执行SQL语句,调用connection对象的cursor()方法获取cursor对象
cs1 = conn.cursor()
对象属性
rowcount: 只读属性,表示最近一次execute()执行后受影响的行数
connection: 获取当前连接对象
对象方法
close(): 关闭游标对象
execute(operation[, parameters]): 执行SQL语句返回受影响的行数
fetchone(): 执行SQL语句时获取查询结果集的第一行数据,返回一个元祖
fetchmany(n): 执行SQL语句返回n条记录
fetchall(): 执行SQL语句获取结果集的所有行,一行构成一个元祖,再将这些元祖装入一个元祖中返回
5.示例(增删改)
from pymysql import *

def main():
# 创建Connection连接
conn = connect(host=‘localhost‘, port=3306, database=‘jing_dong‘, user=‘root‘, password=‘aptx4869‘, charset=‘utf8‘)
# 获取Cursor对象
cs1 = conn.cursor()

# 增加,执行insert语句添加一条记录并返回受影响的记录
count = cs1.execute(‘insert into goods_cates(name) values("硬盘")‘)
# 打印受影响的记录
print(count)

# 更新
count = cs1.execute(‘update goods_cates set name="机械硬盘" where name="硬盘"‘)
print(count)

# 删除
count = cs1.execute(‘delete from goods_cates where name="机械硬盘"‘)
print(count)

# 提交之前的操作
conn.commit()
# 关闭Cursor对象
cs1.close()
# 关闭Connection对象
conn.close()

if __name__ == ‘__main__‘:
main()
6.示例(查询)
from pymysql import *

def main():
# 创建Connection连接
conn = connect(host=‘localhost‘, port=3306, user=‘root‘, password=‘aptx4869‘, database=‘jing_dong‘, charset=‘utf8‘)
# 获取Cursor对象
cs1 = conn.cursor()
# 执行select语句返回受影响的行数
count = cs1.execute(‘select id,name from goods where id>=4;‘)
# 打印受影响的行数
print("查询到%d条记录" % count)
# 查询一行fetchone
for i in range(count):
# 获取查询的结果
result = cs1.fetchone()
# 打印查询的结果
print(result)
# 查询多行fetchall
result = cs1.fetchall()
print(result)
# 关闭Cursor对象
cs1.close()
# 关闭Connection连接
conn.close()

if __name__ == ‘__main__‘:
main()
7.参数化(防SQL注入):
from pymysql import *

def main():
find_name = input("请输入物品名称:")
# 创建Connection连接
conn = connect(host=‘localhost‘, port=3306,user=‘root‘, password=‘aptx4869‘, 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, ...]

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

if __name__ == ‘__main__‘:
main()