漫谈mysql
目录python
数据库mysql
1.1 数据库
1. 概念
用户认证mysql
- 注册：用户名不能重复
- 登录
只是经过文件操做，改变数据是很是繁琐的linux
解决对于多台机器或多个进程操做同一份数据咱们须要本身解决并发和安全问题比较麻烦ios
本身处理数据备份，容错措施正则表达式
c/s架构的操做数据文件的一个管理软件redis
- 解决并发问题
- 实现用更简单快速的方式完成数据的增删改查
- 提供一些容错、高可用的机制
- 权限的认证
数据操做算法
- 链接server
- 指令
专有名词sql
- 数据库管理系统(DBMS)：专门用来管理数据文件，帮助用户更简洁的操做数据的软件
- 数据(data)、文件
- 数据库(database, DB)：每个项目都有一个数据库
- 数据库管理员(DBA)
常见的数据库mongodb
关系型数据库数据库
- Relational Database Management System：(RDBMS)是指包括相互联系的逻辑组织和存取这些数据的一套程序 (数据库管理系统软件)。关系数据库管理系统就是管理关系数据库，并将数据逻辑组织的系统。
- sql server/ sqlite/ db2/ access/
- oracle：收费，比较严谨，安全性高（国企、事业单位银行、金融行业）
- mysql：开源（小公司互联网公司）
- 注意：sql语句通用
非关系型数据库(key:value结构)eg：快递单号（redis、mongodb、memcache）
在 WEB 应用方面，MySQL是最好的 RDBMS(关系数据库管理系统) 应用软件。
2. mysql的安装
- win，路径必须是全英文
- bin目录
- my.ini文件（文件名必须是这个）
# 客户端 [mysql] # 设置mysql客户端默认字符集 default-character-set=utf8 # server端 [mysqld] #设置3306端口 port = 3306 # 设置mysql的安装目录 basedir=C:\Program Files\mysql-5.6.39-winx64 # 设置mysql数据库的数据的存放目录 datadir=C:\Program Files\mysql-5.6.39-winx64\data # 容许最大链接数 max_connections=200 # 服务端使用的字符集默认为8比特编码的latin1字符集 character-set-server=utf8mb4 # 建立新表时将使用的默认存储引擎 default-storage-engine=INNODB
- 安装路径：不能有空格，不能有中文，不能带着转义特殊字符开头的文件夹名
- 安装以后发现配置有问题：再修改配置文件每每不能生效
- 卸载以后重装
- mysqld remove，把全部配置、PATH修改正确
- 重启计算机—清空注册表
- 从新安装：mysqld install
3. mysql的cs架构
# windows mysqld install net start mysql # server net stop mysql mysql -u'用户名' -p'密码' # 客户端，能够是python代码也能够是一个程序 # mysql.exe是一个客户端
# mac sudo mysql.server status sudo mysql.server start/stop/restart
3.1 mysql中的用户和权限
- 在安装数据库以后，有一个最高权限的用户root
- mysql server端的ip 用户名/密码
- Mysql -h192.168.12.87 -uroot -p123
Note1
- 能够链接网络上的某一个数据库
3.2 数据库中的概念
- 库、表、数据
- 描述事物的符号记录称为数据，如：一条数据data(一行数据)
- 表就至关于文件，表中的一条记录就至关于文件的一行内容，多条数据组成一个表
- 数据库即存放数据的仓库，多个表组成一个库
- 通常状况下：一个项目占用一个或以上个库
3.3 mysql的操做
sql语句(structure query language)
- SQL : 结构化查询语言(Structured Query Language)简称SQL(发音：/ˈes kjuː ˈel/ "S-Q-L")，是一种特殊目的的编程语言，是一种数据库查询和程序设计语言，用于存取数据以及查询、更新和管理关系数据库系统。
- SQL语言主要用于存取数据、查询数据、更新数据和管理关系数据库系统,SQLsu语言由IBM开发。SQL语言分为3种类型：
- DDL语句 数据库定义语言：数据库，表，视图，索引，存储规程
- DML语句 数据库操纵语言：插入数据insert，delete，update，alter
- DCL语句 数据库控制语言：建立用户。grant revoke 取消受权
# 查看当前用户
select user();
# 设置密码，password 表示密文存储
set password for root@localhost = password('123');
# 建立用户
create user '用户名'@'网段.%' identified by '密码';
# 查看用户状态，用户信息都存储在mysql中的user表中
select host,user from mysql.user;
# 查看当前库
show databases;
# 建立文件夹henry
create database henry；
# 查看指定用户权限
show grants for '用户名'(@'网段.%');
# 受权 * 表示全部
grant all(select/insert) on henry.* to '用户名'@'ip网段.%';
# 设置当即生效
flush privileges
# 建立帐号并受权,必须有密码
grant all on herny.* to 'henry'@'%' identified by '123';
#select, insert, update, delete, create, drop, index, alter, grant, references, reload, shutdown, process, file等14个权限
# 取消用户权限
revoke all on test.* from 'henry'@'%';
# 删除用户
delete from mysql.user where host='192.168.12.%' and user='test';
drop user 'test'@'192.168.12
# 修改指定用户密码
update mysql.user set password=password('新密码') where User='test' and Host='%';
- 库的操做
# 建立库 create database demo; # 查看库 show databases; # 删除库，demo drop database demo # 查看当前使用的库 select database(); # 切换库，到demo库下 use demo；
- 表操做(4)
# 建立表,char()默认一个字符 create table student(id int, name char(10)); # 查看当前文件夹中的表 show tables; # 删除表 drop table student; # 查看表结构 desc student; # 删除多个表 drop tables s2,s3,s4;
- 操做表中数据(4)
# 数据插入 insert into student values(1, 'henry'); # 数据查看 select * from student; # 修改数据，必须设置条件，肯定为一条数据data update 表 set 字段名=值 where id=2; # 删除数据 delete from 表 where id=1；
1.2 表的介绍
1. 存储引擎
- 选择如何存储和检索数据的这种灵活性是MySQL为何如此受欢迎的主要缘由。其它数据库系统(包括大多数商业选择)仅支持一种类型的数据存储。
- mysql5.6/5.7支持的存储引擎包括InnoDB、 MyISAM、 MEMORY、 CSV、 BLACKHOLE、 FEDERATED、 MRG_MYISAM、 ARCHIVE、 PERFORMANCE_SCHEMA。其中NDB和InnoDB提供事务安全表，其余存储引擎都是非事务安全表。
1.1 表的存储方式(3)
- 方式1：MyISAM
- mysql5.5- 默认存储方式
- 存储的文件个数：表结构、表数据、索引
- 不支持行级锁、事务和外键
- 方式2：InnoDB
- mysql5.6+ 默认存储方式
- 存储文件个数：表结构、表数据
- 支持事务：把多句操做，变成原子操做
- 支持外键：经过外键(有约束)在其余表(有约束)中查找信息
- 支持行级锁(默认)：脏数据（+表级锁），支持数据并发
- 方式3：MEMORY
- 存储在内存：表结构存储到硬盘中， 表数据存储到内存上
- 优点：增删改查速度快
- 劣势：重启数据消失、容量有限
1.2 存储引擎介绍
- InnoDB
- 用于事务处理应用程序，支持外键和行级锁。
- 若是应用对事物的完整性有比较高的要求，在并发条件下要求数据的一致性
- 数据操做除了插入和查询以外，还包括不少更新和删除操做，那么InnoDB存储引擎是比较合适的。
- InnoDB除了有效的下降由删除和更新致使的锁定，还能够确保事务的完整提交和回滚，对于相似计费系统或者财务系统等对数据准确要求性比较高的系统都是合适的选择。
- MyISAM
- 若是应用是以读操做和插入操做为主
- 只有不多的更新和删除操做，而且对事务的完整性、并发性要求不高，那么能够选择这个存储引擎。
- Memory
- 将全部的数据保存在内存中，在须要快速定位记录和其余相似数据的环境下，能够提供极快的访问。Memory的缺陷是对表的大小有限制，虽然数据库由于异常终止的话数据能够正常恢复，可是一旦数据库关闭，存储在内存中的数据都会丢失。
其余存储引擎
- InnoDB
- MySql 5.6 版本默认的存储引擎。InnoDB 是一个事务安全的存储引擎，它具有提交、回滚以及崩溃恢复的功能以保护用户数据。InnoDB 的行级别锁定以及 Oracle 风格的一致性无锁读提高了它的多用户并发数以及性能。InnoDB 将用户数据存储在汇集索引中以减小基于主键的普通查询所带来的 I/O 开销。为了保证数据的完整性，InnoDB 还支持外键约束。
- MyISAM
- MyISAM既不支持事务、也不支持外键、其优点是访问速度快，可是表级别的锁定限制了它在读写负载方面的性能，所以它常常应用于只读或者以读为主的数据场景。
- Memory
- 在内存中存储全部数据，应用于对非关键数据由快速查找的场景。Memory类型的表访问数据很是快，由于它的数据是存放在内存中的，而且默认使用HASH索引，可是一旦服务关闭，表中的数据就会丢失
- BLACKHOLE
- 黑洞存储引擎，相似于 Unix 的 /dev/null，Archive 只接收但却并不保存数据。对这种引擎的表的查询经常返回一个空集。这种表能够应用于 DML 语句须要发送到从服务器，但主服务器并不会保留这种数据的备份的主从配置中。
- CSV
- 它的表真的是以逗号分隔的文本文件。CSV 表容许你以 CSV 格式导入导出数据，以相同的读和写的格式和脚本和应用交互数据。因为 CSV 表没有索引，你最好是在普通操做中将数据放在 InnoDB 表里，只有在导入或导出阶段使用一下 CSV 表。
- NDB
- (又名 NDBCLUSTER)——这种集群数据引擎尤为适合于须要最高程度的正常运行时间和可用性的应用。注意：NDB 存储引擎在标准 MySql 5.6 版本里并不被支持。
- MySql 集群的版本有：基于 MySql 5.1 的 MySQL Cluster NDB 7.1；基于 MySql 5.5 的 MySQL Cluster NDB 7.2；基于 MySql 5.6 的 MySQL Cluster NDB 7.3。一样基于 MySql 5.6 的 MySQL Cluster NDB 7.4 目前正处于研发阶段。
- Merge
- 容许 MySql DBA 或开发者将一系列相同的 MyISAM 表进行分组，并把它们做为一个对象进行引用。适用于超大规模数据场景，如数据仓库。
- Federated
- 提供了从多个物理机上联接不一样的 MySql 服务器来建立一个逻辑数据库的能力。适用于分布式或者数据市场的场景。
- Example
- 这种存储引擎用以保存阐明如何开始写新的存储引擎的 MySql 源码的例子。它主要针对于有兴趣的开发人员。这种存储引擎就是一个啥事也不作的 "存根"。你可使用这种引擎建立表，可是你没法向其保存任何数据，也没法从它们检索任何索引。
1.3 查看mysql全部的配置
# 查看与存储引擎相关配置 show variables like '%engine%'; show variables like "default_storage_engine"; # 查看当前数据库支持的存储引擎 show engines \g show engines; # 修改已经存在表的存储引擎 alter table 表名 engine = innodb; # 查看与编码相关的配置 show variables like '%chara%'; # 查看 show variables like '%关键字%';
- 指定存储引擎
# 建立表 create table t1(id int, name char(10)) engine=innodb; # 查看表的结构，包括存储引擎和编码 \G 格式化输出，带 \G 不能使用分号 show create table t1 \G # 只查看表字段基础信息 describle t1; t1.frm frame 表结构 t1.ibd innoDB 存储引擎
# 指定engine为myisam create table t2(id int, name char(10)) engine=MyISAM; t2.frm 表结构 t2.MYD 数据 t2.MYI 索引
# 指定engine为memory create table t2(id int, name char(10)) engine=memory; t2. 数据
2. mysql数据类型
# 语法： create table 表名( 字段名1 类型[(宽度) 约束条件], 字段名2 类型[(宽度) 约束条件], 字段名3 类型[(宽度) 约束条件]); # 注意： 1. 在同一张表中，字段名是不能相同 2. 宽度和约束条件可选 3. 字段名和类型是必须的
- 数值：
- TINYINT(1byte)，SMALLINT(2byte)，MEDIUMINT(4byte)，INT(4byte)，BIGINT(8byte)
- 日期时间
- 字符
- ENUM和SET类型
2.1数值
- MySQL支持全部标准SQL数值数据类型。这些类型包括严格数值数据类型(INTEGER、 SMALLINT、 DECIMAL和NUMERIC)，以及近似数值数据类型(FLOAT、 REAL和DOUBLE PRECISION)。
- 关键字INT是INTEGER的同义词，关键字DEC是DECIMAL的同义词。
- MySQL支持的整数类型有TINYINT、MEDIUMINT和BIGINT。
- 对于小数的表示，MYSQL分为两种方式：浮点数和定点数。浮点数包括float(单精度)和double(双精度),而定点数只有decimal一种，在mysql中以字符串的形式存放，比浮点数更精确，适合用来表示货币等精度高的数据。
- BIT数据类型保存位字段值，而且支持MyISAM、MEMORY、InnoDB和BDB表。
- 整数(int)
# 建立无符号int型表 create table t3(id1 int, id2 int unsigned);
- 小数(float/double)
# 一共有5位，小数2位 float(5, 2)/ double(5, 2) # 建立表 create tables t4(f1 float(5,2), double(5,2)); # 不指定长度，单精度和双精度 create tables t4(f1 float, double); # decimal精度,默认存储（10，0）整数 create table t5(d1 decimal, d2 decimal(25, 20)); # decimal内部存储是按照字符串存的
Note2(4)
- 默认int类型有符号
- int类型数据范围不被宽度约束
- 5.6版只能约束数字的显示宽度，5.7不受限制
- 5.6版插入数据超过最大长度会默认显示最大值，5.7版直接会提示：Out of range value
2.2 时间和日期(5)
- date：年月日
- time：时分秒
- year：年份值
- datetime：年月日时分秒
- timestamp：年月日时分秒
- 1970-01-01 00:00:00/2038结束时间是第 2147483647 秒，北京时间 2038-1-19 11:14:07，格林尼治时间 2038年1月19日 凌晨 03:14:07
# 建立表
create table t6(d1 date, y year, ts timestamp);
insert into t6(now(), now(), now());
# 指定传y,datetime默认为更新时间
insert into t6(y) values(2019);
# 指定datetime更新方式
create table t6(d1 date, y year,
dt datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP);
# 可使用字符串，纯数字
# 5.7版本，插入参数不全，会报错，5.6版不会
2.3 字符串
- 字符串类型指CHAR、VARCHAR、BINARY、VARBINARY、BLOB、TEXT、ENUM和SET。该节描述了这些类型如何工做以及如何在查询中使用这些类型。
- BINARY 和 VARBINARY 相似于 CHAR 和 VARCHAR，不一样的是它们包含二进制字符串而不要非二进制字符串。也就是说，它们包含字节字符串而不是字符字符串。这说明它们没有字符集，而且排序和比较基于列值字节的数值值。
- BLOB 是一个二进制大对象，能够容纳可变数量的数据。有 4 种 BLOB 类型：TINYBLOB、BLOB、MEDIUMBLOB 和 LONGBLOB。它们区别在于可容纳存储范围不一样。
- 有 4 种 TEXT 类型：TINYTEXT、TEXT、MEDIUMTEXT 和 LONGTEXT。对应的这 4 种 BLOB 类型，可存储的最大长度不一样，可根据实际状况选择。
- char：定长字符串(3)
- 补齐指定长度的
- 长度变化小的状况使用、浪费空间，存储效率较高
- 用户名、密码、身份证、手机号
- varchar：变长字符串(3)
- 存储输入长度的+1 eg.alex 则存储alex4
- 节省空间、存储效率s相对低
- 评论、微博、说说、微信状态
create table t7(name1 char(5), name2 varchar(5));
# 分别存储 'echo ' 和 'echo4'
insert into t7 values('echo', 'echo')
select concat(name1, '---') from t7;
select concat(name2, '---') from t7;
2.4 enum和set类型
- ENUM中文名称叫枚举类型，它的值范围须要在建立表时经过枚举方式显示。ENUM只容许从值集合中选取单个值，而不能一次取多个值。
- SET和ENUM很是类似，也是一个字符串对象，里面能够包含0-64个成员。根据成员的不一样，存储上也有所不一样。set类型能够容许值集合中任意选择1或多个元素进行组合。对超出范围的内容将不容许注入，而对重复的值将进行自动去重。
- en ENUM('male', 'female')：单选框
- s set('')：多选框
- 5.6版本取交集，5.7版本插入的数据必须和指定数据一致，否则会报错
create table t8(name char(12),
gender ENUM('male', 'female'),
hobby set('play', 'drink', 'eat'));
3. mysql工做流程
- MySQL架构总共四层，在上图中以虚线做为划分。
- 最上层的服务并非MySQL独有的，大多数给予网络的客户端/服务器的工具或者服务都有相似的架构。好比：链接处理、受权认证、安全等。
- 第二层的架构包括大多数的MySQL的核心服务。包括：查询解析、分析、优化、缓存以及全部的内置函数（例如：日期、时间、数学和加密函数）。同时，全部的跨存储引擎的功能都在这一层实现：存储过程、触发器、视图等。
- 第三层包含了存储引擎。存储引擎负责MySQL中数据的存储和提取。服务器经过API和存储引擎进行通讯。这些接口屏蔽了不一样存储引擎之间的差别，使得这些差别对上层的查询过程透明化。存储引擎API包含十几个底层函数，用于执行“开始一个事务”等操做。但存储引擎通常不会去解析SQL（InnoDB会解析外键定义，由于其自己没有实现该功能），不一样存储引擎之间也不会相互通讯，而只是简单的响应上层的服务器请求。
- 第四层包含了文件系统，全部的表结构和数据以及用户操做的日志最终仍是以文件的形式存储在硬盘上。
1.3 表的完整性约束
1. 约束
- unsigned：设置无符号
- NOT NULL ：非空约束，指定某列不能为空；
- DEFAULT：默认值，当同一数据大量出现时使用；
- UNIQUE : 惟一约束，指定某列或者几列组合不能重；
- PRIMARY KEY ：主键，指定该列的值能够惟一地标识该列记；
- FOREIGN KEY ：外键，指定该行记录从属于主表中的一条记录，主要用于参照完整性。
1.1 not null
- 非空
create table t1(id int not null,
name char(12) not null,
age int);
insert into t1(id, name) values(1, 'henry');
1.2 default
- 默认值，建立列时能够指定默认值，当插入数据时若是未主动设置，则自动添加默认值
create table t2(id int not null,
name char(12) not null,
gender enum('male', 'female') not null default 'male'
);
insert into t2(id, name) values(1, 'henry');
1.3 unique
- 不重复(key UNI)，全部的非空数据不重复
- 惟一约束，指定某列或者几列组合不能重复
create table t3(id int unique,
username char(12) not null unique,
pwd char(18)
);
- 联合惟一(key MUL)
create table t4(id int not null unique,
ip char(15),
server char(10),
port int,
unique(ip, port)) # 联合惟一,不能同时重复
1.4 auto_increment
- 自增(只能用于数值)，**自带非空 惟一属性*s
- 约束字段为自动增加，被约束的字段必须同时被key约束
- 若是事务rollback了这个auto_increment值就会浪费掉，从而形成间隙
- AUTO_INCREMENT数据列序号的最大值受该列的数据类型约束，一旦达到上限，AUTO_INCREMENT就会失效。
create table t5(id int unique auto_increment,
username char(10),
pwd char(18));
insert into t5(username, pwd) values('henry', '123');
# 自增大小只增不减
# 对于自增的字段，在用delete删除后，再插入值，该字段仍按照删除前的位置继续增加
- 应该用truncate清空表，比起delete一条一条地删除记录，truncate是直接清空表，在删除大表时用它 mysql> truncate student;
# 也能够建立表时指定auto_increment的初始值，注意初始值的设置为表选项，应该放到括号外
create table student(id int primary key auto_increment,
name varchar(20),
gender enum('male','female') default 'male'
)auto_increment=3;
- mysql自增步长
#设置步长
# sqlserver：自增步长
# 基于表级别,指定步为2，从0开始计数
create table t1（id int unique auto_increment, age int
）engine=innodb,auto_increment=2 default charset=utf8;
# mysql自增的步长：
show session variables like 'auto_inc%';
# 基于会话级别
set session auto_increment_increment=2;# 修改会话级别的步长
# 基于全局级别的
set global auto_increment_increment=2; # 修改全局级别的步长（全部会话都生效）
# 查看设置，从新登录5.7版本直接失效
show variables like 'auto_incre%';
- If the value of auto_increment_offset(起始偏移量) is greater than that of auto_increment_increment(步长), the value of auto_increment_offset is ignored.
- 好比：设置auto_increment_offset=3，auto_increment_increment=2
1.5 primary key
- 一张表只能设置一个主键,innodb表中最好设置一个主键
- 主键约束这个字段，非空且惟一即：not null unique
create table t6(id int not null unique,
name char(10) not null unique);
# 第一个指定为not null nuique 字段被定义为主键
create table t7(id int primary key,
name char(10) not null unique);
- 联合主键
create table t8(id int,
ip char(15),
server char(10),
port int,
primary(ip, port)) # 联合主键
Note(4)
- 主键为了保证表中的每一条数据的该字段都是表格中的惟一值。换言之，它是用来独一无二地确认一个表格中的每一行数据。
- 主键能够包含一个字段或多个字段。当主键包含多个栏位时，称为组合键 (Composite Key),也能够叫联合主键。
- 主键能够在建新表格时设定 (运用 CREATE TABLE 语句)，或是以改变现有的表格架构方式设定 (运用 ALTER TABLE)。
- 主键必须惟一，主键值非空；能够是单一字段，也能够是多字段组合。
1.6 foreign key
- 外键，涉及到两张表
- 关联的数据类型必须一致
- 被关联的表必须惟一，mysql最好关联主键
- 先建立外表，再建立关联表
create table staff(id int primary key auto_increment,
age int,
gender enum('male', 'female'),
salary float(10,2),
hire_date date,
post_id int,
foreign key(post_id) references dept(pid);
create table dept(pid int primary key, name char(10) not null nuique);
- 级联删除和更新
- foreign key(post_id) references dept(pid) on update cascade on delete cascade
create table staff(id int primary key auto_increment,
age int,
gender enum('male', 'female'),
salary float(10,2),
hire_date date,
post_id int,
foreign key(post_id) references dept(pid)
on update cascade
on delete set null);
create table dept(pid int primary key, name char(10) not null nuique);
2. 修改表结构
- 建立项目以前
- 项目开发、运行过程当中
2.1 修改表名
# 修改表名 alter table 表名 rename 新表名;
2.2 增长/删除字段
# 添加字段 alter table 表名 add 添加字段名 数据类型(宽度) 约束 # 删除字段 alter table 表名 drop 删除字段名;
2.3 修改字段
# 修改已经存在字段的类型、宽度 约束，不能修改字段名字 alter table 表名 modify 字段名 类型() 约束 # 修改已经存在字段的类型、宽度 约束、字段名字 alter table 表名 change 字段名 新字段名 类型() 约束
2.4 修改字段顺序
# 把字段放在第一列 alter table 表名 modify age 类型+约束 first； # 把字段放在id以后 alter table 表名 modify age int not null after id； # 也能够与 add、change 连用
2.5 修改字段约束
#去掉null约束 alter table t modify name char(10) null; # 添加null约束 alter table t modify name char(10) not null;
# 去掉unique约束,特殊 alter table 表名 drop index 字段名; # 添加unique约束 alter table 表名 modify 字段名 int unique;
2.6 修改库的默认编码
alter database 库名 CHARACTER SET utf8;
2.7 操做主键add/drop
# 先删除主键，删除一个自增主键会报错 # 须要先去掉主键的自增约束，而后再删除主键约束 alter table 表名 drop primary key; # 增长主键 alter table 表名 add primary key(id);
2.8 操做外键add/drop
# 添加外键 alter table 表名 add constraint 外键名 foreign key(字段) references press(字段); # 删除外键 alter table 表名 drop foreign key 外键名;
2.9 删除表
drop table 表名；
3. 操做数据
两张表的数据关系：多对一、一对一、多对多(书、做者)
3.1 多对一
- 永远在多的表中设置外键
- 例如：一对多（或多对一）：一个出版社能够出版多本书
create table press(id int primary key auto_increment,
name varchar(20));
create table book(id int primary key auto_increment,
name varchar(20),
press_id int not null,
foreign key(press_id) references press(id)
on delete cascade
on update cascade);
insert into press(name) values('henry publisher'),
('echo publisher'),('dean publisher');
insert into book(name,press_id) values('henry',1),('echo',2),
('dean',2),('brad',3),('dianel',2),('oleg',3);
3.2 一对一
- 外键+unique
- 后出现的表中字段做为外键
# 两张表：学生表和客户表
create table customer(id int primary key auto_increment,
name varchar(20) not null,
qq varchar(10) not null,
phone char(16) not null);
create table student(id int primary key auto_increment,
class_name varchar(20) not null,
customer_id int unique, #该字段必定要是惟一的
foreign key(customer_id) references customer(id)
on delete cascade
on update cascade);
# 增长客户
insert into customer(name,qq,phone) values('henry', '12345', 12312312311), ('echo','123123123',12312312311),('dean', '283818181', 12312312311), ('brad','283818181',12312312311), ('oleg', '888818181', 12312312311), ('dianel','112312312',12312312311);
# 增长学生
insert into student(class_name,customer_id) values('1班',3),('2班',4),('3班',5);
3.3 多对多
- 利用第三张表，把两个关联关系的字段做为第三张表的外键
create table author(id int primary key auto_increment,
name varchar(20));
create table book(id int primary key auto_increment,
name varchar(20));
# 这张表就存放做者表与书表的关系，即查询两者的关系查这表就能够了
create table author_book(id int not null unique auto_increment,
author_id int not null,
book_id int not null,
constraint fk_author foreign key(author_id) references author(id)
on delete cascade
on update cascade,
constraint fk_book foreign key(book_id) references book(id)
on delete cascade
on update cascade,
primary key(author_id,book_id));
# 插入做者和书籍信息
insert into author(name) values('henry'),('echo'),('dean'),('diane');
insert into book(name) values('1'),('2'),('3'),('4'),('5'),('6')
insert into author_book(author_id,book_id) values(1,1),(1,2),(1,3）,(1,4),(1,5),(1,6),(2,1),(2,6),(3,4),(3,5),(3,6),(4,1);
3.4 on delete/update
# 在父表上update/delete记录时，同步update/delete掉子表的匹配记录 cascade方式 # 在父表上update/delete记录时，将子表上匹配记录的列设为null要注意子表的外键列不能为not null set null方式 # 若是子表中有匹配的记录,则不容许对父表对应候选键进行update/delete操做 No action方式 # 同no action, 都是当即检查外键约束 Restrict方式 # 父表有变动时,子表将外键列设置成一个默认的值 但Innodb不能识别 Set default方式
4. 记录操做
4.1 数据增长
- insert into 表名 values(值…)：一次性能够写入多行数据
- insert into 表名(字段名) values(值...)
- insert into 表名 value(值…)：一次性只能够写入一行数据
# 写入一行数据
insert into t1 values(1, 'henry', 19);
insert into t1 value(1, 'henry', 19);
# 写入多行数据
insert into t1 values(1, 'henry', 19), (2, 'echo', 18);
# 指定字段写入
insert into t1(name, age) value('henry', 19);
4.2 删除
# 删除条件匹配到的数据 delete form 表 where 条件;
4.3 修改
# 修改表中数据， set 后的字段能够为一个或多个 update 表 set 字段=值 where 条件; # 注意null只能使用 is 匹配 where name is null;
1.4 查询
- select 语法
SELECT DISTINCT 字段1,字段2... FROM 表名
WHERE 条件
GROUP BY field
HAVING 筛选
ORDER BY field
LIMIT 限制条数
1. 基本查询
# 查看表中全部数据
select * from 表
# 查看指定字段
select 字段1,字段2... from 表
# 查看指定字段，自动去重
select distinct 字段1,字段2... from 表
# 数值型四则运算，并名别名显示
select name,salary*12 (as) annual_salary form 表
# 数值型四则运算，并名别名， 拼接显示
select concat ('姓名：',name,'薪资：',salary*12) (as) annual_salary form 表
# 使用':'进行拼接
select concat_ws (':', name,salary*12 (as) annual_salary) form 表
# 结合CASE语句：
SELECT(CASE
WHEN emp_name = 'henry' THEN
emp_name
WHEN emp_name = 'echo' THEN
CONCAT(emp_name,'_prefect')
ELSE
concat(emp_name, '_nice')
END
) as new_name FROM employee;
2 . where
- 逐行过滤
- 比较运算：<>/!= 不等于，> ，< ，>=，<=
- 范围筛选
- 多选一个
- 在一个模糊的范围里
- 在一个数值区间
- 字符串模糊查询
- 正则匹配
- 逻辑运算—条件拼接
- 与、或、非
2.1 比较/逻辑/身份运算
- in / not in / is / is not
select * from t1 where salary>1000; # 和数值类型无关 select * from t1 where salary=20000 or slary=30000; # 逻辑运算 select * from t1 where gender='male' and age=18; # 多选一,可使用 in select 字段名，... from t1 where salary in (20000, 30000, 19000); # not in select 字段名，... from t1 where salary not in (20000, 30000, 19000); # is /is not select 字段名 from t1 where 字段 is null;
2.2 模糊查找(3)
- between…and...
# between ... and ... select name,salary from t1 where salary between 10000 and 20000
- 字符串模糊匹配，like
# like ， % 通配符，匹配任意长度，任意内容 select * from t1 where name like '程%'; # like ， _ 通配符，匹配一个任意字符 select * from t1 where name like '程_'; # like ， 以 n 结尾 select * from t1 where name like '%n';
- 正则匹配，regexp
select * from t1 where name regexp 正则表达式; SELECT * FROM employee WHERE emp_name REGEXP 'on$';
3. 分组聚合
3.1 group by
- group by 后的这个字段，也就是post字段中的每个不一样的项目保留下来
- 而且把值是这一项的全部行归为一组，并只显示组中第一个
# 显示一个组的第一个,必须有group的字段 select post from employee group by post; # distinct 基于group by完成
3.2 聚合函数(5)
- 把多行的同一字段进行一些统计，最终获得一个结果
- count(字段)：统计这个字段有多少项
- sum(字段)：统计这个字段对应的数值和，数值类型
- avg(字段)：平均值
- min、max：
- 只能取到最小、最大值，但不能取到对应的其余项(名字)，显示组中第一项
- 使用多表查询
- count
select count(*/ 主键) from employee; # 只算id不为空的字段个数 select count(id) from employee;
- avg/sum
select avg(salary) from employee; select sum(salary) from employee;
3.3 分组聚合
- group by
# 分别对各个组,统计人数 select post,count(*) from employee group by post; # 对某一组进行统计人数 select post,count(*) from employee where post='teacher'; # 各部门的平均薪资 select post,avg(salary) from employee group by post;
# 最晚入职 select max(hire_date) from employee group by post; # 最先入职 select min(hire_date) from employee group by post;
- 查询分组内全部成员名
- group_concat()
# 查询岗位名以及岗位包含的全部员工名字 select post, group_concat(emp_name) from employee group by post; # 查询岗位名以及各岗位内包含的员工个数 select post, count(id) from employee group by post; # 查询公司内男员工和女员工的个数 select gender, count(id) from employee group by gender;
Note3(2)
- 老是根据会重复的项进行分组
- 分组老是和聚合函数一块儿使用
3.4 having
- having 条件，组过滤， 通常与group一块儿使用
- Where 发生在分组group by以前，于是Where中能够有任意字段，可是绝对不能使用聚合函数。
- Having发生在分组group by以后，于是Having中可使用分组的字段，没法直接取到其余字段,可使用聚合函数
# 部门人数大于3 select post from employee group by post having count(*) > 3; # 平均薪资大于10000 select post from employee group by post having avg(salary) > 10000; # 过滤整张表,必须有 age 字段，不然报错 select emp_name, age from employee having avg(age)>18;
- having 过滤示例
# 查询各岗位内包含的员工个数小于2的岗位名、岗位内包含员工名字、个数 select post, group_concat(emp_name), count(*) from employee group by post having count(id) < 2; # 查询各岗位平均薪资大于10000的岗位名、平均工资 select post,avg(salary) from employee group by post having avg(salary) > 10000; # 查询各岗位平均薪资大于10000且小于20000的岗位名、平均工资 select post,avg(salary) from employee group by post having avg(salary) > 10000 and avg(salary) < 20000; # 使用 between ... and... select post,avg(salary) from employee group by post having avg(salary) between 10000 and 20000;
3.5 order by
# desc 表示降序排 # asc 表示生序排列，默认值 select * from employee order by salary desc; # 多个个字段排序，先根据第一个字段排列后，再根据第二个字段排列 select * from employee order by age asc, salary desc;
- having 和 order by综合使用示例
# 查询各岗位平均薪资大于10000的岗位名、平均工资,结果按平均薪资升序排列 select post, avg(salary) from employee group by post having avg(salary) > 10000 order by avg(salary) asc; # 查询各岗位平均薪资大于10000的岗位名、平均工资,结果按平均薪资降序排列 select post, avg(salary) from employee group by post having avg(salary) > 10000 order by avg(salary) desc;
3.6 limit
# 分页显示 # 默认从0开始，显示前5个 select * from employee limit 5; # 显示下5个, 5+1 位置开始取 # limit m,n 表示从m+1开始取到5个 limit n offset m等价于limit m,n select * from employee limit 5,5; # 显示下5个 select * from employee limit 10,5;
Note3(3)
- 关键字执行的优先级(8)
- join优先级要高于from
- from—> where —> group by —> select —> distinct —> having —> order by —>limit
- 用户认证—>解析、优化、执行sql、找到存储引擎
- select以前把行数限制在小的范围
4. 多表查询
- 数据准备
#建表
create table department(id int,
name varchar(20) );
create table staff(id int primary key auto_increment,
name varchar(20),
gender enum('male','female') not null default 'male',
age int,
dep_id int);
#插入数据
insert into department values(200,'技术'),(201,'人力资源'),(202,'销售'),(203,'运营');
insert into staff(name,gender,age,dep_id) values
('henry','male',18,200),
('echo','female',48,201),
('dean','male',38,201),
('diane','female',28,202),
('oleg','male',18,200),
('iris','female',18,204);
#查看表结构和数据
mysql> desc department;
mysql> desc employee;
mysql> select * from department;
mysql> select * from employee;
4.1 连表查询
- 一般使用内链接和左外链接
select 字段列表
FROM 表1 INNER|LEFT|RIGHT JOIN 表2
ON 表1.字段 = 表2.字段;
- 交叉链接：不适用任何匹配条件。生成笛卡尔积
# 笛卡尔积 select 字段 from t1,t2 where 字段1=字段2; # 连表查询,staff,department 两个表，和 inner join 效果一致 select * from staff, department as dept where dep_id=dept.id;
- 内链接(inner join)
- 两张表条件不匹配的项不出现结果中
select 字段 from t1 inner join t2 on t1(字段1) = t2(字段2);
- 外链接
- 左外链接(left join)：全量显示左边的表中数据
- 本质就是：在内链接的基础上增长左边有右边没有的结果
- 右外链接(right join)：全量显示右边的表中数据
- 本质就是：在内链接的基础上增长右边有左边没有的结果
- 全外链接(左外链接 union 右外链接)：mysql没有全外链接
- 在内链接的基础上增长左边有右边没有的和右边有左边没有的结果
- sqlserver中有全外链接(full join)，没有右外链接
- 左外链接(left join)：全量显示左边的表中数据
# t1链接t2，显示全量的左表，只显示匹配到的t2 select 字段 from t1 left join t2 on t1(字段1) = t2(字段2); select 字段 from t1 right join t2 on t1(字段1) = t2(字段2); # 全链接 select 字段 from t1 left join t2 on t1(字段1) = t2(字段2) union select 字段 from t1 right join t2 on t1(字段1) = t2(字段2);
# 经过左外、和右外链接实现全外链接示例 select * from staff left join department as dept on dep_id = dept.id union select * from staff right join department as dept on dep_id = dept.id;
- 注意 union与union all的区别：union会去掉相同的纪录
- 连表查询示例
- 连表查询效率更高
# 之内链接的方式查询staff和department表，而且staff表中的age字段值必须大于25,即找出年龄大于25岁的员工以及员工所在的部门 # 此时括号能够省略 select staff.name, dept.name from staff left join department as dept on dep_id = dept.id where age > 25; # 之内链接的方式查询staff和department表，而且以age字段的升序方式显示 select * from staff inner join department as dept on dep_id = dept.id order by age;
4.2 子查询
- 基本语法
1：子查询是将一个查询语句嵌套在另外一个查询语句中。 2：内层查询语句的查询结果，能够为外层查询语句提供查询条件。 3：子查询中能够包含：IN、NOT IN、ANY、ALL、EXISTS 和 NOT EXISTS等关键字 4：还能够包含比较运算符：= 、 !=、> 、<等
# 子表中匹配到惟一值
select name from emp where dep_id = (select id from department where name='技术');
# 子表中匹配到多个值
select name from emp where dep_id in (select id from department where name in ('技术', '销售'));
- 带in关键字的查询
- 使用in时，后面的表中字段只能有一个字段
# 查询平均年龄在25岁以上的部门名 select name from department where id in (select dep_id from staff group by dep_id having avg(age) > 25); # 查看技术部员工姓名 select name from staff where dep_id in (select id from department where name = '技术' ) # 查看不足1人的部门名(子查询获得的是有人的部门id) select name from department where id not in (select dep_id from staff group by dep_id);
- 带比较运算符
# 查询大于全部人平均年龄的员工名、年龄 select name, age from staff where age > (select avg(age) from staff); # 查询大于部门内平均年龄的员工名、年龄 select name, age from staff t1 inner join (select dep_id, avg(age) avg_age from staff group by dep_id) t2 on t1.dep_id = t2.dep_id where t1.age > t2.avg_age;
- 带EXISTS关键字的子查询
- EXISTS关字键字表示存在。在使用EXISTS关键字时，内层查询语句不返回查询的记录。而是返回一个真假值。
- 当返回True时，外层查询语句将进行查询；当返回值为False时，外层查询语句不进行查询
# exists后为真 select * from staff where exists (select id from department where id=200); # 输出staff中全部数据 # exists后为假 select * from staff where exists (select id from department where id=200); # 输出为空
- 示例
- 查询每一个部门最新入职的那位员工
# 连表查询 select t1.emp_name, t1.hire_date, t1.post from employee as t1 inner join (select depart_id, max(hire_date) as max_date from employee group by depart_id) as t2 on t1.depart_id = t2.depart_id where t1.hire_date = t2.max_date;
# 子查询 select t3.emp_name,t3.post,t3.hire_date from employee as t3 where id in (select (select id from employee as t2 where t2.depart_id=t1.depart_id order by hire_date desc limit 1) from employee as t1 group by depart_id);
1.5 mysql索引
1. 存储过程
# 1.准备表
create table s_test(id int,
name varchar(20),
gender char(6),
email varchar(50));
# 2.建立存储过程，实现批量插入记录
delimiter $$ #声明存储过程的结束符号为$$
create procedure auto_insert()
BEGIN
declare i int default 1;
while(i<3000000)do
insert into s_test values(i,'henry','male',concat('henry',i,'@qq.com'));
set i=i+1;
end while;
END$$ #$$结束
delimiter ; #从新声明分号为结束符号
# 3.查看存储过程
show create procedure auto_insert\G
# 4.调用存储过程
call auto_insert();
# 在写入的时候不更新索引表，只针对myisam生效
ALTER TABLE table_name DELAY_KEY_WRITE= 1;
2. 初识索引
- 索引是应用程序设计和开发的一个重要方面。若索引太多，应用程序的性能可能会受到影响。而索引太少，对查询性能又会产生影响，要找到一个平衡点，这对应用程序的性能相当重要。
- 场景：某台MySQL服务器iostat显示磁盘使用率一直处于100%，通过分析后发现是因为开发人员添加了太多的索引，在删除一些没必要要的索引以后，磁盘使用率立刻降低为20%。可见索引的添加也是很是有技术含量的。
2.1 概念
- 索引在MySQL中也叫是一种“键”，是存储引擎用于快速找到记录的一种数据结构
- 创建起的一个在存储表阶段的一个存储结构可以在查询的时候加速
- 出于效率方面的考虑，InnoDB数据表的数据行级锁定实际发生在它们的索引上，而不是数据表自身上。显然，数据行级锁定机制只有在有关的数据表有一个合适的索引可供锁定的时候才能发挥效力
2.2 索引的重要性
- 读写比例：10:1，读的速度是数据库的关键
- 读取硬盘的io操做时间要远远长于cpu执行指令的时间
- 尽可能减小io次数才是关键
- 索引对性能的影响随着数据量的增长愈发重要
- 访问磁盘的成本大概是访问内存的十万倍左右
- 磁盘IO与预读性原理，一次读取一个block块
- 访问磁盘，那么这里先简单介绍一下磁盘IO和预读，磁盘读取数据靠的是机械运动，每次读取数据花费的时间能够分为寻道时间、旋转延迟、传输时间三个部分，寻道时间指的是磁臂移动到指定磁道所须要的时间，主流磁盘通常在5ms如下；旋转延迟就是咱们常常据说的磁盘转速，
- 一台500 -MIPS（Million Instructions Per Second）的机器每秒能够执行5亿条指令。
- 考虑到磁盘IO是很是高昂的操做，计算机操做系统作了一些优化，当一次IO时，不光把当前磁盘地址的数据，并且把相邻的数据也都读取到内存缓冲区内，由于局部预读性原理告诉咱们，当计算机访问一个地址的数据的时候，与其相邻的数据也会很快被访问到。每一次IO读取的数据咱们称之为一页(page)。具体一页有多大数据跟操做系统有关，通常为4k或8k，也就是咱们读取一页内的数据时候，实际上才发生了一次IO，这个理论对于索引的数据结构设计很是有帮助。
- 4096bytes, 4k(linux)
- oracle会一次读取2个block块
- mysql会一次读取4个block块
2.3 索引原理
- 本质都是：经过不断地缩小想要获取数据的范围来筛选出最终想要的结果，同时把随机的事件变成顺序的事件，也就是说，有了这种索引机制，咱们能够老是用同一种查找方式来锁定数据。
- 索引会加速搜索的速度，但写的速度很慢。每次写入数据时都必须整理树形结构。
2.4 数据库存储方式
平衡树 balance tree b树
写入数据：速度较慢，须要整理数据
b树在范围查询b树不占优点(root、leaf、branch)演变成双向链式结构
在b树基础上的改良：b+树(innodb 默认结构)（2）
- 目的：每次查找数据时把磁盘IO次数控制在一个很小的数量级，最好是常数数量级。
- 分支节点和根节点不在存储实际数据
- 让分支和根节点能存储更多的索引信息
- 在叶子节点之间加入双向的链式结构方便在查询中的范围条件
索引字段要尽可能的小：经过上面的分析，咱们知道IO次数取决于b+数的高度h，假设当前数据表的数据为N，每一个磁盘块的数据项的数量是m，则有h=㏒(m+1)N，当数据量N必定的状况下，m越大，h越小；而m = 磁盘块的大小 / 数据项的大小，磁盘块的大小也就是一个数据页的大小，是固定的，若是数据项占的空间越小，数据项的数量越多，树的高度越低。这就是为何每一个数据项，即索引字段要尽可能的小，好比int占4字节，要比bigint8字节少一半。这也是为何b+树要求把真实的数据放到叶子节点而不是内层节点，一旦放到内层节点，磁盘块的数据项会大幅度降低，致使树增高。当数据项等于1时将会退化成线性表。
- B-Tree中一次检索最多须要h-1次I/O（根节点常驻内存），渐进复杂度为O(h) = O(logdN) 。通常实际应用中，出度d是很是大的数字，一般超过100，所以h很是小（一般不超过3）。（h表示树的高度 & 出度d表示的是树的度，即树中各个节点的度的最大值）
- 索引的最左匹配特性：当b+树的数据项是复合的数据结构，好比(name,age,sex)的时候，b+树是按照从左到右的顺序来创建搜索树的，好比当(张三,20,F)这样的数据来检索的时候，b+树会优先比较name来肯定下一步的所搜方向，若是name相同再依次比较age和sex，最后获得检索的数据；但当(20,F)这样的没有name的数据来的时候，b+树就不知道下一步该查哪一个节点，由于创建搜索树的时候name就是第一个比较因子，必需要先根据name来搜索才能知道下一步去哪里查询。好比当(张三,F)这样的数据来检索时，b+树能够用name来指定搜索方向，但下一个字段age的缺失，因此只能把名字等于张三的数据都找到，而后再匹配性别是F的数据了， 这个是很是重要的性质，即索引的最左匹配特性。
树的高度会影响索引的效率
- 对哪一列建立索引，选择尽可能短的列作索引
- 对区分度高的列建索引，重复率超过10%就不适合建立索引
- 尽可能选择区分度高的列做为索引,区分度的公式是count(distinct 字段)/count(*)，表示字段不重复的比例。
索引特色(2)
- 加速读取，但牺牲了写的速度
- 每一个节点存储数据的地址
mysql中全部的b+树索引的高度都基本上控制在3层
- io操做的次数很是稳定(3)
- 有利于经过范围查询
- 在数据库中，B+树的高度通常都在2~4层，这也就是说查找某一个键值的行记录时最多只须要2到4次IO，这倒不错。由于当前通常的机械硬盘每秒至少能够作100次IO，2~4次的IO意味着查询时间只须要0.02~0.04秒。
2.4 汇集索引和辅助索引
数据库中的B+树索引能够分为汇集索引（clustered index）和辅助索引（secondary index）
汇集索引：数据直接存储在树结构的叶子节点
- 如用户须要查找一张表，查询最后的10位用户信息，因为B+树索引是双向链表，因此用户能够快速找到最后一个数据页，并取出10条记录
# InnoDB存储引擎表是索引组织表，即表中数据按照主键顺序存放。 1. 而汇集索引（clustered index）就是按照每张表的主键构造一棵B+树，同时叶子结点存放的即为整张表的行记录数据，也将汇集索引的叶子结点称为数据页。 2. 汇集索引的这个特性决定了索引组织表中数据也是索引的一部分。同B+树数据结构同样，每一个数据页都经过一个双向链表来进行连接。 # 若是未定义主键，MySQL取第一个惟一索引（unique）并且只含非空列（NOT NULL）做为主键，InnoDB使用它做为聚簇索引。 1. 若是没有这样的列，InnoDB就本身产生一个这样的ID值，它有六个字节，并且是隐藏的，使其做为汇集索引。 # 因为实际的数据页只能按照一棵B+树进行排序，所以每张表只能拥有一个汇集索引。 1. 在多数状况下，查询优化器倾向于采用汇集索引。由于汇集索引可以在B+树索引的叶子节点上直接找到数据。 2. 此外因为定义了数据的逻辑顺序，汇集索引可以特别快地访问针对范围值得查询。
- 能够经过添加主键的方式完成索引的创建
alter table t1 add primary key(id); alter table t1 modify id not null unique;
- 汇集索引的好处之一：它对主键的排序查找和范围查找速度很是快，叶子节点的数据就是用户所要查询的数据。
- 汇集索引的好处之二：范围查询（range query），即若是要查找主键某一范围内的数据，经过叶子节点的上层中间节点就能够获得页的范围，以后直接读取数据页便可。
辅助索引：数据不直接存储在树中
- 须要回表
- 表中除了汇集索引外其余索引都是辅助索引（Secondary Index，也称为非汇集索引），与汇集索引的区别是：辅助索引的叶子节点不包含行记录的所有数据。叶子节点除了包含键值之外，每一个叶子节点中的索引行中还包含一个书签（bookmark）。该书签用来告诉InnoDB存储引擎去哪里能够找到与索引相对应的行数据。
- 辅助索引的存在并不影响数据在汇集索引中的组织，所以每张表上能够有多个辅助索引，但只能有一个汇集索引。当经过辅助索引来寻找数据时，InnoDB存储引擎会遍历辅助索引并经过叶子级别的指针得到索引的主键，而后再经过主键索引来找到一个完整的行记录。
汇集和辅助索引对比
- 汇集索引与辅助索引相同的是：无论是汇集索引仍是辅助索引，其内部都是B+树的形式，即高度是平衡的，叶子结点存放着全部的数据。汇集索引与辅助索引不一样的是：叶子结点存放的是不是一整行的信息
- 汇集索引
- 纪录的索引顺序与顺序相同，所以更适合between and和order by操做
- 叶子结点直接对应数据从中间级的索引页的索引行直接对应数据页
- 每张表只能建立一个汇集索引
- 非汇集索引
- 索引顺序和物理顺序无关
- 叶子结点不直接指向数据页
- 每张表能够有多个非汇集索引，须要更多磁盘和内容
- 多个索引会影响insert和update的速度
innodb中汇集索引和辅助索引并存（都是b+树）
- 数据和索引存在一块儿
- 除了主键以外全部的索引都是辅助索引
myisam中只有辅助索引
- 叶子节点存储数据的主键的值
- 经过主键再查找数据
须要注意的是：innodb表的索引会存放于s1.ibd文件中，而myisam表的索引则会有单独的索引文件table1.MYI
MySAM索引文件和数据文件是分离的，索引文件仅保存数据记录的地址。而在innodb中，表数据文件自己就是按照B+Tree（BTree即Balance Tree）组织的一个索引结构，这棵树的叶节点data域保存了完整的数据记录。这个索引的key是数据表的主键，所以innodb表数据文件自己就是主索引。由于inndob的数据文件要按照主键汇集，因此innodb要求表必需要有主键（Myisam能够没有），若是没有显式定义，则mysql系统会自动选择一个能够惟一标识数据记录的列做为主键，若是不存在这种列，则mysql会自动为innodb表生成一个隐含字段做为主键，这字段的长度为6个字节，类型为长整型.
3. 使用索引
3.1 索引两大类型
- 咱们能够在建立上述索引的时候，为其指定索引类型，分两类：
- hash类型的索引：查询单条快，范围查询慢
- 只有memory（内存）存储引擎支持哈希索引，哈希索引用索引列的值计算该值的hashCode，而后在hashCode相应的位置存执该值所在行数据的物理位置，由于使用散列算法，所以访问速度很是快，可是一个值只能对应一hashCode，并且是散列的分布方式，所以哈希索引不支持范围查找和排序的功能。
- btree类型的索引：b+树，层数越多，数据量指数级增加（咱们就用它，由于innodb默认支持它）
- hash类型的索引：查询单条快，范围查询慢
- 不一样的存储引擎支持的索引类型也不同
- InnoDB 支持事务，支持行级别锁定，支持 B-tree、Full-text 等索引，不支持 Hash 索引；
- MyISAM 不支持事务，支持表级别锁定，支持 B-tree、Full-text 等索引，不支持 Hash 索引；
- Memory 不支持事务，支持表级别锁定，支持 B-tree、Hash 等索引，不支持 Full-text 索引；
- NDB 支持事务，支持行级别锁定，支持 Hash 索引，不支持 B-tree、Full-text 等索引；
- Archive 不支持事务，支持表级别锁定，不支持 B-tree、Hash、Full-text 等索引；
- 除此以外还有全文索引，即FULLTEXT用于搜索很长一篇文章的时候，效果最好。用在比较短的文本，若是就一两行字的，普通的 INDEX 也能够。但其实对于全文搜索，咱们并不会使用MySQL自带的该索引，而是会选择第三方软件如Sphinx，专门来作全文搜索。
- 其余的如空间索引SPATIAL，了解便可，几乎不用。
3.2 索引的种类
- primary key 主键 自带汇集索引 和约束：非空+惟一
- 联合主键
- unique 区分度最高 自带辅助索引 和约束：惟一
- 联合惟一
- index 辅助索引 辅助索引 没有约束
- 联合索引，根据两个字段创建索引
3.3 使用索引
- 添加主键会自动添加为索引
- 添加unique也会自动添加为索引
# 方法一：建立表时
create table 表(字段...,
index|unique|fulltext|spatial|key
索引名称 on 表(字段1,字段2...));
# 方法二：CREATE在已存在的表上建立索引,经常使用方法
create index(索引类型，一般使用index) 索引名称 on 表(字段1,字段2...);
# 方法三：ALTER TABLE在已存在的表上建立索引
alter table 表名 add index 索引名称 on 表(字段1,字段2...);
# 删除索引
drop index 索引名 on 表名字;
# 查看表s1的索引
show index from s1;
- 不添加索引的时候确定慢
- 查询的字段不是索引字段也慢
3.4 索引不生效
- 范围、条件字段是否参与计算、列的区分度、列的长度、条件 and/or，联合索引的前缀问题
- 要查询的范围越大，索引效果越不明显，越费时
- 和比较运算符有关的，大于、小于、不等于、between … and ...
- like，结果范围大，like abc%能够生效，%abc索引不生效
select * from 表 where id between 1000000 and 1000005; # 使用like select * from 表 where emial like '%abc';
- 一列的区分度不高
- 即范围过大
# 而对于区分度低的字段，没法找到大小关系，由于值都是相等的，毫无疑问，还想要用b+树存放这些等值的数据，只能增长树的高度，字段的区分度越低，则树的高度越高。
- 索引列不能参与计算，不能包含函数
select * from s1 where id*10 = 1000000;
- 对两列内容进行条件查询
- and：优先选择有索引且树形结构更好的进行查找，快速缩小范围
- or：若是存在没有索引项，索引效果不生效，只是根据条件从左到右依次筛选
- 条件中带有or的想要命中索引，这些条件中全部列都是索引列
- 最左前缀匹配原则，很是重要的原则，对于组合索引mysql会一直向右匹配直到遇到范围查询(>、<、between、like)就中止匹配(指的是范围大了，有索引速度也慢)，好比a = 1 and b = 2 and c > 3 and d = 4 若是创建(a,b,c,d)顺序的索引，d是用不到索引的，若是创建(a,b,d,c)的索引则均可以用到，a,b,d的顺序能够任意调整。
- 其余状况
- 索引字段使用函数
- 排序条件为索引，则select字段必须也是索引字段，不然没法命中
- 若是对主键排序，则仍是速度很快：
- create index xxxx on tb(title(19)) # text类型，必须制定长度
小结：索引不生效状况
- 在联合索引中若是使用or条件索引不生效
- 条件必须含有建立索引的第一个字段(最左前缀原则)
- id列能够命中索引
- 整个条件中，一开始出现模糊匹配的那一刻，索引就失效
3.5 联合索引
- 查找老是两个(多)个条件
- 从本质上来讲，联合索引就是一棵B+树，不一样的是联合索引的键值得数量不是1，而是>=2
- 在第一个键相同的状况下，已经对第二个键进行了排序处理
create index ind_mix on s1(id, email); # 对于联合索引（a,b）,下述语句能够直接使用该索引，无需二次排序 select ... from table where a=xxx order by b; # 而后对于联合索引(a,b,c)来首，下列语句一样能够直接经过索引获得结果 select ... from table where a=xxx order by b; select ... from table where a=xxx and b=xxx order by c; # 可是对于联合索引(a,b,c)，下列语句不能经过索引直接获得结果，还须要本身执行一次filesort操做，由于索引（a，c)并未排序 select ... from table where a=xxx order by c;
- 应用场景
- 只对a，b，c条件进行索引
- 不对b，对c进行单列索引
- 单列索引
- 区分度高的列，创建索引，条件的范围尽可能小
- 条件中的列不参与计算，使用and 做为条件链接
- 使用or链接多个条件，在知足上述条件的基础上，对or相关的全部列建立索引
3.6 覆盖/合并索引
- InnoDB存储引擎支持覆盖索引（covering index，或称索引覆盖），即从辅助索引中就能够获得查询记录，而不须要查询汇集索引中的记录。
- 覆盖索引的一个好处是：辅助索引不包含整行记录的全部信息，故其大小要远小于汇集索引，所以能够减小大量的IO操做
- 若是使用索引做为条件查询，查询完毕以后，不须要回表查即覆盖索引
- 对两个字段分别建立索引，因为sql让两个索引同时生效，那么这个时候这两个索引就成为了合并索引。
3.7 执行计划
# 执行计划，并不会真正执行sql语句，给出一个执行计划 explain select id from s1 where id = 1000000;
- 执行计划使用场景
- 测试sql语句是否能够知足数据量多的状况下的效率
- 建表、使用sql须要注意
- char代替varchar
- 连表代替子查询
- 建立表的时候，固定长度的字段在前面
3.8 慢查询优化流程
- 先运行看看是否真的很慢，注意设置SQL_NO_CACHE
- where条件单表查，锁定最小返回记录表。这句话的意思是把查询语句的where都应用到表中返回的记录数最小的表开始查起，单表每一个字段分别查询，看哪一个字段的区分度最高
- explain查看执行计划，是否与1预期一致（从锁定记录较少的表开始查询）
- order by limit 形式的sql语句让排序的表优先查
- 了解业务方使用场景
- 加索引时参照建索引的几大原则
- 观察结果，不符合预期继续从0分析
4. 库的备份与恢复
# 语法： mysqldump -h服务器 -u用户名 -p密码 数据库名 > 备份文件.sql # 示例： # 单库备份 mysqldump -uroot -p123 库名 > 备份文件名(路径) mysqldump -uroot -p123 db1 table1 table2 > db1-table1-table2.sql # 多库备份,导入时不须要指定库名，会覆盖库名相同的库 mysqldump -uroot -p123 --databases db1 db2 mysql db3 > db1_db2_mysql_db3.sql # 备份全部库 mysqldump -uroot -p123 --all-databases > all.sql
# 方法一：不使用 --databases 参数 mysql -u用户名 -p密码 库名 < 备份文件名 # 方法二： mysql> use db1; # 关闭二进制日志，只对当前session生效 mysql> SET SQL_LOG_BIN=0; mysql> source /root/db1.sql
1.6 pymysql模块
1. 第三方模块
mysql -uroot -p mysql.exe # mysql的一个客户端
- ip port 用户名 密码 使用的库 链接mysqld的server端
import pymysql
con = pymysql.connect(host='127.0.0.1', user='root', password='123', database='test')
# 数据库操做符，游标，dict取值，默认元组
cur = con.cursor(pymysql.cursors.DictCursor)
# 操做
cur.execute('sql语句')
# 获取返回值,cur相似操做文件的游标指针
ret = cur.fetchone()/ fetchmany(n)/ fetchall()
con.commit()
con.close()
- localhost：不过网卡，127.0.0.1过网卡
2. 事务和锁
# 开启事务 begin; 或者 start transction; # 查询id值，for update添加行锁； select * from emp where id = 1 for update; # 完成更新 update emp set salary=10000 where id = 1; # 提交事务 commit;
3. sql注入
-- 表示注释掉以后的sql语句 select * from userinfo where name = 'alex' ;-- and password = '792164987034'; select * from userinfo where name = 219879 or 1=1 ;-- and password = 792164987034; select * from userinfo where name = '219879' or 1=1 ;-- and password = '792164987034';
- 怎么避免sql注入问题
sql = 'select * from 表' # 参数为可迭代对象,使用execut拼接 cur.execute(sql, (username, password)) cur.close() con.close()
- 回滚操做
- 修改表中数据必须使用commit() 方法
import pymysql
# 打开数据库链接
db = pymysql.connect("localhost","testuser","test123","TESTDB" )
# 使用cursor()方法获取操做游标
cursor = db.cursor()
# SQL 插入语句
sql = """INSERT INTO EMPLOYEE(FIRST_NAME,
LAST_NAME, AGE, SEX, INCOME)
VALUES ('Mac', 'Mohan', 20, 'M', 2000)"""
try:
cursor.execute(sql) # 执行sql语句
db.commit() # 提交到数据库执行
except:
db.rollback() # 若是发生错误则回滚
# 关闭数据库链接
db.close()
- 查询操做
- Python查询Mysql使用 fetchone() 方法获取单条数据, 使用fetchall() 方法获取多条数据。
- fetchone(): 该方法获取下一个查询结果集。结果集是一个对象
- fetchall(): 接收所有的返回结果
- rowcount: 这是一个只读属性，并返回执行execute()方法后影响的行数。
import pymysql
# 打开数据库链接
db = pymysql.connect("localhost", "root", "root", "day40")
# 使用cursor()方法获取操做游标
cur = db.cursor()
# SQL 查询语句
sql = "SELECT * FROM employee \
WHERE salary > %s" % (1000)
try:
ret = cur.execute(sql) # 执行SQL语句
print(ret) # ret为数据行数
results = cur.fetchall() # 获取全部记录列表
for row in results:
id = row[0]
name = row[1]
gender = row[2]
age = row[3]
hire_date = row[4]
print("id=%s,name=%s,gender=%s,age=%s,hire_date=%s"%(id, name, gender, age, hire_date))
except:
print("Error: unable to fetch data")
# 关闭数据库链接
db.close()
1.7 数据库优化
- sql优化：索引、尽力那个把条件范围都写在where里，尽可能用连表查
- 如何建立表：把固定长度的字段放在前面、分库分表
- innodb中的外键是特有的
相关文章
- 1. MySQL体系结构漫谈
- 2. 漫谈 MySQL 的锁机制
- 3. 漫谈MySql中的事务
- 4. 漫谈MySQL的锁机制
- 5. 漫谈MySQL体系结构
- 6. 【MySQL】漫谈MySQL体系结构
- 7. 漫谈慢慢谈。。。
- 8. MySQL的词法分析漫谈
- 9. MySQL - InnoDB特性 - Buffer Pool漫谈
- 10. mysql 高可用方案漫谈（二）
- 更多相关文章...
- • PHP 连接 MySQL - PHP教程
- • MySQL DATE_ADD() 函数 - SQL 教程
- • 漫谈MySQL的锁机制
- • Docker容器实战(八) - 漫谈 Kubernetes 的本质
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
相关文章
- 1. MySQL体系结构漫谈
- 2. 漫谈 MySQL 的锁机制
- 3. 漫谈MySql中的事务
- 4. 漫谈MySQL的锁机制
- 5. 漫谈MySQL体系结构
- 6. 【MySQL】漫谈MySQL体系结构
- 7. 漫谈慢慢谈。。。
- 8. MySQL的词法分析漫谈
- 9. MySQL - InnoDB特性 - Buffer Pool漫谈
- 10. mysql 高可用方案漫谈（二）