MySql的相关资操做 01-MySql的前戏 02-数据库概述 03-MySql安装和基本管理 04-基本的mysql语句 05-库的操做 06-表的操做 07-数据类型 08-数据类型(2) 09

时间 2019-12-04

标签 mysql 相关前戏数据库概述安装基本管理语句数据类型栏目 MySQL 繁體版

原文原文链接

01-MySql的前戏

MySql的前戏

在学习Mysql以前，咱们先来想一下一开始作的登陆注册案例，当时咱们把用户的信息保存到一个文件中：css

#用户名 |密码
root|123321
alex|123123

上面文件内容的规则是我本身定义的，你要想用我这个程序，必须按照个人规则去执行，但凡不是这个规则，就没有交流的余地。html

在一开始的时候文件格式的规定是没有规范的，后面学到模块的时候逐渐知道了目录规则，咱们会把文件放到db目录下。node

相似下面目录结构：python

对于上面db目录中，是能够存放多个文件的，而且文件中能够有多行数据。mysql

那么问你们一个问题，若是说上面那个软件是我写好的，在一台服务器或者一台机器上安装了我写好的软件。redis

如今有张三和李四两我的都安装了我这个软件，张三注册了一个用户，李四也注册了一个用户，那么本身注册的用户应该是本身用的。那么这两个用户是不共享的，算法

因此这个软件证实我写的不太好，它不能共享，这种相似单机的软件是很差的。sql

而后呢，我如今将我写的这个软件中目录修改一下，将db目录移除。如今将单机程序（本身的DB）改变成也是单机程序（公用DB）。mongodb

那么以前给你们介绍过，凡是交互操做，是离不开scoket的，那么如今我这边有个公用DB和一个scoket服务端，而后在张三和李四那边有scoket客户端。张三和李四此时输入用户名和密码，如今我这边scoket服务端某个目录接收用户输入的用户名和密码，看一下该用户名存在不存在，若是存在返回true,若是不存在返回false。也就是说重点的内容咱们把db目录放到某台服务器上。数据库

那么上面这个例子呢，其实就给你们慢慢的引出来mysql了，mysql呢其实就一个软件，这个软件安装到某台电脑上或者某台服务器上，那么如今只要我告诉它建立一个文件目录或者建立文件，那么mysql就自动帮咱们建立了，好比说咱们再在文件中添加一条数据，那么它也帮咱们完成。

总结一句话：其实mysql就是用于管理咱们的文件的一个软件。

那么对于mysql这个软件来讲有两个软件

---服务器软件
     - socket服务端
     - 本地文件操做
　　　- 解析指令（mysql语句）
---客户端软件
     - socket客户端
     - 发送指令
　　　- 解析指令（mysql语句）

解释：

对于服务器软件中的socket服务器是一直开着，客户端得须要链接，而且还有建立文件、删除文件等等的操做

对于客户端软件中的scoket客户端，咱们得须要发送指令去命令scoket服务端对文件进行操做。

你们应该知道ftp的项目，上传项目和下载项目的命令是不同的。那么对于mysql中的客户端和服务端也会有些指令的操做，那么在这两个端中应该是有解析指令的过程，这个指令只有mysql这个软件知道，这种指令就是mysql语句。

再想一想咱们写的html、css、js.这些比如就是咱们客户端写好的语法，而后浏览器充当了服务端的角色去解析咱们的的语法，最后来渲染出来结果。

接下来咱们要学习这些技能：

- 安装 服务端和客户端
- 链接
- 学习SOL语句规则：命令服务端作任何的操做

02-数据库概述

什么是数据（Data）

描述事物的符号记录称为数据，描述事物的符号既能够是数字，也能够是文字、图片，图像、声音、语言等，数据由多种表现形式，它们均可以通过数字化后存入计算机

在计算机中描述一个事物，就须要抽取这一事物的典型特征，组成一条记录，就至关于文件里的一行内容，如：

1 xiaomage,male,18,1999,山东,计算机系,2017,oldboy

单纯的一条记录并无任何意义，若是咱们按逗号做为分隔，依次定义各个字段的意思，至关于定义表的标题

这样经过表格咱们很清楚的知道了某人的详细信息。

什么是数据库（DataBase,简称DB）

数据库即存放数据的仓库，只不过这个仓库是在计算机存储设备上，并且数据是按必定的格式存放的

过去人们将数据存放在文件柜里，如今数据量庞大，已经再也不适用

数据库是长期存放在计算机内、有组织、可共享的数据便可。

数据库中的数据按必定的数据模型组织、描述和储存，具备较小的冗余度、较高的数据独立性和易扩展性，并可为各类用户共享

什么是数据库管理系统（DataBase Management System）

在了解了Data与DB的概念后，如何科学地组织和存储数据，如何高效获取和维护数据成了关键

这就用到了一个系统软件---数据库管理系统

如MySQL、Oracle、SQLite、Access、MS SQL Server

mysql主要用于大型门户，例如搜狗、新浪等，它主要的优点就是开放源代码，由于开放源代码这个数据库是免费的，他如今是甲骨文公司的产品。
oracle主要用于银行、铁路、飞机场等。该数据库功能强大，软件费用高。也是甲骨文公司的产品。
sql server是微软公司的产品，主要应用于大中型企业，如联想、方正等。

数据库服务器、数据管理系统、数据库、表与记录的关系（重点理解！！！）

记录：1 xxx 324245234 22（多个字段的信息组成一条记录，即文件中的一行内容）

表：student,scholl,class_list（即文件）

数据库：oldboy_stu（即文件夹）

数据库管理系统：如mysql（是一个软件）

数据库服务器：一台计算机（对内存要求比较高）

总结：

数据库服务器-：运行数据库管理软件

数据库管理软件：管理-数据库

数据库：即文件夹，用来组织文件/表

表：即文件，用来存放多行内容/多条记录

03-MySql安装和基本管理

本节掌握内容：

MySQL的介绍安装、启动
windows上制做服务
MySQL破解密码
MySQL中统一字符编码

MySQL是一个关系型数据库管理系统，由瑞典MySQL AB 公司开发，目前属于 Oracle 旗下公司。MySQL 最流行的关系型数据库管理系统，在 WEB 应用方面MySQL是最好的 RDBMS (Relational Database Management System，关系数据库管理系统) 应用软件之一。

MySQL是一种关系数据库管理系统，关系数据库将数据保存在不一样的表中，而不是将全部数据放在一个大仓库内，这样就增长了速度并提升了灵活性。

Mysql是开源的，因此你不须要支付额外的费用。
Mysql支持大型的数据库。能够处理拥有上千万条记录的大型数据库。
MySQL使用标准的SQL数据语言形式。
Mysql能够容许于多个系统上，而且支持多种语言。这些编程语言包括C、C++、Python、Java、Perl、PHP、Eiffel、Ruby和Tcl等。
Mysql对PHP有很好的支持，PHP是目前最流行的Web开发语言。
MySQL支持大型数据库，支持5000万条记录的数据仓库，32位系统表文件最大可支持4GB，64位系统支持最大的表文件为8TB。
Mysql是能够定制的，采用了GPL协议，你能够修改源码来开发本身的Mysql系统。

因为其社区版的性能卓越，搭配Apache和PHP以及python 可组成良好的开发环境。

应用环境

与其余的大型数据库例如 Oracle、DB2、SQL Server等相比，MySQL [1] 自有它的不足之处，可是这丝毫也没有减小它受欢迎的程度。对于通常的我的使用者和中小型企业来讲，MySQL提供的功能已经绰绰有余，并且因为 MySQL是开放源码软件，所以能够大大下降整体拥有成本。

Linux做为操做系统， Apache 或 Nginx做为 Web 服务器，MySQL 做为数据库，PHP/Perl/ Python做为服务器端脚本解释器。因为这四个软件都是免费或开放源码软件（ FLOSS)，所以使用这种方式不用花一分钱（除开人工成本）就能够创建起一个稳定、免费的网站系统，被业界称为“ LAMP“或“ LNMP”组合。

mysql是什么？

总结：mysql就是一个基于socket编写的C/S架构的软件

数据库管理软件分类

分两大类：
　　关系型：如sqllite，db2，oracle，access，sql server，MySQL，注意：sql语句通用
　　非关系型：mongodb，redis，memcache

总结两句话：
    关系型数据库须要有表结构
    非关系型数据库是key-value存储的，没有表结构

因此，如今咱们使用关系型数据库管理系统（RDBMS）来存储和管理的大数据量。所谓的关系型数据库，是创建在关系模型基础上的数据库，借助于集合代数等数学概念和方法来处理数据库中的数据。

RDBMS即关系数据库管理系统(Relational Database Management System)的特色：

1.数据以表格的形式出现
2.每行为各类记录名称
3.每列为记录名称所对应的数据域
4.许多的行和列组成一张表单
5.若干的表单组成database

RDBMS 术语

在咱们开始学习MySQL 数据库前，让咱们先了解下RDBMS的一些术语：

数据库: 数据库是一些关联表的集合。.
数据表: 表是数据的矩阵。在一个数据库中的表看起来像一个简单的电子表格。
列: 一列(数据元素) 包含了相同的数据, 例如邮政编码的数据。
行：一行（=元组，或记录）是一组相关的数据，例如一条用户订阅的数据。
冗余：存储两倍数据，冗余下降了性能，但提升了数据的安全性。
主键：主键是惟一的。一个数据表中只能包含一个主键。你能够使用主键来查询数据。
外键：外键用于关联两个表。
复合键：复合键（组合键）将多个列做为一个索引键，通常用于复合索引。
索引：使用索引可快速访问数据库表中的特定信息。索引是对数据库表中一列或多列的值进行排序的一种结构。相似于书籍的目录。
参照完整性: 参照的完整性要求关系中不容许引用不存在的实体。与实体完整性是关系模型必须知足的完整性约束条件，目的是保证数据的一致性。

mysql的下载安装

想要使用MySQL来存储并保存数据，则须要作几件事情：

　　a. 安装MySQL服务端
　　b. 安装MySQL客户端
　　b. 【客户端】链接【服务端】
　　c. 【客户端】发送命令给【服务端MySQL】服务的接受命令并执行相应操做(增删改查等)

下载地址：

https://dev.mysql.com/downloads/mysql/

window版本

一、官网去下载

二、针对操做系统的不一样下载不一样的版本

3.解压

若是想要让MySQL安装在指定目录，那么就将解压后的文件夹移动到指定目录，如：C:\mysql-5.6.40-winx64

4.添加环境变量

5.初始化

6.启动mysql服务

mysqld #启动MySQL服务

7.启动mysql客户端并链接mysql服务端（新开一个cmd窗口）

mysql -u root -p # 链接MySQL服务器

上一步解决了一些问题，但不够完全，由于在执行【mysqd】启动MySQL服务器时，当前终端会被hang住，那么作一下设置便可解决此问题,即将MySQL服务制做成windows服务

注意：--install前，必须用mysql启动命令的绝对路径
# 制做MySQL的Windows服务，在终端执行此命令：
"c:\mysql-5.6.40-winx64\bin\mysqld" --install

# 移除MySQL的Windows服务，在终端执行此命令：
"c:\mysql-5.6.40-winx64\bin\mysqld" --remove


注册成服务以后，之后再启动和关闭MySQL服务时，仅需执行以下命令：
# 启动MySQL服务
net start mysql

# 关闭MySQL服务
net stop mysql

windows下登陆设置密码

打开终端，输入mysql

输入mysql提供的函数：select user(); # 查看当前登陆的帐号

当前登陆的默认帐号为ODBC@localhost

若是想切到root帐号登陆

执行命令：

mysql -uroot -p

再查看当前用户：

select user();

管理员为root(拥有最高权限,管理员帐号）,密码为空，以无密码的方式登陆了管理员帐号，是很是危险的一件事情，因此要为管理员帐号设置密码

设置管理员root帐号密码为123

C:\Users\mjj>mysqladmin -uroot -p password "123"  #设置初始密码 因为原密码为空，所以-p能够不用 Mysql版本的不一样，可能执行这句指令不起做用，请使用update mysql.user set authentication_string =password('') where User='root';

ps:⚠️不用管它。翻译为：在命令行界面使用密码不安全，暴露在终端当中。

而后再登陆帐号，不输入密码则会出现以下结果：

再次执行以下操做：

再查看一下当前登陆的帐号：

若是想将原始密码123，设置新密码为456

C:\Users\mjj>mysqladmin -uroot -p"123" password "456"  #修改mysql密码,由于已经有密码了，因此必须输入原密码才能设置新密码

依次执行以下操做：

mysql -uroot -p456

select user();

密码忘记——破解密码

跳过受权方式，直接登陆！！

0.以管理员身份打开cmd

2.停掉mysql服务端

C:\WINDOWS\system32>net stop mysql
MySQL 服务正在中止.
MySQL 服务已成功中止。

3.执行以下命令跳过受权表

#跳过受权表
C:\WINDOWS\system32>mysqld --skip-grant-tables
2018-06-09 17:12:38 0 [Warning] Insecure configuration for --secure-file-priv: Current value does not restrict location of generated files. Consider setting it to a valid, non-empty path.
2018-06-09 17:12:38 0 [Note] mysqld (mysqld 5.6.40) starting as process 6052 ...4.

4.再次查看

5. 如今能够任意的更改密码，执行以下命令

update mysql.user set authentication_string =password('') where User='root';

6.刷新权限，执行命令

flush privileges;

7.退出mysql。执行命令：exit，

8.让用户去加载权限，以管理员身份进入cmd,查看当前mysql进程

 
                tasklist |findstr mysql   
                #查看当前mysql的进程

9.杀死当前的进程，执行以下命令

taskkill /F /PID 6052  # 杀死当前的进程pid

10.再次执行以下操做，还原

统一字符编码

进入mysql客户端，执行\s

为了统一字符编码，请执行以下操做：

（1）my.ini文件是mysql的配置文件，

在C:\mysql-5.6.40-winx64文件下建立my.ini文件

（2）将以下代码拷贝保存。

[mysqld]
# 设置mysql的安装目录 **后面的路径必定是安装sql的目录（本身电脑的）**
basedir=C:\mysql-5.7.22-winx64\mysql-5.7.22-winx64
# 设置mysql数据库的数据的存放目录，必须是data
datadir=C:\mysql-5.7.22-winx64\mysql-5.7.22-winx64\data
sql_mode=NO_ENGINE_SUBSTITUTION,STRICT_TRANS_TABLES

# mysql端口
port=3306
# 字符集
[mysqld]
character-set-server=utf8
collation-server=utf8_general_ci
[client]
default-character-set=utf8
[mysql]
default-character-set=utf8

（3）以管理员身份重启服务，执行以下命令

C:\Windows\system32>net stop MySQL
MySQL 服务正在中止..
MySQL 服务已成功中止。

C:\Windows\system32>net start MySQL
MySQL 服务正在启动 .
MySQL 服务已经启动成功。

（4）在cmd中输入mysql进入mysql环境，执行\s,显示以下信息，表示成功

04-基本的mysql语句

本节课先对mysql的基本语法初体验。

操做文件夹（库）

增

create database db1 charset utf8;

查

# 查看当前建立的数据库
show create database db1;
# 查看全部的数据库
show databases;

改

alter database db1 charset gbk;

删

drop database db1;

操做文件（表）

use db1; #切换文件夹

select database(); #查看当前所在文件夹

增

create table t1(id int,name char);

查

#查看当前的这张t1表
show create table t1;

# 查看全部的表
show tables;

# 查看表的详细信息
desc t1;

改

# modify修改的意思
alter table t1 modify name char(6);
# 改变name为大写的NAME
alter table t1 change name NAMA char(7);

删

# 删除表
drop table t1;

操做文件内容（记录）

增

# 插入一条数据，规定id，name数据leilei
insert t1(id,name) values(1,"mjj01"),(2,"mjj02"),(3,"mjj03");

查

select id from db1.t1;
select id,name from db1.t1;
select * from db1.t1;

改

update db1.t1 set name='zhangsan';
update db1.t1 set name='alex' where id=2;

删

delete from t1;
delete from t1 where id=2;

05-库的操做

本节重点：

掌握库的增删改查

1、系统数据库

执行以下命令，查看系统库

show databases;

information_schema：虚拟库，不占用磁盘空间，存储的是数据库启动后的一些参数，如用户表信息、列信息、权限信息、字符信息等
performance_schema： MySQL 5.5开始新增一个数据库：主要用于收集数据库服务器性能参数，记录处理查询请求时发生的各类事件、锁等现象
mysql：受权库，主要存储系统用户的权限信息
test： MySQL数据库系统自动建立的测试数据库

2、建立数据库

一、求救语法：

help create database;

二、建立数据库语法

CREATE DATABASE 数据库名 charset utf8;

三、数据库命名规则：

能够由字母、数字、下划线、＠、＃、＄
区分大小写
惟一性
不能使用关键字如 create select
不能单独使用数字
最长128位
# 基本上跟python或者js的命名规则同样

3、数据库相关操做

#查看数据库
show databases;
#查看当前库
show create database db1;
#查看所在的库
select database();

#选择数据库
use 数据库名

#删除数据库
DROP DATABASE 数据库名;
# 修改数据库
alter database db1 charset utf8;

4、了解内容

SQL语言主要用于存取数据、查询数据、更新数据和管理关系数据库系统,SQL语言由IBM开发。SQL语言分为3种类型：
一、DDL语句    数据库定义语言： 数据库、表、视图、索引、存储过程，例如CREATE DROP ALTER

二、DML语句    数据库操纵语言： 插入数据INSERT、删除数据DELETE、更新数据UPDATE、查询数据SELECT

三、DCL语句    数据库控制语言： 例如控制用户的访问权限GRANT、REVOKE

SQL语言主要用于存取数据、查询数据、更新数据和管理关系数据库系统,SQL语言由IBM开发。SQL语言分为3种类型：
一、DDL语句    数据库定义语言： 数据库、表、视图、索引、存储过程，例如CREATE DROP ALTER

二、DML语句    数据库操纵语言： 插入数据INSERT、删除数据DELETE、更新数据UPDATE、查询数据SELECT

三、DCL语句    数据库控制语言： 例如控制用户的访问权限GRANT、REVOKE

06-表的操做

本节掌握

存储引擎介绍（了解）
表的增删改查

1、存储引擎（了解）

前几节咱们知道mysql中创建的库===》文件夹，库中的表====》文件

现实生活中咱们用来存储数据的文件有不一样的类型，每种文件类型对应各自不一样的处理机制：好比处理文本用txt类型，处理表格用excel，处理图片用png等

数据库中的表也应该有不一样的类型，表的类型不一样，会对应mysql不一样的存取机制，表类型又称为存储引擎。

ps: 存储引擎说白了就是如何存储数据、如何为存储的数据创建索引和如何更新、查询数据等技术的实现方法。由于在关系数据库中数据的存储是以表的形式存储的，因此存储引擎也能够称为表类型（即存储和操做此表的类型）

在Oracle 和SQL Server等数据库中只有一种存储引擎，全部数据存储管理机制都是同样的。而MySql
数据库提供了多种存储引擎。用户能够根据不一样的需求为数据表选择不一样的存储引擎，用户也能够根据
本身的须要编写本身的存储引擎

SQL 解析器、SQL 优化器、缓冲池、存储引擎等组件在每一个数据库中都存在,但不是每个数据库都有这么多存储引擎。MySQL 的插件式存储引擎可让存储引擎层的开发人员设计他们但愿的存储层,例如,有的应用须要知足事务的要求,有的应用则不须要对事务有这么强的要求 ;有的但愿数据能持久存储,有的只但愿放在内存中,临时并快速地提供对数据的查询。

2、mysql支持的存储引擎

mysql> show engines\G;# 查看全部支持的引擎
mysql> show variables like 'storage_engine%'; # 查看正在使用的存储引擎

一、InnoDB 存储引擎

支持事务,其设计目标主要面向联机事务处理(OLTP)的应用。其

特色是行锁设计、支持外键,并支持相似 Oracle 的非锁定读,即默认读取操做不会产生锁。从 MySQL 5.5.8 版本开始是默认的存储引擎。

InnoDB 存储引擎将数据放在一个逻辑的表空间中,这个表空间就像黑盒同样由 InnoDB 存储引擎自身来管理。从 MySQL 4.1(包括 4.1)版本开始,能够将每一个 InnoDB 存储引擎的表单独存放到一个独立的 ibd 文件中。此外,InnoDB 存储引擎支持将裸设备(row disk)用于创建其表空间。

InnoDB 经过使用多版本并发控制(MVCC)来得到高并发性,而且实现了 SQL 标准的 4 种隔离级别,默认为 REPEATABLE 级别,同时使用一种称为 netx-key locking 的策略来避免幻读(phantom)现象的产生。除此以外,InnoDB 存储引擎还提供了插入缓冲(insert buffer)、二次写(double write)、自适应哈希索引(adaptive hash index)、预读(read ahead) 等高性能和高可用的功能。

对于表中数据的存储,InnoDB 存储引擎采用了汇集(clustered)的方式,每张表都是按主键的顺序进行存储的,若是没有显式地在表定义时指定主键,InnoDB 存储引擎会为每一行生成一个 6 字节的 ROWID,并以此做为主键。

InnoDB 存储引擎是 MySQL 数据库最为经常使用的一种引擎,Facebook、Google、Yahoo 等公司的成功应用已经证实了 InnoDB 存储引擎具有高可用性、高性能以及高可扩展性。对其底层实现的掌握和理解也须要时间和技术的积累。若是想深刻了解 InnoDB 存储引擎的工做原理、实现和应用,能够参考《MySQL 技术内幕:InnoDB 存储引擎》一书。

二、MyISAM 存储引擎

不支持事务、表锁设计、支持全文索引,主要面向一些 OLAP 数据库应用,在 MySQL 5.5.8 版本以前是默认的存储引擎(除 Windows 版本外)。数据库系统与文件系统一个很大的不一样在于对事务的支持,MyISAM 存储引擎是不支持事务的。究其根本,这也并不难理解。用户在全部的应用中是否都须要事务呢?在数据仓库中,若是没有 ETL 这些操做,只是简单地经过报表查询还须要事务的支持吗?此外,MyISAM 存储引擎的另外一个不同凡响的地方是,它的缓冲池只缓存(cache)索引文件,而不缓存数据文件,这与大多数的数据库都不相同。

三、NDB 存储引擎

年,MySQL AB 公司从 Sony Ericsson 公司收购了 NDB 存储引擎。 NDB 存储引擎是一个集群存储引擎,相似于 Oracle 的 RAC 集群,不过与 Oracle RAC 的 share everything 结构不一样的是,其结构是 share nothing 的集群架构,所以能提供更高级别的高可用性。NDB 存储引擎的特色是数据所有放在内存中(从 5.1 版本开始,能够将非索引数据放在磁盘上),所以主键查找(primary key lookups)的速度极快,而且可以在线添加 NDB 数据存储节点(data node)以便线性地提升数据库性能。因而可知,NDB 存储引擎是高可用、高性能、高可扩展性的数据库集群系统,其面向的也是 OLTP 的数据库应用类型。

四、Memory 存储引擎

正如其名,Memory 存储引擎中的数据都存放在内存中,数据库重启或发生崩溃,表中的数据都将消失。它很是适合于存储 OLTP 数据库应用中临时数据的临时表,也能够做为 OLAP 数据库应用中数据仓库的维度表。Memory 存储引擎默认使用哈希索引,而不是一般熟悉的 B+ 树索引。

五、Infobright 存储引擎

第三方的存储引擎。其特色是存储是按照列而非行的,所以很是适合 OLAP 的数据库应用。其官方网站是 http://www.infobright.org/,上面有很多成功的数据仓库案例可供分析。

六、NTSE 存储引擎

网易公司开发的面向其内部使用的存储引擎。目前的版本不支持事务, 但提供压缩、行级缓存等特性,不久的未来会实现面向内存的事务支持。

七、BLACKHOLE

黑洞存储引擎，能够应用于主备复制中的分发主库。

MySQL 数据库还有不少其余存储引擎,上述只是列举了最为经常使用的一些引擎。若是你喜欢,彻底能够编写专属于本身的引擎,这就是开源赋予咱们的能力,也是开源的魅力所在。

指定表类型/存储引擎

create table t1(id int)engine=innodb;# 默认不写就是innodb

小练习：

建立四张表，分别使用innodb,myisam,memory,blackhole存储引擎，进行插入数据测试

create table t1(id int)engine=innodb;
create table t2(id int)engine=myisam;
create table t3(id int)engine=memory;
create table t4(id int)engine=blackhole;

查看data文件下db1数据库中的文件：

#.frm是存储数据表的框架结构

# .ibd是mysql数据文件 

#.MYD是MyISAM表的数据文件的扩展名

#.MYI是MyISAM表的索引的扩展名

#发现后两种存储引擎只有表结构，无数据

#memory，在重启mysql或者重启机器后，表内数据清空
#blackhole，往表内插入任何数据，都至关于丢入黑洞，表内永远不存记录

3、表介绍

表至关于文件，表中的一条记录就至关于文件的一行内容，不一样的是，表中的一条记录有对应的标题，称为表的字段

id,name,sex,age,birth称为字段，其他的，一行内容称为一条记录

4、建立表

语法：

create table 表名(
字段名1 类型[(宽度) 约束条件],
字段名2 类型[(宽度) 约束条件],
字段名3 类型[(宽度) 约束条件]
);

#注意：
1. 在同一张表中，字段名是不能相同
2. 宽度和约束条件可选
3. 字段名和类型是必须的

1.建立数据库

create database db2 charset utf8;

2.使用数据库

use db2;

3.建立a1表

create table a1(
　　id int,
　　name varchar(50),
　　age int(3)
);

4.插入表的记录

insert into a1 values
(1,'mjj',18),
(2,'wusir',28);

ps:以；做为mysql的结束语

5.查询表的数据和结构

（1）查询a1表中的存储数据

mysql> select * from a1;
+------+-------+------+
| id | name | age |
+------+-------+------+
| 1 | mjj | 18 |
| 2 | wusir | 28 |
+------+-------+------+
2 rows in set (0.02 sec)

mysql>

（2）查看a1表的结构

mysql> desc a1;
+-------+-------------+------+-----+---------+-------+
| Field     | Type           | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+-------+
| id        | int(11)        | YES  |      | NULL    |       |
| name      | varchar(50)    | YES  |      | NULL    |       |
| age       | int(3)         | YES  |      | NULL    |       |
+-------+-------------+------+-----+---------+-------+
3 rows in set (0.16 sec)

（3）查看表的详细结构

mysql> show create table a1\G;
*************************** 1. row ***************************
       Table: a1
Create Table: CREATE TABLE `a1` (
  `id` int(11) DEFAULT NULL,
  `name` varchar(50) DEFAULT NULL,
  `age` int(3) DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8
1 row in set (0.00 sec)

6.复制表

（1）新建立一个数据库db3

mysql> create database db3 charset utf8;
Query OK, 1 row affected (0.00 sec)

（2）使用db3

mysql> use db3;
Database changed

#这是上个建立的db2数据库中的a1表
mysql> select * from db2.a1;
+------+-------+------+
| id   | name  | age  |
+------+-------+------+
|    1 | mjj   |   18 |
|    2 | wusir |   28 |
+------+-------+------+

（3）复制db2.a1的表结构和记录

# 这就是复制表的操做（既复制了表结构，又复制了记录）
mysql> create table b1 select * from db2.a1;
Query OK, 2 rows affected (0.03 sec)

（4）查看db3.b1中的数据和表结构

#再去查看db3文件夹下的b1表发现 跟db2文件下的a1表数据同样
mysql> select * from db3.b1;
+------+-------+------+
| id   | name  | age  |
+------+-------+------+
|    1 | mjj   |   18 |
|    2 | wusir |   28 |
+------+-------+------+
2 rows in set (0.00 sec)

ps1：若是只要表结构，不要记录

#在db2数据库下新建立一个b2表，给一个where条件，条件要求不成立，条件为false，只拷贝表结构
mysql> create table b2 select * from db2.a1 where 1>5;
Query OK, 0 rows affected (0.05 sec)
Records: 0  Duplicates: 0  Warnings: 0

查看表结构：

# 查看表结构
mysql> desc b2;
+-------+-------------+------+-----+---------+-------+
| Field | Type        | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+-------+
| id    | int(11)     | YES  |     | NULL    |       |
| name  | varchar(50) | YES  |     | NULL    |       |
| age   | int(3)      | YES  |     | NULL    |       |
+-------+-------------+------+-----+---------+-------+
3 rows in set (0.02 sec)

#查看表结构中的数据，发现是空数据
mysql> select * from b2;
Empty set (0.00 sec)

ps2:还有一种作法，使用like(只拷贝表结构，不拷贝记录)

mysql> create table b3 like db2.a1;
Query OK, 0 rows affected (0.01 sec)

mysql> desc b3;
+-------+-------------+------+-----+---------+-------+
| Field | Type        | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+-------+
| id    | int(11)     | YES  |     | NULL    |       |
| name  | varchar(50) | YES  |     | NULL    |       |
| age   | int(3)      | YES  |     | NULL    |       |
+-------+-------------+------+-----+---------+-------+
3 rows in set (0.02 sec)

mysql> select * from db3.b3;
Empty set (0.00 sec)

7.删除表：

drop table 表名;

07-数据类型

介绍

存储引擎决定了表的类型，而表内存放的数据也要有不一样的类型，每种数据类型都有本身的宽度，但宽度是可选的

详细参考连接：http://www.runoob.com/mysql/mysql-data-types.html

mysql经常使用数据类型归纳：

#1. 数字：
    整型：tinyint  int  bigint
    小数：
        float ：在位数比较短的状况下不精准
        double ：在位数比较长的状况下不精准
            0.000001230123123123
            存成：0.000001230000

        decimal：（若是用小数，则用推荐使用decimal）
            精准
            内部原理是以字符串形式去存

#2. 字符串：
    char（10）：简单粗暴，浪费空间，存取速度快
        　　　　root存成root000000
    varchar：精准，节省空间，存取速度慢

    sql优化：建立表时，定长的类型往前放，变长的日后放
                    好比性别           好比地址或描述信息

    >255个字符，超了就把文件路径存放到数据库中。
            好比图片，视频等找一个文件服务器，数据库中只存路径或url。


#3. 时间类型：
    最经常使用：datetime


#4. 枚举类型与集合类型
　　 enum 和set

1、数值类型

整数类型：TINYINT SMALLINT MEDIUMINT INT BIGINT

做用：存储年龄，等级，id，各类号码等

========================================
        tinyint[(m)] [unsigned] [zerofill]

            小整数，数据类型用于保存一些范围的整数数值范围：
            有符号：
                -128 ～ 127
            无符号：
                0 ～ 255

            PS： MySQL中无布尔值，使用tinyint(1)构造。



========================================
        int[(m)][unsigned][zerofill]

            整数，数据类型用于保存一些范围的整数数值范围：
            有符号：
                    -2147483648 ～ 2147483647
            无符号：
                    0 ～ 4294967295



========================================
        bigint[(m)][unsigned][zerofill]
            大整数，数据类型用于保存一些范围的整数数值范围：
            有符号：
                    -9223372036854775808 ～ 9223372036854775807
            无符号：
                    0  ～  18446744073709551615

验证1：有符号和无符号tinyint

============有符号tinyint==============
# 建立数据库db4
create database db4 charset utf8;

# 切换到当前db4数据库
mysql> use db4;

# 建立t1 规定x字段为tinyint数据类型（默认是有符号的）
mysql> create table t1(x tinyint);

# 验证，插入-1这个数
mysql>   insert into t1 values(-1);

# 查询 表记录，查询成功（证实默认是有符号类型）
mysql> select * from t1;
+------+
| x    |
+------+
| -1 |
+------+

#执行以下操做，会发现报错。由于有符号范围在(-128,127)
mysql>   insert into t1 values(-129),(128);
ERROR 1264 (22003): Out of range value for column 'x' at row 1


============无符号tinyint==============
# 建立表时定义记录的字符为无符号类型（0,255） ，使用unsigned
mysql> create table t2(x tinyint unsigned);

# 报错，超出范围
mysql>   insert into t2 values(-129);
ERROR 1264 (22003): Out of range value for column 'x' at row 1

# 插入成功
mysql>   insert into t2 values(255);
Query OK, 1 row affected (0.00 sec)

验证2：int类型后面的存储是显示宽度，而不是存储宽度

mysql> create table t3(id int(1) unsigned);

#插入255555记录也是能够的
mysql> insert into t3 values(255555);

mysql> select * from t3;
+--------+
| id     |
+--------+
| 255555 |
+--------+
ps:以上操做还不可以验证，再来一张表验证用zerofill 用0填充

# zerofill 用0填充
mysql> create table t4(id int(5) unsigned zerofill);


mysql> insert into t4 value(1);
Query OK, 1 row affected (0.00 sec)

#插入的记录是1，可是显示的宽度是00001
mysql> select * from t4;
+-------+
| id    |
+-------+
| 00001 |
+-------+
1 row in set (0.00 sec)

注意：为该类型指定宽度时，仅仅只是指定查询结果的显示宽度，与存储范围无关，存储范围以下

其实咱们彻底不必为整数类型指定显示宽度，使用默认的就能够了

默认的显示宽度，都是在最大值的基础上加1

int的存储宽度是4个Bytes，即32个bit，即2**32

无符号最大值为：4294967296-1

有符号最大值：2147483648-1

有符号和无符号的最大数字须要的显示宽度均为10，而针对有符号的最小值则须要11位才能显示彻底，因此int类型默认的显示宽度为11是很是合理的

最后：整形类型，其实没有必要指定显示宽度，使用默认的就ok

2、浮点型

定点数类型: DEC等同于DECIMAL

浮点类型：FLOAT DOUBLE

做用：存储薪资、身高、体重、体质参数等

语法：

-------------------------FLOAT-------------------
FLOAT[(M,D)] [UNSIGNED] [ZEROFILL]
#参数解释：单精度浮点数（非准确小数值），M是全长，D是小数点后个数。M最大值为255，D最大值为30

#有符号：
           -3.402823466E+38 to -1.175494351E-38,
           1.175494351E-38 to 3.402823466E+38

#无符号：
           1.175494351E-38 to 3.402823466E+38
#精确度： 
           **** 随着小数的增多，精度变得不许确 ****


 -------------------------DOUBLE-----------------------
DOUBLE[(M,D)] [UNSIGNED] [ZEROFILL]

#参数解释： 双精度浮点数（非准确小数值），M是全长，D是小数点后个数。M最大值为255，D最大值为30

#有符号：
           -1.7976931348623157E+308 to -2.2250738585072014E-308
           2.2250738585072014E-308 to 1.7976931348623157E+308

#无符号：
           2.2250738585072014E-308 to 1.7976931348623157E+308

#精确度：
           ****随着小数的增多，精度比float要高，但也会变得不许确 ****

======================================
--------------------DECIMAL------------------------
decimal[(m[,d])] [unsigned] [zerofill]

#参数解释：准确的小数值，M是整数部分总个数（负号不算），D是小数点后个数。 M最大值为65，D最大值为30。


#精确度：
           **** 随着小数的增多，精度始终准确 ****
           对于精确数值计算时须要用此类型
           decaimal可以存储精确值的缘由在于其内部按照字符串存储。

验证三种类型建表：

#1验证FLOAT类型建表：
mysql> create table t5(x float(256,31));
ERROR 1425 (42000): Too big scale 31 specified for column 'x'. Maximum is 30.
mysql> create table t5(x float(256,30));
ERROR 1439 (42000): Display width out of range for column 'x' (max = 255)
mysql> create table t5(x float(255,30)); #建表成功
Query OK, 0 rows affected (0.03 sec)

#2验证DOUBLE类型建表：
mysql> create table t6(x double(255,30)); #建表成功
Query OK, 0 rows affected (0.03 sec)

#3验证deimal类型建表：
mysql> create table t7(x decimal(66,31));
ERROR 1425 (42000): Too big scale 31 specified for column 'x'. Maximum is 30.
mysql> create table t7(x decimal(66,30));
ERROR 1426 (42000): Too big precision 66 specified for column 'x'. Maximum is 65.
mysql> create table t7(x decimal(65,30)); #建表成功
Query OK, 0 rows affected (0.00 sec)

验证三种类型的精度：

# 分别对三张表插入相应的记录
mysql> insert into t5 values(1.1111111111111111111111111111111);#小数点后31个1
Query OK, 1 row affected (0.01 sec)

mysql> insert into t6 values(1.1111111111111111111111111111111);
Query OK, 1 row affected (0.01 sec)

mysql> insert into t7 values(1.1111111111111111111111111111111);
Query OK, 1 row affected, 1 warning (0.00 sec)

# 查询结果
mysql> select * from t5; #随着小数的增多，精度开始不许确
+----------------------------------+
| x                                |
+----------------------------------+
| 1.111111164093017600000000000000 |
+----------------------------------+
1 row in set (0.00 sec)

mysql> select * from t6; #精度比float要准确点，但随着小数的增多，一样变得不许确
+----------------------------------+
| x                                |
+----------------------------------+
| 1.111111111111111200000000000000 |
+----------------------------------+
1 row in set (0.00 sec)

mysql> select * from t7; #精度始终准确,d为30，因而只留了30位小数
+----------------------------------+
| x                                |
+----------------------------------+
| 1.111111111111111111111111111111 |
+----------------------------------+
1 row in set (0.00 sec)

3、日期类型

DATE TIME DATETIME TIMESTAMP YEAR
做用：存储用户注册时间，文章发布时间，员工入职时间，出生时间，过时时间等

语法：
        YEAR
            YYYY（1901/2155）

        DATE
            YYYY-MM-DD（1000-01-01/9999-12-31）

        TIME
            HH:MM:SS（'-838:59:59'/'838:59:59'）

        DATETIME

            YYYY-MM-DD HH:MM:SS（1000-01-01 00:00:00/9999-12-31 23:59:59    Y）

        TIMESTAMP

            YYYYMMDD HHMMSS（1970-01-01 00:00:00/2037 年某时）

验证：

一、year

mysql> create table t8(born_year year);#不管year指定何种宽度，最后都默认是year(4)
Query OK, 0 rows affected (0.03 sec)

#插入失败，超出范围（1901/2155）
mysql>  insert into t8 values
    ->  (1900),
    -> (1901),
    ->  (2155),
    ->  (2156);
ERROR 1264 (22003): Out of range value for column 'born_year' at row 1


mysql> select * from t8;
Empty set (0.01 sec)


mysql> insert into t8 values
    -> (1905),
    -> (2018);
Query OK, 2 rows affected (0.00 sec) #插入记录成功
Records: 2  Duplicates: 0  Warnings: 0


mysql> select * from t8;
+-----------+
| born_year |
+-----------+
|      1905 |
|      2018 |
+-----------+
2 rows in set (0.00 sec)

二、date、year、datetime

#建立t9表
mysql> create table t9(d date,t time,dt datetime);
Query OK, 0 rows affected (0.06 sec)

#查看表的结构
mysql> desc t9;
+-------+----------+------+-----+---------+-------+
| Field | Type     | Null | Key | Default | Extra |
+-------+----------+------+-----+---------+-------+
| d     | date     | YES  |     | NULL    |       |
| t     | time     | YES  |     | NULL    |       |
| dt    | datetime | YES  |     | NULL    |       |
+-------+----------+------+-----+---------+-------+
3 rows in set (0.14 sec)


# 调用mysql自带的now()函数，获取当前类型指定的时间 以下结构
mysql> insert into t9 values(now(),now(),now());
Query OK, 1 row affected, 1 warning (0.01 sec)

mysql> select * from t9;
+------------+----------+---------------------+
| d          | t        | dt                  |
+------------+----------+---------------------+
| 2018-06-09 | 09:35:20 | 2018-06-09 09:35:20 |
+------------+----------+---------------------+
1 row in set (0.00 sec)

三、timestamp（了解便可）

mysql>  create table t10(time timestamp);
Query OK, 0 rows affected (0.06 sec)

mysql>  insert into t10 values();
Query OK, 1 row affected (0.00 sec)

mysql>  insert into t10 values(null);
Query OK, 1 row affected (0.00 sec)

mysql>  select * from t10;
+------+
| time |
+------+
| NULL |
| NULL |
+------+

mysql> insert into t10 values(now());
Query OK, 1 row affected (0.01 sec)

mysql> select * from t10;
+---------------------+
| time                |
+---------------------+
| 2018-06-09 09:44:48 |
+---------------------+
1 row in set (0.01 sec)

datetime与timestamp的区别

在实际应用的不少场景中，MySQL的这两种日期类型都可以知足咱们的须要，存储精度都为秒，但在某些状况下，会展示出他们各自的优劣。
下面就来总结一下两种日期类型的区别。

1.DATETIME的日期范围是1001——9999年，TIMESTAMP的时间范围是1970——2038年。

2.DATETIME存储时间与时区无关，TIMESTAMP存储时间与时区有关，显示的值也依赖于时区。在mysql服务器，
操做系统以及客户端链接都有时区的设置。

3.DATETIME使用8字节的存储空间，TIMESTAMP的存储空间为4字节。所以，TIMESTAMP比DATETIME的空间利用率更高。

4.DATETIME的默认值为null；TIMESTAMP的字段默认不为空（not null）,默认值为当前时间（CURRENT_TIMESTAMP），
若是不作特殊处理，而且update语句中没有指定该列的更新值，则默认更新为当前时间。

注意事项

============注意啦，注意啦，注意啦===========
#1. 单独插入时间时，须要以字符串的形式，按照对应的格式插入
#2. 插入年份时，尽可能使用4位值
#3. 插入两位年份时，<=69，以20开头，好比50,  结果2050      
                >=70，以19开头，好比71，结果1971
 create table t12(y year);
 insert into t12 values  (50),(71);
 select * from t12;
+------+
| y    |
+------+
| 2050 |
| 1971 |
+------+

综合练习：

建立一张学生表（student），要求有id,姓名，出生年份，出生的年月日，进班的时间，以及来老男孩学习的如今具体时间。

mysql> create table student(
    -> id int,
    -> name varchar(20),
    -> born_year year,
    -> birth date,
    -> class_time time,
    -> reg_time datetime
    -> );
Query OK, 0 rows affected (0.02 sec)

mysql> insert into student values
    ->   (1,'alex',"1995","1995-11-11","11:11:11","2017-11-11 11:11:11"),
    ->   (2,'egon',"1997","1997-12-12","12:12:12","2017-12-12 12:12:12"),
    ->   (3,'wsb',"1998","1998-01-01","13:13:13","2017-01-01 13:13:13");
Query OK, 3 rows affected (0.00 sec)
Records: 3  Duplicates: 0  Warnings: 0

mysql>   select * from student;
+------+------+-----------+------------+------------+---------------------+
| id   | name | born_year | birth      | class_time | reg_time            |
+------+------+-----------+------------+------------+---------------------+
|    1 | alex |      1995 | 1995-11-11 | 11:11:11   | 2017-11-11 11:11:11 |
|    2 | egon |      1997 | 1997-12-12 | 12:12:12   | 2017-12-12 12:12:12 |
|    3 | wsb  |      1998 | 1998-01-01 | 13:13:13   | 2017-01-01 13:13:13 |
+------+------+-----------+------------+------------+---------------------+
3 rows in set (0.00 sec)

08-数据类型(2)

本节重点

掌握char类型和varchar类型
掌握枚举类型和集合类型

字符类型

#官网：https://dev.mysql.com/doc/refman/5.7/en/char.html
#注意：char和varchar括号内的参数指的都是字符的长度

#char类型：定长，简单粗暴，浪费空间，存取速度快
    字符长度范围：0-255（一个中文是一个字符，是utf8编码的3个字节）
    存储：
        存储char类型的值时，会往右填充空格来知足长度
        例如：指定长度为10，存>10个字符则报错，存<10个字符则用空格填充直到凑够10个字符存储

    检索：
        在检索或者说查询时，查出的结果会自动删除尾部的空格，除非咱们打开pad_char_to_full_length SQL模式（设置SQL模式：SET sql_mode = 'PAD_CHAR_TO_FULL_LENGTH';
　　　　　　查询sql的默认模式：select @@sql_mode;）

#varchar类型：变长，精准，节省空间，存取速度慢
    字符长度范围：0-65535（若是大于21845会提示用其余类型 。mysql行最大限制为65535字节，字符编码为utf-8：https://dev.mysql.com/doc/refman/5.7/en/column-count-limit.html）
    存储：
        varchar类型存储数据的真实内容，不会用空格填充，若是'ab  ',尾部的空格也会被存起来
        强调：varchar类型会在真实数据前加1-2Bytes的前缀，该前缀用来表示真实数据的bytes字节数（1-2Bytes最大表示65535个数字，正好符合mysql对row的最大字节限制，即已经足够使用）
        若是真实的数据<255bytes则须要1Bytes的前缀（1Bytes=8bit 2**8最大表示的数字为255）
        若是真实的数据>255bytes则须要2Bytes的前缀（2Bytes=16bit 2**16最大表示的数字为65535）

    检索：
        尾部有空格会保存下来，在检索或者说查询时，也会正常显示包含空格在内的内容

官网解释以下：

验证：

验证以前了解两个函数：

length()：查看字节数
char_length():查看字符数

1.char填充空格来知足固定长度，可是在查询时却会很不要脸地删除尾部的空格（装做本身好像没有浪费过空间同样），而后修改sql_mode让其现出原形。

# 建立t1表,分别指明字段x为char类型，字段y为varchar类型
mysql> create table t1(x char(5),y varchar(4));
Query OK, 0 rows affected (0.16 sec)

# char存放的是5个字符，而varchar存4个字符
mysql>  insert into t1 values('你瞅啥 ','你瞅啥 ');
Query OK, 1 row affected (0.01 sec)

# 在检索时char很不要脸地将本身浪费的2个字符给删掉了，装的好像本身没浪费过空间同样，而varchar很老实，存了多少，就显示多少
mysql> select x,char_length(x),y,char_length(y) from t1;
+-----------+----------------+------------+----------------+
| x         | char_length(x) | y          | char_length(y) |
+-----------+----------------+------------+----------------+
| 你瞅啥    |              3 | 你瞅啥     |              4 |
+-----------+----------------+------------+----------------+
1 row in set (0.02 sec)

 #略施小计，让char现原形
 mysql> SET sql_mode = 'PAD_CHAR_TO_FULL_LENGTH';
Query OK, 0 rows affected (0.00 sec)

#查看当前mysql的mode模式
mysql> select @@sql_mode;
+-------------------------+
| @@sql_mode              |
+-------------------------+
| PAD_CHAR_TO_FULL_LENGTH |
+-------------------------+
1 row in set (0.00 sec)

#原形毕露了吧。。。。
mysql> select x,char_length(x) y,char_length(y) from t1;
+-------------+------+----------------+
| x           | y    | char_length(y) |
+-------------+------+----------------+
| 你瞅啥      |    5 |              4 |
+-------------+------+----------------+
1 row in set (0.00 sec)

# 查看字节数
#char类型：3个中文字符+2个空格=11Bytes
#varchar类型:3个中文字符+1个空格=10Bytes
mysql> select x,length(x),y,length(y) from t1;
+-------------+-----------+------------+-----------+
| x           | length(x) | y          | length(y) |
+-------------+-----------+------------+-----------+
| 你瞅啥      |        11 | 你瞅啥     |        10 |
+-------------+-----------+------------+-----------+
1 row in set (0.02 sec)

总结：

#经常使用字符串系列：char与varchar
注：虽然varchar使用起来较为灵活，可是从整个系统的性能角度来讲，char数据类型的处理速度更快，有时甚至能够超出varchar处理速度的50%。所以，用户在设计数据库时应当综合考虑各方面的因素，以求达到最佳的平衡

#其余字符串系列（效率：char>varchar>text）
TEXT系列 TINYTEXT TEXT MEDIUMTEXT LONGTEXT
BLOB 系列    TINYBLOB BLOB MEDIUMBLOB LONGBLOB 
BINARY系列 BINARY VARBINARY

text：text数据类型用于保存变长的大字符串，能够组多到65535 (2**16 − 1)个字符。
mediumtext：A TEXT column with a maximum length of 16,777,215 (2**24 − 1) characters.
longtext：A TEXT column with a maximum length of 4,294,967,295 or 4GB (2**32 − 1) characters.

枚举类型和集合类型

字段的值只能在给定范围中选择，如单选框，多选框

enum 单选只能在给定的范围内选一个值，如性别 sex 男male/女female

set 多选在给定的范围内能够选择一个或一个以上的值（爱好1,爱好2,爱好3...）

mysql> create table consumer(
    -> id int,
    -> name varchar(50),
    -> sex enum('male','female','other'),
    -> level enum('vip1','vip2','vip3','vip4'),#在指定范围内，多选一
    -> fav set('play','music','read','study') #在指定范围内，多选多
    -> );
Query OK, 0 rows affected (0.03 sec)


mysql> insert into consumer values
    -> (1,'赵云','male','vip2','read,study'),
    -> (2,'赵云2','other','vip4','play');
Query OK, 2 rows affected (0.00 sec)
Records: 2  Duplicates: 0  Warnings: 0

mysql> select * from consumer;
+------+---------+-------+-------+------------+
| id   | name    | sex   | level | fav        |
+------+---------+-------+-------+------------+
|    1 | 赵云    | male  | vip2  | read,study |
|    2 | 赵云2   | other | vip4  | play       |
+------+---------+-------+-------+------------+
2 rows in set (0.00 sec)

09-完整性约束

本节重点：

not null 与 default
unique
primary
auto_increment
foreign key

1、介绍

约束条件与数据类型的宽度同样，都是可选参数

做用：用于保证数据的完整性和一致性

主要分为：

PRIMARY KEY (PK)    #标识该字段为该表的主键，能够惟一的标识记录
FOREIGN KEY (FK)    #标识该字段为该表的外键
NOT NULL    #标识该字段不能为空
UNIQUE KEY (UK)    #标识该字段的值是惟一的
AUTO_INCREMENT    #标识该字段的值自动增加（整数类型，并且为主键）
DEFAULT    #为该字段设置默认值

UNSIGNED #无符号
ZEROFILL #使用0填充

说明：

#1. 是否容许为空，默认NULL，可设置NOT NULL，字段不容许为空，必须赋值
#2. 字段是否有默认值，缺省的默认值是NULL，若是插入记录时不给字段赋值，此字段使用默认值
sex enum('male','female') not null default 'male'

#必须为正值（无符号） 不容许为空 默认是20
age int unsigned NOT NULL default 20 
# 3. 是不是key
主键 primary key
外键 foreign key
索引 (index,unique...)

2、not null 与default

是否可空，null表示空，非字符串
not null - 不可空
null - 可空

默认值，建立列时能够指定默认值，当插入数据时若是未主动设置，则自动添加默认值

create table tb1(
    nid int not null defalut 2,
    num int not null

);

验证1：

mysql> create table t11(id int);# id字段默承认觉得空
Query OK, 0 rows affected (0.05 sec)

mysql> desc t11;
+-------+---------+------+-----+---------+-------+
| Field | Type    | Null | Key | Default | Extra |
+-------+---------+------+-----+---------+-------+
| id    | int(11) | YES   |          | NULL    |       |
+-------+---------+------+-----+---------+-------+
1 row in set (0.03 sec)
mysql> insert into t11 values(); #给t11表插一个空的值
Query OK, 1 row affected (0.00 sec)

#查询结果以下
mysql> select * from t11;
+------+
| id   |
+------+
| NULL |
+------+
1 row in set (0.00 sec)

验证2：

mysql> create table t12(id int not null);#设置字段id不为空
Query OK, 0 rows affected (0.03 sec)

mysql> desc t12;
+-------+---------+------+-----+---------+-------+
| Field | Type    | Null | Key | Default | Extra |
+-------+---------+------+-----+---------+-------+
| id    | int(11) | NO   |     | NULL    |       |
+-------+---------+------+-----+---------+-------+
1 row in set (0.01 sec)

mysql> insert into t12 values();#不能插入空
ERROR 1364 (HY000): Field 'id' doesn't have a default value

验证3：

# 第一种状况
mysql> create table t13(id int default 1);
Query OK, 0 rows affected (0.03 sec)

mysql> desc t13;
+-------+---------+------+-----+---------+-------+
| Field | Type    | Null | Key | Default | Extra |
+-------+---------+------+-----+---------+-------+
| id    | int(11) | YES  |           | 1              |              |
+-------+---------+------+-----+---------+-------+
1 row in set (0.01 sec)

mysql> insert into t13 values();
Query OK, 1 row affected (0.00 sec)

mysql> select * from t13;
+------+
| id   |
+------+
|    1  |
+------+
1 row in set (0.00 sec)


# 第二种状况
mysql> create table t14(id int not null default 2);
Query OK, 0 rows affected (0.02 sec)

mysql> desc t14;
+-------+---------+------+-----+---------+-------+
| Field | Type    | Null | Key | Default | Extra |
+-------+---------+------+-----+---------+-------+
| id    | int(11) | NO      |         | 2               |             |
+-------+---------+------+-----+---------+-------+
1 row in set (0.01 sec)

mysql> select * from t14;
+----+
| id |
+----+
|  2 |
+----+
1 row in set (0.00 sec)

小练习：

建立学生表student2，设置每一个字段的约束条件。

mysql> create table student2(
    -> id int not null,
    -> name varchar(50) not null,
    -> age int(3) unsigned not null default 18,
    -> sex enum('male','female') default 'male',
    -> fav set('smoke','drink','tangtou') default 'drink,tangtou'
    -> );
Query OK, 0 rows affected (0.01 sec)

# 只插入了not null约束条件的字段对应的值
mysql> insert into student2(id,name) values(1,'mjj');
Query OK, 1 row affected (0.00 sec)

# 查询结果以下
mysql> select * from student2;
+----+------+-----+------+---------------+
| id | name | age | sex  | fav           |
+----+------+-----+------+---------------+
|  1 | mjj  |  18 | male | drink,tangtou |
+----+------+-----+------+---------------+
1 row in set (0.00 sec)

三、unique

中文翻译：不一样的。在mysql中称为单列惟一

举例说明：建立公司部门表（每一个公司都有惟一的一个部门）。

mysql> create table department(
    -> id int,
    -> name char(10)
    -> );
Query OK, 0 rows affected (0.01 sec)

mysql> insert into department values(1,'IT'),(2,'IT');
Query OK, 2 rows affected (0.00 sec)
Records: 2  Duplicates: 0  Warnings: 0

mysql> select * from department;
+------+------+
| id   | name |
+------+------+
|    1 | IT   |
|    2 | IT   |
+------+------+
2 rows in set (0.00 sec)
# 发现： 同时插入两个IT部门也是能够的，但这是不合理的，因此咱们要设置name字段为unique 解决这种不合理的现象。

接下来，使用约束条件unique，来对公司部门的字段进行设置。

#第一种建立unique的方式
#例子1：
create table department(
    id int,
    name char(10) unique
);
mysql> insert into department values(1,'it'),(2,'it');
ERROR 1062 (23000): Duplicate entry 'it' for key 'name'

#例子2：
create table department(
    id int unique,
    name char(10) unique
);
insert into department values(1,'it'),(2,'sale');

#第二种建立unique的方式
create table department(
    id int,
    name char(10) ,
    unique(id),
    unique(name)
);
insert into department values(1,'it'),(2,'sale');

联合惟一：

# 建立services表
mysql> create table services(
    -> id int,
    -> ip char(15),
    -> port int,
    -> unique(id),
    -> unique(ip,port)
    -> );
Query OK, 0 rows affected (0.05 sec)

mysql> desc services;
+-------+----------+------+-----+---------+-------+
| Field | Type      | Null | Key | Default | Extra |
+-------+----------+------+-----+---------+-------+
| id        | int(11)   | YES   | UNI  | NULL       |             |
| ip        | char(15) | YES   | MUL  | NULL       |             |
| port    | int(11) | YES   |          | NULL       |             |
+-------+----------+------+-----+---------+-------+
3 rows in set (0.01 sec)

#联合惟一，只要两列记录，有一列不一样，既符合联合惟一的约束
mysql> insert into services values
    -> (1,'192,168,11,23',80),
    -> (2,'192,168,11,23',81),
    -> (3,'192,168,11,25',80);
Query OK, 3 rows affected (0.01 sec)
Records: 3  Duplicates: 0  Warnings: 0

mysql> select * from services;
+------+---------------+------+
| id   | ip            | port |
+------+---------------+------+
|    1 | 192,168,11,23 |   80 |
|    2 | 192,168,11,23 |   81 |
|    3 | 192,168,11,25 |   80 |
+------+---------------+------+
3 rows in set (0.00 sec)

mysql> insert into services values (4,'192,168,11,23',80);
ERROR 1062 (23000): Duplicate entry '192,168,11,23-80' for key 'ip'

4.primary key

一个表中能够：

单列作主键
多列作主键（复合主键）

约束：等价于 not null unique,字段的值不为空且惟一

存储引擎默认是（innodb）:对于innodb存储引擎来讲，一张表必须有一个主键。

单列主键

# 建立t14表，为id字段设置主键，惟一的不一样的记录
create table t14(
    id int primary key,
    name char(16)
);

insert into t14 values
(1,'xiaoma'),
(2,'xiaohong');

mysql> insert into t14 values(2,'wxxx');
ERROR 1062 (23000): Duplicate entry '6' for key 'PRIMARY'


#   not null + unique的化学反应，至关于给id设置primary key
create table t15(
    id int not null unique,
    name char(16)
);
mysql> create table t15(
    -> id int not null unique,
    -> name char(16)
    -> );
Query OK, 0 rows affected (0.01 sec)

mysql> desc t15;
+-------+----------+------+-----+---------+-------+
| Field | Type         | Null | Key | Default | Extra |
+-------+----------+------+-----+---------+-------+
| id        | int(11)  | NO     | PRI | NULL       |             |
| name   | char(16) | YES  |         | NULL       |             |
+-------+----------+------+-----+---------+-------+
2 rows in set (0.02 sec)

复合主键

create table t16(
    ip char(15),
    port int,
    primary key(ip,port)
);

insert into t16 values
('1.1.1.2',80),
('1.1.1.2',81);

5.auto_increment

约束:约束的字段为自动增加，约束的字段必须同时被key约束

（重点）验证：

# 建立student
create table student(
id int primary key auto_increment,
name varchar(20),
sex enum('male','female') default 'male'
);

mysql>  desc student;
+-------+-----------------------+------+-----+---------+----------------+
| Field | Type                  | Null | Key | Default | Extra          |
+-------+-----------------------+------+-----+---------+----------------+
| id    | int(11)               | NO   | PRI | NULL    | auto_increment |
| name  | varchar(20)           | YES  |     | NULL    |                |
| sex   | enum('male','female') | YES  |     | male    |                |
+-------+-----------------------+------+-----+---------+----------------+
3 rows in set (0.17 sec)

#插入记录
mysql>  insert into student(name) values ('老白'),('小白');
Query OK, 2 rows affected (0.01 sec)
Records: 2  Duplicates: 0  Warnings: 0

mysql> select * from student;
+----+--------+------+
| id | name   | sex  |
+----+--------+------+
|  1 | 老白   | male |
|  2 | 小白   | male |
+----+--------+------+
2 rows in set (0.00 sec)

mysql> insert into student values(4,'asb','female');
Query OK, 1 row affected (0.00 sec)

mysql> insert into student values(7,'wsb','female');
Query OK, 1 row affected (0.01 sec)

mysql> select * from student;
+----+--------+--------+
| id | name   | sex    |
+----+--------+--------+
|  1 | 老白   | male   |
|  2 | 小白   | male   |
|  4 | asb    | female |
|  7 | wsb    | female |
+----+--------+--------+
4 rows in set (0.00 sec)

# 再次插入一条不指定id的记录，会在以前的最后一条记录继续增加
mysql>  insert into student(name) values ('大白');
Query OK, 1 row affected (0.00 sec)

mysql> select * from student;
+----+--------+--------+
| id | name   | sex    |
+----+--------+--------+
|  1 | 老白   | male   |
|  2 | 小白   | male   |
|  4 | asb    | female |
|  7 | wsb    | female |
|  8 | 大白   | male   |
+----+--------+--------+
5 rows in set (0.00 sec)

mysql> delete from student;
Query OK, 5 rows affected (0.00 sec)

mysql> select * from student;
Empty set (0.00 sec)

mysql> select * from student;
Empty set (0.00 sec)

mysql> insert into student(name) values('ysb');
Query OK, 1 row affected (0.01 sec)

mysql> select * from student;
+----+------+------+
| id | name | sex  |
+----+------+------+
|  9 | ysb  | male |
+----+------+------+
1 row in set (0.00 sec)

#应该用truncate清空表，比起delete一条一条地删除记录，truncate是直接清空表，在删除大表时用它
mysql> truncate student;
Query OK, 0 rows affected (0.03 sec)

mysql>  insert into student(name) values('xiaobai');
Query OK, 1 row affected (0.00 sec)

mysql> select * from student;
+----+---------+------+
| id | name    | sex  |
+----+---------+------+
|  1 | xiaobai | male |
+----+---------+------+
1 row in set (0.00 sec)

mysql>

了解：

查看可用的 开头auto_inc的词
mysql> show variables like 'auto_inc%';
+--------------------------+-------+
| Variable_name            | Value |
+--------------------------+-------+
| auto_increment_increment | 1     |
| auto_increment_offset    | 1     |
+--------------------------+-------+
2 rows in set (0.02 sec)
# 步长auto_increment_increment,默认为1
# 起始的偏移量auto_increment_offset, 默认是1

 # 设置步长 为会话设置，只在本次链接中有效
 set session auto_increment_increment=5;

 #全局设置步长 都有效。
 set global auto_increment_increment=5;

 # 设置起始偏移量
 set global  auto_increment_offset=3;

#强调：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的值大于auto_increment_increment的值，则auto_increment_offset的值会被忽略 

# 设置完起始偏移量和步长以后，再次执行show variables like'auto_inc%';
发现跟以前同样，必须先exit,再登陆才有效。

mysql> show variables like'auto_inc%';
+--------------------------+-------+
| Variable_name            | Value |
+--------------------------+-------+
| auto_increment_increment | 5     |
| auto_increment_offset    | 3     |
+--------------------------+-------+
2 rows in set (0.00 sec)

#由于以前有一条记录id=1
mysql> select * from student;
+----+---------+------+
| id | name    | sex  |
+----+---------+------+
|  1 | xiaobai | male |
+----+---------+------+
1 row in set (0.00 sec)
# 下次插入的时候，从起始位置3开始，每次插入记录id+5
mysql> insert into student(name) values('ma1'),('ma2'),('ma3');
Query OK, 3 rows affected (0.00 sec)
Records: 3  Duplicates: 0  Warnings: 0

mysql> select * from student;
+----+---------+------+
| id | name    | sex  |
+----+---------+------+
|  1 | xiaobai | male |
|  3 | ma1     | male |
|  8 | ma2     | male |
| 13 | ma3     | male |
+----+---------+------+

清空表区分delete和truncate的区别：

delete from t1; #若是有自增id，新增的数据，仍然是以删除前的最后同样做为起始。

truncate table t1;数据量大，删除速度比上一条快，且直接从零开始。

6.foreign key

一快速理解foreign key

以前建立表的时候都是在一张表中添加记录，好比以下表：

公司有3个部门，可是有1个亿的员工，那意味着部门这个字段须要重复存储，部门名字越长，越浪费。

这个时候，

解决方法：

咱们彻底能够定义一个部门表

而后让员工信息表关联该表，如何关联，即foreign key

咱们能够将上表改成以下结构：

此时有两张表，一张是employee表,简称emp表（关联表，也就从表）。一张是department表，简称dep表（被关联表，也叫主表）。

建立两张表操做：

#1.建立表时先建立被关联表，再建立关联表
# 先建立被关联表（dep表）
create table dep(
    id int primary key,
    name varchar(20) not null,
    descripe varchar(20) not null
);

#再建立关联表（emp表）
create table emp(
    id int primary key,
    name varchar(20) not null,
    age int not null,
    dep_id int,
    constraint fk_dep foreign key(dep_id) references dep(id) 
);

#2.插入记录时，先往被关联表中插入记录，再往关联表中插入记录

insert into dep values
(1,'IT','IT技术有限部门'),
(2,'销售部','销售部门'),
(3,'财务部','花钱太多部门');

insert into emp values
(1,'zhangsan',18,1),
(2,'lisi',19,1),
(3,'egon',20,2),
(4,'yuanhao',40,3),
(5,'alex',18,2);

3.删除表
#按道理来讲，删除了部门表中的某个部门，员工表的有关联的记录相继删除。
mysql> delete from dep where id=3;
ERROR 1451 (23000): Cannot delete or update a parent row: a foreign key constraint fails (`db5`.`emp`, CONSTRAINT `fk_name` FOREIGN KEY (`dep_id`) REFERENCES `dep` (`id`))

#可是先删除员工表的记录以后，再删除当前部门就没有任何问题

mysql> delete from emp where dep =3;
Query OK, 1 row affected (0.00 sec)

mysql> select * from emp;
+----+----------+-----+--------+
| id | name     | age | dep_id |
+----+----------+-----+--------+
|  1 | zhangsan |  18 |      1 |
|  2 | lisi     |  18 |      1 |
|  3 | egon     |  20 |      2 |
|  5 | alex     |  18 |      2 |
+----+----------+-----+--------+
4 rows in set (0.00 sec)

mysql> delete from dep where id=3;
Query OK, 1 row affected (0.00 sec)

mysql> select * from dep;
+----+-----------+----------------------+
| id | name      | descripe             |
+----+-----------+----------------------+
|  1 | IT        | IT技术有限部门       |
|  2 | 销售部    | 销售部门             |
+----+-----------+----------------------+
2 rows in set (0.00 sec)

上面的删除表记录的操做比较繁琐，按道理讲，裁掉一个部门，该部门的员工也会被裁掉。其实呢，在建表的时候还有个很重要的内容，叫同步删除，同步更新

接下来将刚建好的两张表所有删除，先删除关联表（emp）,再删除被关联表（dep）

接下来：
重复上面的操做建表
注意：在关联表中加入
on delete cascade #同步删除
on update cascade #同步更新

修改emp表：

create table emp(
    id int primary key,
    name varchar(20) not null,
    age int not null,
    dep_id int,
    constraint fk_dep foreign key(dep_id) references dep(id) 
    on delete cascade #同步删除
    on update cascade #同步更新
);

接下来的操做，就复合咱们正常的生活中的状况了。

#再去删被关联表(dep)的记录，关联表(emp)中的记录也跟着删除
mysql> delete from dep where id=3;
Query OK, 1 row affected (0.00 sec)

mysql> select * from dep;
+----+-----------+----------------------+
| id | name      | descripe             |
+----+-----------+----------------------+
|  1 | IT        | IT技术有限部门       |
|  2 | 销售部    | 销售部门             |
+----+-----------+----------------------+
2 rows in set (0.00 sec)

mysql> select * from emp;
+----+----------+-----+--------+
| id | name     | age | dep_id |
+----+----------+-----+--------+
|  1 | zhangsan |  18 |      1 |
|  2 | lisi     |  19 |      1 |
|  3 | egon     |  20 |      2 |
|  5 | alex     |  18 |      2 |
+----+----------+-----+--------+
4 rows in set (0.00 sec)

#再去更改被关联表(dep)的记录，关联表(emp)中的记录也跟着更改

mysql> update dep set id=222 where id=2;
Query OK, 1 row affected (0.02 sec)
Rows matched: 1  Changed: 1  Warnings: 0

# 赶忙去查看一下两张表是否都被删除了，是否都被更改了
mysql> select * from dep;
+-----+-----------+----------------------+
| id  | name      | descripe             |
+-----+-----------+----------------------+
|   1 | IT        | IT技术有限部门       |
| 222 | 销售部    | 销售部门             |
+-----+-----------+----------------------+
2 rows in set (0.00 sec)

mysql> select * from emp;
+----+----------+-----+--------+
| id | name     | age | dep_id |
+----+----------+-----+--------+
|  1 | zhangsan |  18 |      1 |
|  2 | lisi     |  19 |      1 |
|  3 | egon     |  20 |    222 |
|  5 | alex     |  18 |    222 |
+----+----------+-----+--------+
4 rows in set (0.00 sec)

10-外键的变种三种关系

本节重点：

如何找出两张表之间的关系
表的三种关系

1、介绍

由于有foreign key的约束，使得两张表造成了三种了关系：

多对一
多对多
一对一

2、重点理解若是找出两张表之间的关系

分析步骤：
#一、先站在左表的角度去找
是否左表的多条记录能够对应右表的一条记录，若是是，则证实左表的一个字段foreign key 右表一个字段（一般是id）

#二、再站在右表的角度去找
是否右表的多条记录能够对应左表的一条记录，若是是，则证实右表的一个字段foreign key 左表一个字段（一般是id）

#三、总结：
#多对一：
若是只有步骤1成立，则是左表多对一右表
若是只有步骤2成立，则是右表多对一左表

#多对多
若是步骤1和2同时成立，则证实这两张表时一个双向的多对一，即多对多,须要定义一个这两张表的关系表来专门存放两者的关系

#一对一:
若是1和2都不成立，而是左表的一条记录惟一对应右表的一条记录，反之亦然。这种状况很简单，就是在左表foreign key右表的基础上，将左表的外键字段设置成unique便可

3、表的三种关系

（1）书和出版社

　　一对多（或多对一）：一个出版社能够出版多本书。看图说话。

　　关联方式：foreign key

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,
         constraint fk_book_press foreign key(press_id) references press(id)
    on delete cascade
    on update cascade
);

# 先往被关联表中插入记录
insert into press(name) values
('北京工业地雷出版社'),
('人民音乐很差听出版社'),
('知识产权没有用出版社')
;

# 再往关联表中插入记录
insert into book(name,press_id) values
('九阳神功',1),
('九阴真经',2),
('九阴白骨爪',2),
('独孤九剑',3),
('降龙十巴掌',2),
('葵花宝典',3)
;

查询结果：
mysql> select * from book;
+----+-----------------+----------+
| id | name            | press_id |
+----+-----------------+----------+
|  1 | 九阳神功        |        1 |
|  2 | 九阴真经        |        2 |
|  3 | 九阴白骨爪      |        2 |
|  4 | 独孤九剑        |        3 |
|  5 | 降龙十巴掌      |        2 |
|  6 | 葵花宝典        |        3 |
+----+-----------------+----------+
6 rows in set (0.00 sec)

mysql> select * from press;
+----+--------------------------------+
| id | name                           |
+----+--------------------------------+
|  1 | 北京工业地雷出版社             |
|  2 | 人民音乐很差听出版社           |
|  3 | 知识产权没有用出版社           |
+----+--------------------------------+
3 rows in set (0.00 sec)

（2）做者和书籍的关系

　　多对多：一个做者能够写多本书，一本书也能够有多个做者，双向的一对多，即多对多。看图说话。

　　关联方式：foreign key+一张新的表

# 建立被关联表author表，以前的book表在讲多对一的关系已建立
create table author(
    id int primary key auto_increment,
    name varchar(20)
);
#这张表就存放了author表和book表的关系，即查询两者的关系查这表就能够了
create table author2book(
    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)
);
#插入四个做者，id依次排开
insert into author(name) values('egon'),('alex'),('wusir'),('yuanhao');

# 每一个做者的表明做
egon: 九阳神功、九阴真经、九阴白骨爪、独孤九剑、降龙十巴掌、葵花宝典
alex: 九阳神功、葵花宝典
wusir:独孤九剑、降龙十巴掌、葵花宝典
yuanhao:九阳神功

# 在author2book表中插入相应的数据

insert into author2book(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)
;
# 如今就能够查author2book对应的做者和书的关系了
mysql> select * from author2book;
+----+-----------+---------+
| id | author_id | book_id |
+----+-----------+---------+
|  1 |         1 |       1 |
|  2 |         1 |       2 |
|  3 |         1 |       3 |
|  4 |         1 |       4 |
|  5 |         1 |       5 |
|  6 |         1 |       6 |
|  7 |         2 |       1 |
|  8 |         2 |       6 |
|  9 |         3 |       4 |
| 10 |         3 |       5 |
| 11 |         3 |       6 |
| 12 |         4 |       1 |
+----+-----------+---------+
12 rows in set (0.00 sec)

（3）用户和博客

　　一对一：一个用户只能注册一个博客，即一对一的关系。看图说话

　　关联方式：foreign key+unique

#例如： 一个用户只能注册一个博客

#两张表： 用户表 （user）和 博客表(blog)
# 建立用户表
create table user(
    id int primary key auto_increment,
    name varchar(20)
);
# 建立博客表
create table blog(
    id int primary key auto_increment,
    url varchar(100),
    user_id int unique,
    constraint fk_user foreign key(user_id) references user(id)
    on delete cascade
    on update cascade
);
#插入用户表中的记录
insert into user(name) values
('alex'),
('wusir'),
('egon'),
('xiaoma')
;
# 插入博客表的记录
insert into blog(url,user_id) values
('http://www.cnblog/alex',1),
('http://www.cnblog/wusir',2),
('http://www.cnblog/egon',3),
('http://www.cnblog/xiaoma',4)
;
# 查询wusir的博客地址
select url from blog where user_id=2;

11-数据的增删改

本节重点：

插入数据 INSERT
更新数据 UPDATE
删除数据 DELETE

再来回顾一下以前咱们练过的一些操做，相信你们都对插入数据、更新数据、删除数据有了全面的认识。那么在mysql中其实最重要的不是这三大操做，而是查数据最重要，下节课知晓

1、
在MySQL管理软件中，能够经过SQL语句中的DML语言来实现数据的操做，包括

1.使用INSERT实现数据的插入
2.UPDATE实现数据的更新
3.使用DELETE实现数据的删除
4.使用SELECT查询数据以及。


2、插入数据 INSERT
1. 插入完整数据（顺序插入）
    语法一：
    INSERT INTO 表名(字段1,字段2,字段3…字段n) VALUES(值1,值2,值3…值n);

    语法二：
    INSERT INTO 表名 VALUES (值1,值2,值3…值n);

2. 指定字段插入数据
    语法：
    INSERT INTO 表名(字段1,字段2,字段3…) VALUES (值1,值2,值3…);

3. 插入多条记录
    语法：
    INSERT INTO 表名 VALUES
        (值1,值2,值3…值n),
        (值1,值2,值3…值n),
        (值1,值2,值3…值n);

 4. 插入查询结果
    语法：
    INSERT INTO 表名(字段1,字段2,字段3…字段n) 
                    SELECT (字段1,字段2,字段3…字段n) FROM 表2
                    WHERE …;

3、更新数据UPDATE
语法：
    UPDATE 表名 SET
        字段1=值1,
        字段2=值2,
        WHERE CONDITION;

示例：
    UPDATE mysql.user SET password=password(‘123’) 
        where user=’root’ and host=’localhost’;
4、删除数据DELETE
语法：
    DELETE FROM 表名 
        WHERE CONITION;

示例：
    DELETE FROM mysql.user 
        WHERE password=’’;

12-单表查询

本节重点：

　　单表查询

语法：

1、单表查询的语法
   SELECT 字段1,字段2... FROM 表名
                  WHERE 条件
                  GROUP BY field
                  HAVING 筛选
                  ORDER BY field
                  LIMIT 限制条数
2、关键字的执行优先级（重点）

重点中的重点：关键字的执行优先级
from
where
group by
having
select
distinct
order by
limit

1.找到表:from

2.拿着where指定的约束条件，去文件/表中取出一条条记录

3.将取出的一条条记录进行分组group by，若是没有group by，则总体做为一组

4.将分组的结果进行having过滤

5.执行select

6.去重

7.将结果按条件排序：order by

8.限制结果的显示条数

建立公司员工表，表的字段和数据类型

company.employee
    员工id          id                          int                  
    姓名            name                        varchar                                                             
    性别            sex                         enum                                                                  
    年龄            age                         int
    入职日期         hire_date                   date
    岗位            post                        varchar
    职位描述         post_comment         　　　　varchar
    薪水            salary                　　　 double
    办公室           office                     int
    部门编号         depart_id                   int

#建立表,设置字段的约束条件
create table employee(
    id int primary key auto_increment,
    name  varchar(20) not null,
    sex enum('male','female') not null default 'male', #大部分是男的
    age int(3) unsigned not null default 28,
    hire_date date not null,
    post varchar(50),
    post_comment varchar(100),
    salary  double(15,2),
    office int,#一个部门一个屋
    depart_id int
);
# 查看表结构
mysql> desc employee;
+--------------+-----------------------+------+-----+---------+----------------+
| Field                | Type                              | Null | Key     | Default | Extra          |
+--------------+-----------------------+------+-----+---------+----------------+
| id                      | int(11)                            | NO   | PRI     | NULL    | auto_increment |
| emp_name             | varchar(20)                   | NO   |             | NULL    |                |
| sex                  | enum('male','female')   | NO   |             | male    |                |
| age                  | int(3) unsigned               | NO   |             | 28         |                |
| hire_date        | date                              | NO   |             | NULL    |                |
| post                 | varchar(50)                   | YES  |         | NULL    |                |
| post_comment     | varchar(100)                  | YES  |         | NULL    |                |
| salart               | double(15,2)                  | YES  |         | NULL    |                |
| office              | int(11)                           | YES  |         | NULL    |                |
| depart_id        | int(11)                           | YES  |         | NULL    |                |
+--------------+-----------------------+------+-----+---------+----------------+
10 rows in set (0.08 sec)

#插入记录
#三个部门：教学，销售，运营
insert into employee(name ,sex,age,hire_date,post,salary,office,depart_id) values
('egon','male',18,'20170301','老男孩驻沙河办事处外交大使',7300.33,401,1), #如下是教学部
('alex','male',78,'20150302','teacher',1000000.31,401,1),
('wupeiqi','male',81,'20130305','teacher',8300,401,1),
('yuanhao','male',73,'20140701','teacher',3500,401,1),
('liwenzhou','male',28,'20121101','teacher',2100,401,1),
('jingliyang','female',18,'20110211','teacher',9000,401,1),
('jinxin','male',18,'19000301','teacher',30000,401,1),
('xiaomage','male',48,'20101111','teacher',10000,401,1),

('歪歪','female',48,'20150311','sale',3000.13,402,2),#如下是销售部门
('丫丫','female',38,'20101101','sale',2000.35,402,2),
('丁丁','female',18,'20110312','sale',1000.37,402,2),
('星星','female',18,'20160513','sale',3000.29,402,2),
('格格','female',28,'20170127','sale',4000.33,402,2),

('张野','male',28,'20160311','operation',10000.13,403,3), #如下是运营部门
('程咬金','male',18,'19970312','operation',20000,403,3),
('程咬银','female',18,'20130311','operation',19000,403,3),
('程咬铜','male',18,'20150411','operation',18000,403,3),
('程咬铁','female',18,'20140512','operation',17000,403,3)
;

（1）where 约束　

where子句中能够使用
1.比较运算符：>、<、>=、<=、<>、!=
2.between 80 and 100 ：值在80到100之间
3.in(80,90,100)值是10或20或30
4.like 'xiaomagepattern': pattern能够是%或者_。%小时任意多字符，_表示一个字符
5.逻辑运算符：在多个条件直接能够使用逻辑运算符 and or not

验证结果：

#1 :单条件查询
mysql> select id,emp_name from employee where id > 5;
+----+------------+
| id | emp_name   |
+----+------------+
|  6 | jingliyang |
|  7 | jinxin     |
|  8 | xiaomage   |
|  9 | 歪歪       |
| 10 | 丫丫       |
| 11 | 丁丁       |
| 12 | 星星       |
| 13 | 格格       |
| 14 | 张野       |
| 15 | 程咬金     |
| 16 | 程咬银     |
| 17 | 程咬铜     |
| 18 | 程咬铁     |

#2 多条件查询
mysql> select emp_name from employee where post='teacher' and salary>10000;
+----------+
| emp_name |
+----------+
| alex         |
| jinxin     |
+----------+

#3.关键字BETWEEN AND
 SELECT name,salary FROM employee 
        WHERE salary BETWEEN 10000 AND 20000;

 SELECT name,salary FROM employee 
        WHERE salary NOT BETWEEN 10000 AND 20000;

#注意''是空字符串，不是null
 SELECT name,post_comment FROM employee WHERE post_comment='';
 ps：
        执行
        update employee set post_comment='' where id=2;
        再用上条查看，就会有结果了
#5:关键字IN集合查询
mysql>  SELECT name,salary FROM employee WHERE salary=3000 OR salary=3500 OR salary=4000 OR salary=9000 ;
+------------+---------+
| name       | salary  |
+------------+---------+
| yuanhao    | 3500.00 |
| jingliyang | 9000.00 |
+------------+---------+
2 rows in set (0.00 sec)

mysql>  SELECT name,salary FROM employee  WHERE salary IN (3000,3500,4000,9000) ;
+------------+---------+
| name       | salary  |
+------------+---------+
| yuanhao    | 3500.00 |
| jingliyang | 9000.00 |
+------------+---------+
mysql>  SELECT name,salary FROM employee  WHERE salary NOT IN (3000,3500,4000,9000) ;
+-----------+------------+
| name      | salary     |
+-----------+------------+
| egon      |    7300.33 |
| alex      | 1000000.31 |
| wupeiqi   |    8300.00 |
| liwenzhou |    2100.00 |
| jinxin    |   30000.00 |
| xiaomage  |   10000.00 |
| 歪歪      |    3000.13 |
| 丫丫      |    2000.35 |
| 丁丁      |    1000.37 |
| 星星      |    3000.29 |
| 格格      |    4000.33 |
| 张野      |   10000.13 |
| 程咬金    |   20000.00 |
| 程咬银    |   19000.00 |
| 程咬铜    |   18000.00 |
| 程咬铁    |   17000.00 |
+-----------+------------+
16 rows in set (0.00 sec)

#6:关键字LIKE模糊查询
通配符’%’
mysql> SELECT * FROM employee WHERE name LIKE 'jin%';
+----+------------+--------+-----+------------+---------+--------------+----------+--------+-----------+
| id | name       | sex    | age | hire_date  | post    | post_comment | salary   | office | depart_id |
+----+------------+--------+-----+------------+---------+--------------+----------+--------+-----------+
|  6 | jingliyang | female |  18 | 2011-02-11 | teacher | NULL         |  9000.00 |    401 |         1 |
|  7 | jinxin     | male   |  18 | 1900-03-01 | teacher | NULL         | 30000.00 |    401 |         1 |
+----+------------+--------+-----+------------+---------+--------------+----------+--------+-----------+
2 rows in set (0.00 sec)


通配符'_'

mysql> SELECT  age FROM employee WHERE name LIKE 'ale_';
+-----+
| age |
+-----+
|  78 |
+-----+
1 row in set (0.00 sec)

练习：
1. 查看岗位是teacher的员工姓名、年龄
2. 查看岗位是teacher且年龄大于30岁的员工姓名、年龄
3. 查看岗位是teacher且薪资在9000-1000范围内的员工姓名、年龄、薪资
4. 查看岗位描述不为NULL的员工信息
5. 查看岗位是teacher且薪资是10000或9000或30000的员工姓名、年龄、薪资
6. 查看岗位是teacher且薪资不是10000或9000或30000的员工姓名、年龄、薪资
7. 查看岗位是teacher且名字是jin开头的员工姓名、年薪

#对应的sql语句
select name,age from employee where post = 'teacher';
select name,age from employee where post='teacher' and age > 30; 
select name,age,salary from employee where post='teacher' and salary between 9000 and 10000;
select * from employee where post_comment is not null;
select name,age,salary from employee where post='teacher' and salary in (10000,9000,30000);
select name,age,salary from employee where post='teacher' and salary not in (10000,9000,30000);
select name,salary*12 from employee where post='teacher' and name like 'jin%';

（2）group by 分组查询

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

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

#三、为什么要分组呢？
    取每一个部门的最高工资
    取每一个部门的员工数
    取男人数和女人数

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

#四、大前提：
    能够按照任意字段分组，可是分组完毕后，好比group by post，只能查看post字段，若是想查看组内信息，须要借助于聚合函数

当执行如下sql语句的时候，是以post字段查询了组中的第一条数据，没有任何意义，由于咱们如今想查出当前组的多条记录。

mysql> select * from employee group by post;
+----+--------+--------+-----+------------+-----------------------------------------+--------------+------------+--------+-----------+
| id | name   | sex    | age | hire_date  | post                                    | post_comment | salary     | office | depart_id |
+----+--------+--------+-----+------------+-----------------------------------------+--------------+------------+--------+-----------+
| 14 | 张野   | male   |  28 | 2016-03-11 | operation                               | NULL         |   10000.13 |    403 |         3 |
|  9 | 歪歪   | female |  48 | 2015-03-11 | sale                                    | NULL         |    3000.13 |    402 |         2 |
|  2 | alex   | male   |  78 | 2015-03-02 | teacher                                 |              | 1000000.31 |    401 |         1 |
|  1 | egon   | male   |  18 | 2017-03-01 | 老男孩驻沙河办事处外交大使              | NULL         |    7300.33 |    401 |         1 |
+----+--------+--------+-----+------------+-----------------------------------------+--------------+------------+--------+-----------+
4 rows in set (0.00 sec)

#因为没有设置ONLY_FULL_GROUP_BY,因而也能够有结果，默认都是组内的第一条记录，但其实这是没有意义的
若是想分组，则必需要设置全局的sql的模式为ONLY_FULL_GROUP_BY
mysql> set global sql_mode='ONLY_FULL_GROUP_BY';
Query OK, 0 rows affected (0.00 sec)

#查看MySQL 5.7默认的sql_mode以下：
mysql> select @@global.sql_mode;
+--------------------+
| @@global.sql_mode  |
+--------------------+
| ONLY_FULL_GROUP_BY |
+--------------------+
1 row in set (0.00 sec)

mysql> exit;#设置成功后，必定要退出，而后从新登陆方可生效
Bye

继续验证经过group by分组以后，只能查看当前字段,若是想查看组内信息，须要借助于聚合函数

mysql> select * from emp group by post;# 报错
ERROR 1054 (42S22): Unknown column 'post' in 'group statement'



mysql>  select post from employee group by post;
+-----------------------------------------+
| post                                    |
+-----------------------------------------+
| operation                               |
| sale                                    |
| teacher                                 |
| 老男孩驻沙河办事处外交大使              |
+-----------------------------------------+
4 rows in set (0.00 sec)

（3）聚合函数

max()求最大值
min()求最小值
avg()求平均值
sum() 求和
count() 求总个数

#强调：聚合函数聚合的是组的内容，如果没有分组，则默认一组
# 每一个部门有多少个员工
select post,count(id) from employee group by post;
# 每一个部门的最高薪水
select post,max(salary) from employee group by post;
# 每一个部门的最低薪水
select post,min(salary) from employee group by post;
# 每一个部门的平均薪水
select post,avg(salary) from employee group by post;
# 每一个部门的全部薪水
select post,sum(age) from employee group by post;

1. 查询岗位名以及岗位包含的全部员工名字
2. 查询岗位名以及各岗位内包含的员工个数
3. 查询公司内男员工和女员工的个数
4. 查询岗位名以及各岗位的平均薪资
5. 查询岗位名以及各岗位的最高薪资
6. 查询岗位名以及各岗位的最低薪资
7. 查询男员工与男员工的平均薪资，女员工与女员工的平均薪资

（4）HAVING过滤

HAVING与WHERE不同的地方在于

#！！！执行优先级从高到低：where > group by > having 
#1. Where 发生在分组group by以前，于是Where中能够有任意字段，可是绝对不能使用聚合函数。

#2. Having发生在分组group by以后，于是Having中能够使用分组的字段，没法直接取到其余字段,能够使用聚合函数

验证：

验证：
mysql> select * from employee where salary>1000000;
+----+------+------+-----+------------+---------+--------------+------------+--------+-----------+
| id | name | sex  | age | hire_date  | post    | post_comment | salary     | office | depart_id |
+----+------+------+-----+------------+---------+--------------+------------+--------+-----------+
|  2 | alex | male |  78 | 2015-03-02 | teacher |              | 1000000.31 |    401 |         1 |
+----+------+------+-----+------------+---------+--------------+------------+--------+-----------+
1 row in set (0.00 sec)

mysql> select * from employee having salary>1000000;
ERROR 1463 (42000): Non-grouping field 'salary' is used in HAVING clause

# 必须使用group by才能使用group_concat()函数，将全部的name值链接
mysql> select post,group_concat(name) from emp group by post having salary > 10000; ##错误，分组后没法直接取到salary字段
ERROR 1054 (42S22): Unknown column 'post' in 'field list'

小练习：

1. 查询各岗位内包含的员工个数小于2的岗位名、岗位内包含员工名字、个数
2. 查询各岗位平均薪资大于10000的岗位名、平均工资
3. 查询各岗位平均薪资大于10000且小于20000的岗位名、平均工资

小练习答案：

# 题1：
mysql> select post,group_concat(name),count(id) from employee group by post;
+-----------------------------------------+-----------------------------------------------------------+-----------+
| post                                    | group_concat(name)                                        | count(id) |
+-----------------------------------------+-----------------------------------------------------------+-----------+
| operation                               | 程咬铁,程咬铜,程咬银,程咬金,张野                          |         5 |
| sale                                    | 格格,星星,丁丁,丫丫,歪歪                                  |         5 |
| teacher                                 | xiaomage,jinxin,jingliyang,liwenzhou,yuanhao,wupeiqi,alex |         7 |
| 老男孩驻沙河办事处外交大使              | egon                                                      |         1 |
+-----------------------------------------+-----------------------------------------------------------+-----------+
4 rows in set (0.00 sec)

mysql> select post,group_concat(name),count(id) from employee group by post having count(id)<2;
+-----------------------------------------+--------------------+-----------+
| post                                    | group_concat(name) | count(id) |
+-----------------------------------------+--------------------+-----------+
| 老男孩驻沙河办事处外交大使              | egon               |         1 |
+-----------------------------------------+--------------------+-----------+
1 row in set (0.00 sec)


#题2：
mysql> select post,avg(salary) from employee group by post having avg(salary) > 10000;
+-----------+---------------+
| post      | avg(salary)   |
+-----------+---------------+
| operation |  16800.026000 |
| teacher   | 151842.901429 |
+-----------+---------------+
2 rows in set (0.00 sec)

#题3：
mysql> select post,avg(salary) from employee group by post having avg(salary) > 10000 and avg(salary) <20000;
+-----------+--------------+
| post      | avg(salary)  |
+-----------+--------------+
| operation | 16800.026000 |
+-----------+--------------+
1 row in set (0.00 sec)

（5）order by 查询排序

按单列排序
    SELECT * FROM employee ORDER BY age;
    SELECT * FROM employee ORDER BY age ASC;
    SELECT * FROM employee ORDER BY age DESC;
按多列排序:先按照age升序排序，若是年纪相同，则按照id降序
    SELECT * from employee
        ORDER BY age ASC,
        id DESC;

验证多列排序：
SELECT * from employee ORDER BY age ASC,id DESC;
mysql> SELECT * from employee ORDER BY age ASC,id DESC;
+----+------------+--------+-----+------------+-----------------------------------------+--------------+------------+--------+-----------+
| id | name       | sex    | age | hire_date  | post                                    | post_comment | salary     | office | depart_id |
+----+------------+--------+-----+------------+-----------------------------------------+--------------+------------+--------+-----------+
| 18 | 程咬铁     | female |  18 | 2014-05-12 | operation                               | NULL         |   17000.00 |    403 |         3 |
| 17 | 程咬铜     | male   |  18 | 2015-04-11 | operation                               | NULL         |   18000.00 |    403 |         3 |
| 16 | 程咬银     | female |  18 | 2013-03-11 | operation                               | NULL         |   19000.00 |    403 |         3 |
| 15 | 程咬金     | male   |  18 | 1997-03-12 | operation                               | NULL         |   20000.00 |    403 |         3 |
| 12 | 星星       | female |  18 | 2016-05-13 | sale                                    | NULL         |    3000.29 |    402 |         2 |
| 11 | 丁丁       | female |  18 | 2011-03-12 | sale                                    | NULL         |    1000.37 |    402 |         2 |
|  7 | jinxin     | male   |  18 | 1900-03-01 | teacher                                 | NULL         |   30000.00 |    401 |         1 |
|  6 | jingliyang | female |  18 | 2011-02-11 | teacher                                 | NULL         |    9000.00 |    401 |         1 |
|  1 | egon       | male   |  18 | 2017-03-01 | 老男孩驻沙河办事处外交大使              | NULL         |    7300.33 |    401 |         1 |
| 14 | 张野       | male   |  28 | 2016-03-11 | operation                               | NULL         |   10000.13 |    403 |         3 |
| 13 | 格格       | female |  28 | 2017-01-27 | sale                                    | NULL         |    4000.33 |    402 |         2 |
|  5 | liwenzhou  | male   |  28 | 2012-11-01 | teacher                                 | NULL         |    2100.00 |    401 |         1 |
| 10 | 丫丫       | female |  38 | 2010-11-01 | sale                                    | NULL         |    2000.35 |    402 |         2 |
|  9 | 歪歪       | female |  48 | 2015-03-11 | sale                                    | NULL         |    3000.13 |    402 |         2 |
|  8 | xiaomage   | male   |  48 | 2010-11-11 | teacher                                 | NULL         |   10000.00 |    401 |         1 |
|  4 | yuanhao    | male   |  73 | 2014-07-01 | teacher                                 | NULL         |    3500.00 |    401 |         1 |
|  2 | alex       | male   |  78 | 2015-03-02 | teacher                                 |              | 1000000.31 |    401 |         1 |
|  3 | wupeiqi    | male   |  81 | 2013-03-05 | teacher                                 | NULL         |    8300.00 |    401 |         1 |
+----+------------+--------+-----+------------+-----------------------------------------+--------------+------------+--------+-----------+
18 rows in set (0.01 sec)

mysql>

小练习：

1. 查询全部员工信息，先按照age升序排序，若是age相同则按照hire_date降序排序
2. 查询各岗位平均薪资大于10000的岗位名、平均工资,结果按平均薪资升序排列
3. 查询各岗位平均薪资大于10000的岗位名、平均工资,结果按平均薪资降序排列

# 题目1
select * from employee ORDER BY age asc,hire_date desc;

# 题目2
mysql> select post,avg(salary) from employee group by post having avg(salary) > 10000 order by avg(salary) asc;
+-----------+---------------+
| post      | avg(salary)   |
+-----------+---------------+
| operation |  16800.026000 |
| teacher   | 151842.901429 |
+-----------+---------------+
2 rows in set (0.00 sec)

# 题目3
mysql> select post,avg(salary) from employee group by post having avg(salary) > 10000 order by avg(salary) desc;
+-----------+---------------+
| post      | avg(salary)   |
+-----------+---------------+
| teacher   | 151842.901429 |
| operation |  16800.026000 |
+-----------+---------------+
2 rows in set (0.00 sec)

mysql>

（5）limit 限制查询的记录数:

示例：
    SELECT * FROM employee ORDER BY salary DESC 
     LIMIT 3;                    #默认初始位置为0 

    SELECT * FROM employee ORDER BY salary DESC
        LIMIT 0,5; #从第0开始，即先查询出第一条，而后包含这一条在内日后查5条

    SELECT * FROM employee ORDER BY salary DESC
        LIMIT 5,5; #从第5开始，即先查询出第6条，而后包含这一条在内日后查5条

小练习：
分页显示，每页5条

# 第1页数据
  mysql> select * from  employee limit 0,5;
+----+-----------+------+-----+------------+-----------------------------------------+--------------+------------+--------+-----------+
| id | name      | sex  | age | hire_date  | post                                    | post_comment | salary     | office | depart_id |
+----+-----------+------+-----+------------+-----------------------------------------+--------------+------------+--------+-----------+
|  1 | egon      | male |  18 | 2017-03-01 | 老男孩驻沙河办事处外交大使              | NULL         |    7300.33 |    401 |         1 |
|  2 | alex      | male |  78 | 2015-03-02 | teacher                                 |              | 1000000.31 |    401 |         1 |
|  3 | wupeiqi   | male |  81 | 2013-03-05 | teacher                                 | NULL         |    8300.00 |    401 |         1 |
|  4 | yuanhao   | male |  73 | 2014-07-01 | teacher                                 | NULL         |    3500.00 |    401 |         1 |
|  5 | liwenzhou | male |  28 | 2012-11-01 | teacher                                 | NULL         |    2100.00 |    401 |         1 |
+----+-----------+------+-----+------------+-----------------------------------------+--------------+------------+--------+-----------+
5 rows in set (0.00 sec)
# 第2页数据
mysql> select * from  employee limit 5,5;
+----+------------+--------+-----+------------+---------+--------------+----------+--------+-----------+
| id | name       | sex    | age | hire_date  | post    | post_comment | salary   | office | depart_id |
+----+------------+--------+-----+------------+---------+--------------+----------+--------+-----------+
|  6 | jingliyang | female |  18 | 2011-02-11 | teacher | NULL         |  9000.00 |    401 |         1 |
|  7 | jinxin     | male   |  18 | 1900-03-01 | teacher | NULL         | 30000.00 |    401 |         1 |
|  8 | xiaomage   | male   |  48 | 2010-11-11 | teacher | NULL         | 10000.00 |    401 |         1 |
|  9 | 歪歪       | female |  48 | 2015-03-11 | sale    | NULL         |  3000.13 |    402 |         2 |
| 10 | 丫丫       | female |  38 | 2010-11-01 | sale    | NULL         |  2000.35 |    402 |         2 |
+----+------------+--------+-----+------------+---------+--------------+----------+--------+-----------+
5 rows in set (0.00 sec)
# 第3页数据
mysql> select * from  employee limit 10,5;
+----+-----------+--------+-----+------------+-----------+--------------+----------+--------+-----------+
| id | name      | sex    | age | hire_date  | post      | post_comment | salary   | office | depart_id |
+----+-----------+--------+-----+------------+-----------+--------------+----------+--------+-----------+
| 11 | 丁丁      | female |  18 | 2011-03-12 | sale      | NULL         |  1000.37 |    402 |         2 |
| 12 | 星星      | female |  18 | 2016-05-13 | sale      | NULL         |  3000.29 |    402 |         2 |
| 13 | 格格      | female |  28 | 2017-01-27 | sale      | NULL         |  4000.33 |    402 |         2 |
| 14 | 张野      | male   |  28 | 2016-03-11 | operation | NULL         | 10000.13 |    403 |         3 |
| 15 | 程咬金    | male   |  18 | 1997-03-12 | operation | NULL         | 20000.00 |    403 |         3 |
+----+-----------+--------+-----+------------+-----------+--------------+----------+--------+-----------+
5 rows in set (0.00 sec)

# 第1页数据
  mysql> select * from  employee limit 0,5;
+----+-----------+------+-----+------------+-----------------------------------------+--------------+------------+--------+-----------+
| id | name      | sex  | age | hire_date  | post                                    | post_comment | salary     | office | depart_id |
+----+-----------+------+-----+------------+-----------------------------------------+--------------+------------+--------+-----------+
|  1 | egon      | male |  18 | 2017-03-01 | 老男孩驻沙河办事处外交大使              | NULL         |    7300.33 |    401 |         1 |
|  2 | alex      | male |  78 | 2015-03-02 | teacher                                 |              | 1000000.31 |    401 |         1 |
|  3 | wupeiqi   | male |  81 | 2013-03-05 | teacher                                 | NULL         |    8300.00 |    401 |         1 |
|  4 | yuanhao   | male |  73 | 2014-07-01 | teacher                                 | NULL         |    3500.00 |    401 |         1 |
|  5 | liwenzhou | male |  28 | 2012-11-01 | teacher                                 | NULL         |    2100.00 |    401 |         1 |
+----+-----------+------+-----+------------+-----------------------------------------+--------------+------------+--------+-----------+
rows in set (0.00 sec)
# 第2页数据
mysql> select * from  employee limit 5,5;
+----+------------+--------+-----+------------+---------+--------------+----------+--------+-----------+
| id | name       | sex    | age | hire_date  | post    | post_comment | salary   | office | depart_id |
+----+------------+--------+-----+------------+---------+--------------+----------+--------+-----------+
|  6 | jingliyang | female |  18 | 2011-02-11 | teacher | NULL         |  9000.00 |    401 |         1 |
|  7 | jinxin     | male   |  18 | 1900-03-01 | teacher | NULL         | 30000.00 |    401 |         1 |
|  8 | xiaomage   | male   |  48 | 2010-11-11 | teacher | NULL         | 10000.00 |    401 |         1 |
|  9 | 歪歪       | female |  48 | 2015-03-11 | sale    | NULL         |  3000.13 |    402 |         2 |
| 10 | 丫丫       | female |  38 | 2010-11-01 | sale    | NULL         |  2000.35 |    402 |         2 |
+----+------------+--------+-----+------------+---------+--------------+----------+--------+-----------+
rows in set (0.00 sec)
# 第3页数据
mysql> select * from  employee limit 10,5;
+----+-----------+--------+-----+------------+-----------+--------------+----------+--------+-----------+
| id | name      | sex    | age | hire_date  | post      | post_comment | salary   | office | depart_id |
+----+-----------+--------+-----+------------+-----------+--------------+----------+--------+-----------+
| 11 | 丁丁      | female |  18 | 2011-03-12 | sale      | NULL         |  1000.37 |    402 |         2 |
| 12 | 星星      | female |  18 | 2016-05-13 | sale      | NULL         |  3000.29 |    402 |         2 |
| 13 | 格格      | female |  28 | 2017-01-27 | sale      | NULL         |  4000.33 |    402 |         2 |
| 14 | 张野      | male   |  28 | 2016-03-11 | operation | NULL         | 10000.13 |    403 |         3 |
| 15 | 程咬金    | male   |  18 | 1997-03-12 | operation | NULL         | 20000.00 |    403 |         3 |
+----+-----------+--------+-----+------------+-----------+--------------+----------+--------+-----------+
rows in set (0.00 sec)

小练习答案

13-多表查询

本节重点：

多表链接查询
符合条件链接查询
子查询

准备工做：准备两张表，部门表（department）、员工表（employee）

create table department(
id int,
name varchar(20) 
);

create table employee(
id int primary key auto_increment,
name varchar(20),
sex enum('male','female') not null default 'male',
age int,
dep_id int
);

#插入数据
insert into department values
(200,'技术'),
(201,'人力资源'),
(202,'销售'),
(203,'运营');

insert into employee(name,sex,age,dep_id) values
('egon','male',18,200),
('alex','female',48,201),
('wupeiqi','male',38,201),
('yuanhao','female',28,202),
('nvshen','male',18,200),
('xiaomage','female',18,204)
;

# 查看表结构和数据
mysql> desc department;
+-------+-------------+------+-----+---------+-------+
| Field | Type        | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+-------+
| id    | int(11)     | YES  |     | NULL    |       |
| name  | varchar(20) | YES  |     | NULL    |       |
+-------+-------------+------+-----+---------+-------+
2 rows in set (0.19 sec)

mysql> desc employee;
+--------+-----------------------+------+-----+---------+----------------+
| Field  | Type                  | Null | Key | Default | Extra          |
+--------+-----------------------+------+-----+---------+----------------+
| id     | int(11)               | NO   | PRI | NULL    | auto_increment |
| name   | varchar(20)           | YES  |     | NULL    |                |
| sex    | enum('male','female') | NO   |     | male    |                |
| age    | int(11)               | YES  |     | NULL    |                |
| dep_id | int(11)               | YES  |     | NULL    |                |
+--------+-----------------------+------+-----+---------+----------------+
5 rows in set (0.01 sec)

mysql> select * from department;
+------+--------------+
| id   | name         |
+------+--------------+
|  200 | 技术         |
|  201 | 人力资源     |
|  202 | 销售         |
|  203 | 运营         |
+------+--------------+
4 rows in set (0.02 sec)

mysql> select * from employee;
+----+----------+--------+------+--------+
| id | name     | sex    | age  | dep_id |
+----+----------+--------+------+--------+
|  1 | egon     | male   |   18 |    200 |
|  2 | alex     | female |   48 |    201 |
|  3 | wupeiqi  | male   |   38 |    201 |
|  4 | yuanhao  | female |   28 |    202 |
|  5 | nvshen   | male   |   18 |    200 |
|  6 | xiaomage | female |   18 |    204 |
+----+----------+--------+------+--------+
6 rows in set (0.00 sec)

ps:观察两张表，发现department表中id=203部门在employee中没有对应的员工，发现employee中id=6的员工在department表中没有对应关系。

1、多表链接查询

两张表的准备工做已完成，好比如今我要查询的员工信息以及该员工所在的部门。从该题中，咱们看出既要查员工又要查该员工的部门，确定要将两张表进行链接查询，多表链接查询。

重点：外连接语法

语法：

SELECT 字段列表
    FROM 表1 INNER|LEFT|RIGHT JOIN 表2
    ON 表1.字段 = 表2.字段;

（1）先看第一种状况交叉链接：不适用任何匹配条件。生成笛卡尔积（关于笛卡尔积的含义，你们百度自行补脑）。

mysql> select * from employee,department;
+----+----------+--------+------+--------+------+--------------+
| id | name     | sex    | age  | dep_id | id   | name         |
+----+----------+--------+------+--------+------+--------------+
|  1 | egon     | male   |   18 |    200 |  200 | 技术         |
|  1 | egon     | male   |   18 |    200 |  201 | 人力资源     |
|  1 | egon     | male   |   18 |    200 |  202 | 销售         |
|  1 | egon     | male   |   18 |    200 |  203 | 运营         |
|  2 | alex     | female |   48 |    201 |  200 | 技术         |
|  2 | alex     | female |   48 |    201 |  201 | 人力资源     |
|  2 | alex     | female |   48 |    201 |  202 | 销售         |
|  2 | alex     | female |   48 |    201 |  203 | 运营         |
|  3 | wupeiqi  | male   |   38 |    201 |  200 | 技术         |
|  3 | wupeiqi  | male   |   38 |    201 |  201 | 人力资源     |
|  3 | wupeiqi  | male   |   38 |    201 |  202 | 销售         |
|  3 | wupeiqi  | male   |   38 |    201 |  203 | 运营         |
|  4 | yuanhao  | female |   28 |    202 |  200 | 技术         |
|  4 | yuanhao  | female |   28 |    202 |  201 | 人力资源     |
|  4 | yuanhao  | female |   28 |    202 |  202 | 销售         |
|  4 | yuanhao  | female |   28 |    202 |  203 | 运营         |
|  5 | nvshen   | male   |   18 |    200 |  200 | 技术         |
|  5 | nvshen   | male   |   18 |    200 |  201 | 人力资源     |
|  5 | nvshen   | male   |   18 |    200 |  202 | 销售         |
|  5 | nvshen   | male   |   18 |    200 |  203 | 运营         |
|  6 | xiaomage | female |   18 |    204 |  200 | 技术         |
|  6 | xiaomage | female |   18 |    204 |  201 | 人力资源     |
|  6 | xiaomage | female |   18 |    204 |  202 | 销售         |
|  6 | xiaomage | female |   18 |    204 |  203 | 运营         |

（2）内链接：只链接匹配的行

#找两张表共有的部分，至关于利用条件从笛卡尔积结果中筛选出了匹配的结果
#department没有204这个部门，于是employee表中关于204这条员工信息没有匹配出来
mysql> select employee.id,employee.name,employee.age,employee.sex,department.name from employee inner join department on employee.dep_id=department.id;
+----+---------+------+--------+--------------+
| id | name    | age  | sex    | name         |
+----+---------+------+--------+--------------+
|  1 | egon    |   18 | male   | 技术         |
|  2 | alex    |   48 | female | 人力资源     |
|  3 | wupeiqi |   38 | male   | 人力资源     |
|  4 | yuanhao |   28 | female | 销售         |
|  5 | nvshen  |   18 | male   | 技术         |
+----+---------+------+--------+--------------+
5 rows in set (0.00 sec)

#上述sql等同于
mysql> select employee.id,employee.name,employee.age,employee.sex,department.name from employee,department where employee.dep_id=department.id;

（3）外连接之左链接：优先显示左表所有记录

#以左表为准，即找出全部员工信息，固然包括没有部门的员工
#本质就是：在内链接的基础上增长左边有，右边没有的结果
mysql> select employee.id,employee.name,department.name as depart_name from employee left join department on employee.dep_id=department.id;
+----+----------+--------------+
| id | name     | depart_name  |
+----+----------+--------------+
|  1 | egon     | 技术         |
|  5 | nvshen   | 技术         |
|  2 | alex     | 人力资源     |
|  3 | wupeiqi  | 人力资源     |
|  4 | yuanhao  | 销售         |
|  6 | xiaomage | NULL         |
+----+----------+--------------+
6 rows in set (0.00 sec)

（4）外连接之右链接：优先显示右表所有记录

#以右表为准，即找出全部部门信息，包括没有员工的部门
#本质就是：在内链接的基础上增长右边有，左边没有的结果
mysql> select employee.id,employee.name,department.name as depart_name from employee right join department on employee.dep_id=department.id;
+------+---------+--------------+
| id   | name    | depart_name  |
+------+---------+--------------+
|    1 | egon    | 技术         |
|    2 | alex    | 人力资源     |
|    3 | wupeiqi | 人力资源     |
|    4 | yuanhao | 销售         |
|    5 | nvshen  | 技术         |
| NULL | NULL    | 运营         |
+------+---------+--------------+
6 rows in set (0.00 sec)

（5）全外链接：显示左右两个表所有记录(了解)

#外链接：在内链接的基础上增长左边有右边没有的和右边有左边没有的结果
#注意：mysql不支持全外链接 full JOIN
#强调：mysql能够使用此种方式间接实现全外链接
语法：select * from employee left join department on employee.dep_id = department.id 
       union all
      select * from employee right join department on employee.dep_id = department.id;

 mysql> select * from employee left join department on employee.dep_id = department.id
          union
        select * from employee right join department on employee.dep_id = department.id
           ;
+------+----------+--------+------+--------+------+--------------+
| id   | name     | sex    | age  | dep_id | id   | name         |
+------+----------+--------+------+--------+------+--------------+
|    1 | egon     | male   |   18 |    200 |  200 | 技术         |
|    5 | nvshen   | male   |   18 |    200 |  200 | 技术         |
|    2 | alex     | female |   48 |    201 |  201 | 人力资源     |
|    3 | wupeiqi  | male   |   38 |    201 |  201 | 人力资源     |
|    4 | yuanhao  | female |   28 |    202 |  202 | 销售         |
|    6 | xiaomage | female |   18 |    204 | NULL | NULL         |
| NULL | NULL     | NULL   | NULL |   NULL |  203 | 运营         |
+------+----------+--------+------+--------+------+--------------+
7 rows in set (0.01 sec)

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

2、符合条件链接查询

示例1：之内链接的方式查询employee和department表，而且employee表中的age字段值必须大于25，即找出年龄大于25岁的员工以及员工所在的部门

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

示例2：之内链接的方式查询employee和department表，而且以age字段的升序方式显示。

select employee.id,employee.name,employee.age,department.name from employee,department
    where employee.dep_id = department.id
    and age > 25
    order by age asc;

3、子查询

#1：子查询是将一个查询语句嵌套在另外一个查询语句中。
#2：内层查询语句的查询结果，能够为外层查询语句提供查询条件。
#3：子查询中能够包含：IN、NOT IN、ANY、ALL、EXISTS 和 NOT EXISTS等关键字
#4：还能够包含比较运算符：= 、 !=、> 、<等

例子：

（1）带in关键字的子查询

#查询平均年龄在25岁以上的部门名
select id,name from department
    where id in 
        (select dep_id from employee group by dep_id having avg(age) > 25);
# 查看技术部员工姓名
select name from employee
    where dep_id in 
        (select id from department where name='技术');
#查看不足1人的部门名
select name from department
    where id not in 
        (select dep_id from employee group by dep_id);

（2）带比较运算符的子查询

#比较运算符：=、!=、>、>=、<、<=、<>
#查询大于全部人平均年龄的员工名与年龄
mysql> select name,age from employee where age > (select avg(age) from employee);
+---------+------+
| name    | age  |
+---------+------+
| alex    |   48 |
| wupeiqi |   38 |
+---------+------+

#查询大于部门内平均年龄的员工名、年龄
思路：
      （1）先对员工表(employee)中的人员分组(group by)，查询出dep_id以及平均年龄。
       (2)将查出的结果做为临时表,再对根据临时表的dep_id和employee的dep_id做为筛选条件将employee表和临时表进行内链接。
       (3)最后再将employee员工的年龄是大于平均年龄的员工名字和年龄筛选。



mysql> select t1.name,t1.age from employee as t1
             inner join
            (select dep_id,avg(age) as avg_age from employee group by dep_id) as t2
            on t1.dep_id = t2.dep_id
            where t1.age > t2.avg_age;
+------+------+
| name | age  |
+------+------+
| alex |   48 |

(3)带EXISTS关键字的子查询

#EXISTS关字键字表示存在。在使用EXISTS关键字时，内层查询语句不返回查询的记录。而是返回一个真假值。True或False
#当返回True时，外层查询语句将进行查询；当返回值为False时，外层查询语句不进行查询
#department表中存在dept_id=203，Ture
mysql> select * from employee  where exists (select id from department where id=200);
+----+----------+--------+------+--------+
| id | name     | sex    | age  | dep_id |
+----+----------+--------+------+--------+
|  1 | egon     | male   |   18 |    200 |
|  2 | alex     | female |   48 |    201 |
|  3 | wupeiqi  | male   |   38 |    201 |
|  4 | yuanhao  | female |   28 |    202 |
|  5 | nvshen   | male   |   18 |    200 |
|  6 | xiaomage | female |   18 |    204 |
+----+----------+--------+------+--------+
#department表中存在dept_id=205，False
mysql> select * from employee  where exists (select id from department where id=204);
Empty set (0.00 sec)

小练习：

查询每一个部门最新入职的那位员工

#建立表
create table employee(
id int not null unique auto_increment,
name varchar(20) not null,
sex enum('male','female') not null default 'male', #大部分是男的
age int(3) unsigned not null default 28,
hire_date date not null,
post varchar(50),
post_comment varchar(100),
salary double(15,2),
office int, #一个部门一个屋子
depart_id int
);


#查看表结构
mysql> desc employee;
+--------------+-----------------------+------+-----+---------+----------------+
| Field        | Type                  | Null | Key | Default | Extra          |
+--------------+-----------------------+------+-----+---------+----------------+
| id           | int(11)               | NO   | PRI | NULL    | auto_increment |
| name         | varchar(20)           | NO   |     | NULL    |                |
| sex          | enum('male','female') | NO   |     | male    |                |
| age          | int(3) unsigned       | NO   |     | 28      |                |
| hire_date    | date                  | NO   |     | NULL    |                |
| post         | varchar(50)           | YES  |     | NULL    |                |
| post_comment | varchar(100)          | YES  |     | NULL    |                |
| salary       | double(15,2)          | YES  |     | NULL    |                |
| office       | int(11)               | YES  |     | NULL    |                |
| depart_id    | int(11)               | YES  |     | NULL    |                |
+--------------+-----------------------+------+-----+---------+----------------+

#插入记录
#三个部门：教学，销售，运营
insert into employee(name,sex,age,hire_date,post,salary,office,depart_id) values
('egon','male',18,'20170301','老男孩驻沙河办事处外交大使',7300.33,401,1), #如下是教学部
('alex','male',78,'20150302','teacher',1000000.31,401,1),
('wupeiqi','male',81,'20130305','teacher',8300,401,1),
('yuanhao','male',73,'20140701','teacher',3500,401,1),
('liwenzhou','male',28,'20121101','teacher',2100,401,1),
('jingliyang','female',18,'20110211','teacher',9000,401,1),
('jinxin','male',18,'19000301','teacher',30000,401,1),
('成龙','male',48,'20101111','teacher',10000,401,1),

('歪歪','female',48,'20150311','sale',3000.13,402,2),#如下是销售部门
('丫丫','female',38,'20101101','sale',2000.35,402,2),
('丁丁','female',18,'20110312','sale',1000.37,402,2),
('星星','female',18,'20160513','sale',3000.29,402,2),
('格格','female',28,'20170127','sale',4000.33,402,2),

('张野','male',28,'20160311','operation',10000.13,403,3), #如下是运营部门
('程咬金','male',18,'19970312','operation',20000,403,3),
('程咬银','female',18,'20130311','operation',19000,403,3),
('程咬铜','male',18,'20150411','operation',18000,403,3),
('程咬铁','female',18,'20140512','operation',17000,403,3)
;

select * from employee as t1
inner join
(select post,max(hire_date) as new_date from employee group by post) as t2
on t1.post=t2.post
where t1.hire_date=t2.new_date;

14-补充内容：MySQl建立用户和受权

权限管理

咱们知道咱们的最高权限管理者是root用户，它拥有着最高的权限操做。包括select、update、delete、update、grant等操做。那么通常状况在公司以后DBA工程师会建立一个用户和密码，让你去链接数据库的操做，并给当前的用户设置某个操做的权限（或者全部权限）。那么这时就须要咱们来简单了解一下：

如何建立用户和密码
给当前的用户受权
移除当前用户的权限

若是你想建立一个新的用户，则须要如下操做：

1.进入到mysql数据库下

mysql> use mysql
Database changed

2.对新用户增删改

1.建立用户:
# 指定ip：192.118.1.1的mjj用户登陆
create user 'mjj'@'192.118.1.1' identified by '123';
# 指定ip：192.118.1.开头的mjj用户登陆
create user 'mjj'@'192.118.1.%' identified by '123';
# 指定任何ip的mjj用户登陆
create user 'mjj'@'%' identified by '123';

2.删除用户
drop user '用户名'@'IP地址';


3.修改用户
rename user '用户名'@'IP地址' to '新用户名'@'IP地址';

4.修改密码
set password for '用户名'@'IP地址'=Password('新密码');

3.对当前的用户受权管理

#查看权限
show grants for '用户'@'IP地址'

#受权 mjj用户仅对db1.t1文件有查询、插入和更新的操做
grant select ,insert,update on db1.t1 to "mjj"@'%';

# 表示有全部的权限，除了grant这个命令，这个命令是root才有的。mjj用户对db1下的t1文件有任意操做
grant all privileges  on db1.t1 to "mjj"@'%';
#mjj用户对db1数据库中的文件执行任何操做

grant all privileges  on db1.* to "mjj"@'%';
#mjj用户对全部数据库中文件有任何操做

grant all privileges  on *.*  to "mjj"@'%';

#取消权限

# 取消mjj用户对db1的t1文件的任意操做
revoke all on db1.t1 from 'mjj'@"%";


# 取消来自远程服务器的mjj用户对数据库db1的全部表的全部权限

revoke all on db1.* from 'mjj'@"%";


取消来自远程服务器的mjj用户全部数据库的全部的表的权限
revoke all privileges on *.* from 'mjj'@'%';

ps:在公司中，通常状况下是DBA工程师来作这些受权工做。给你一个用户名和密码，你来链接就能够了。

4.MySql备份命令行操做

# 备份：数据表结构+数据
mysqdump -u root db1 > db1.sql -p


# 备份：数据表结构
mysqdump -u root -d db1 > db1.sql -p

#导入现有的数据到某个数据库
#1.先建立一个新的数据库
create database db10;
# 2.将已有的数据库文件导入到db10数据库中
mysqdump -u root -d db10 < db1.sql -p

15-可视化工具Navicat的使用

本节重点：

掌握Navicat的基本使用

# PS:在生产环境中操做MySQL数据库仍是推荐使用命令行工具mysql，但在咱们本身开发测试时，能够使用可视化工具Navicat，以图形界面的形式操做MySQL数据库

官网下载：https://www.navicat.com/en/products/navicat-for-mysql

网盘下载：https://pan.baidu.com/s/1bpo5mqj

须要掌握基本的操做

掌握：
#1. 测试+连接数据库
#2. 新建库
#3. 新建表，新增字段+类型+约束
#4. 设计表：外键
#5. 新建查询
#6. 备份库/表

#注意：
批量加注释：ctrl+？键
批量去注释：ctrl+shift+？键

16-pymysql模块的使用

本节重点：

pymysql的下载和使用
execute()之sql注入
增、删、改：conn.commit()
查：fetchone、fetchmany、fetchall

1、pymysql的下载和使用

　　以前咱们都是经过MySQL自带的命令行客户端工具mysql来操做数据库，那如何在python程序中操做数据库呢？这就用到了pymysql模块，该模块本质就是一个套接字客户端软件，使用前须要事先安装。

（1）pymysql模块的下载

pip3 install pymysql

（2）pymysql的使用

数据库和数据都已存在

# 实现：使用Python实现用户登陆，若是用户存在则登陆成功（假设该用户已在数据库中）


import pymysql
user = input('请输入用户名：')

pwd = input('请输入密码：')



# 1.链接
conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', password='', db='db8', charset='utf8')


# 2.建立游标
cursor = conn.cursor()

#注意%s须要加引号
sql = "select * from userinfo where username='%s' and pwd='%s'" %(user, pwd)
print(sql)

# 3.执行sql语句
cursor.execute(sql)

result=cursor.execute(sql) #执行sql语句，返回sql查询成功的记录数目
print(result)


# 关闭链接，游标和链接都要关闭
cursor.close()
conn.close()

if result:
    print('登录成功')
else:
    print('登陆失败')

2、execute()之sql注入

最后那一个空格，在一条sql语句中若是遇到select * from userinfo where username='mjj' -- asadasdas' and pwd='' 则--以后的条件被注释掉了(注意--后面还有一个空格)

#一、sql注入之：用户存在，绕过密码
mjj' -- 任意字符

#二、sql注入之：用户不存在，绕过用户与密码
xxx' or 1=1 -- 任意字符

解决方法：

# 原来是咱们对sql进行字符串拼接
# sql="select * from userinfo where name='%s' and password='%s'" %(username,pwd)
# print(sql)
# result=cursor.execute(sql)

#改写为（execute帮咱们作字符串拼接，咱们无需且必定不能再为%s加引号了）
sql="select * from userinfo where name=%s and password=%s" #！！！注意%s须要去掉引号，由于pymysql会自动为咱们加上
result=cursor.execute(sql,[user,pwd]) #pymysql模块自动帮咱们解决sql注入的问题，只要咱们按照pymysql的规矩来。

3、增、删、改：conn.commit()

commit()方法：在数据库里增、删、改的时候，必需要进行提交，不然插入的数据不生效。

import pymysql
username = input('请输入用户名：')

pwd = input('请输入密码：')



# 1.链接
conn = pymysql.connect(host='localhost', port=3306, user='root', password='', db='db8', charset='utf8')


# 2.建立游标
cursor = conn.cursor()


# 操做
# 增
# sql = "insert into userinfo(username,pwd) values (%s,%s)"


# effect_row = cursor.execute(sql,(username,pwd))
#同时插入多条数据
#cursor.executemany(sql,[('李四'，'110'),（'王五'，'119'）]) 

# print(effect_row)#

# 改
# sql = "update userinfo set username = %s  where id = 2"
# effect_row = cursor.execute(sql,username)
# print(effect_row)


# 删
sql = "delete from userinfo  where id = 2"
effect_row = cursor.execute(sql)
print(effect_row)


#必定记得commit
conn.commit()

# 4.关闭游标
cursor.close()

# 5.关闭链接
conn.close()

4、查：fetchone、fetchmany、fetchall

fetchone():获取下一行数据，第一次为首行；
fetchall():获取全部行数据源
fetchmany(4):获取4行数据

查看一下表内容：

mysql> select * from userinfo;
+----+----------+-----+
| id | username | pwd |
+----+----------+-----+
|  1 | mjj      | 123 |
|  3 | 张三     | 110 |
|  4 | 李四     | 119 |
+----+----------+-----+
3 rows in set (0.00 sec)

使用fetchone():

import pymysql

# 1.链接
conn = pymysql.connect(host='localhost', port=3306, user='root', password='', db='db8', charset='utf8')


# 2.建立游标
cursor = conn.cursor()

sql = 'select * from userinfo'
cursor.execute(sql)


# 查询第一行的数据
row = cursor.fetchone()
print(row) # (1, 'mjj', '123')

# 查询第二行数据
row = cursor.fetchone()
print(row) # (3, '张三', '110')

# 4.关闭游标
cursor.close()

# 5.关闭链接
conn.close()

使用fetchall():

import pymysql

# 1.链接
conn = pymysql.connect(host='localhost', port=3306, user='root', password='', db='db8', charset='utf8')


# 2.建立游标
cursor = conn.cursor()

sql = 'select * from userinfo'
cursor.execute(sql)

# 获取全部的数据
rows = cursor.fetchall()
print(rows)

# 4.关闭游标
cursor.close()

# 5.关闭链接
conn.close()

#运行结果
((1, 'mjj', '123'), (3, '张三', '110'), (4, '李四', '119'))

默认状况下，咱们获取到的返回值是元组，只能看到每行的数据，殊不知道每一列表明的是什么，这个时候能够使用如下方式来返回字典，每一行的数据都会生成一个字典：

cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)  #在实例化的时候，将属性cursor设置为pymysql.cursors.DictCursor

在fetchone示例中，在获取行数据的时候，能够理解开始的时候，有一个行指针指着第一行的上方，获取一行，它就向下移动一行，因此当行指针到最后一行的时候，就不能再获取到行的内容，因此咱们能够使用以下方法来移动行指针：

cursor.scroll(1,mode='relative')  # 相对当前位置移动
cursor.scroll(2,mode='absolute') # 相对绝对位置移动
第一个值为移动的行数，整数为向下移动，负数为向上移动，mode指定了是相对当前位置移动，仍是相对于首行移动

# 1.Python实现用户登陆
# 2.Mysql保存数据

import pymysql

# 1.链接
conn = pymysql.connect(host='localhost', port=3306, user='root', password='', db='db8', charset='utf8')


# 2.建立游标
cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)

sql = 'select * from userinfo'
cursor.execute(sql)


# 查询第一行的数据
row = cursor.fetchone()
print(row) # (1, 'mjj', '123')

# 查询第二行数据
row = cursor.fetchone() # (3, '张三', '110')
print(row)

cursor.scroll(-1,mode='relative') #设置以后，光标相对于当前位置往前移动了一行，因此打印的结果为第二行的数据
row = cursor.fetchone() 
print(row)

cursor.scroll(0,mode='absolute') #设置以后，光标相对于首行没有任何变化，因此打印的结果为第一行数据
row = cursor.fetchone() 
print(row)

# 4.关闭游标
cursor.close()

# 5.关闭链接
conn.close()

#结果以下

{'id': 1, 'username': 'mjj', 'pwd': '123'}
{'id': 3, 'username': '张三', 'pwd': '110'}
{'id': 3, 'username': '张三', 'pwd': '110'}
{'id': 1, 'username': 'mjj', 'pwd': '123'}

fetchmany():

import pymysql

# 1.链接
conn = pymysql.connect(host='localhost', port=3306, user='root', password='', db='db8', charset='utf8')


# 2.建立游标
cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)

sql = 'select * from userinfo'
cursor.execute(sql)



# 获取2条数据
rows = cursor.fetchmany(2)
print(rows)

# 4.关闭游标

# rows = cursor.fetchall()
# print(rows)
cursor.close()

# 5.关闭链接
conn.close()

#结果以下：
[{'id': 1, 'username': 'mjj', 'pwd': '123'}, {'id': 3, 'username': '张三', 'pwd': '110'}]

17-索引

1、索引的介绍

数据库中专门用于帮助用户快速查找数据的一种数据结构。相似于字典中的目录，查找字典内容时能够根据目录查找到数据的存放位置吗，而后直接获取。

二、索引的做用

约束和加速查找

3、常见的几种索引：

- 普通索引
- 惟一索引
- 主键索引
- 联合索引（多列）

   - 联合主键索引 

　 - 联合惟一索引

   - 联合普通索引

无索引： 从前日后一条一条查询
有索引：建立索引的本质，就是建立额外的文件（某种格式存储，查询的时候，先去格外的文件找，定好位置，而后再去原始表中直接查询。可是建立索引越多，会对硬盘也是有损耗。

创建索引的目的：
a.额外的文件保存特殊的数据结构
b.查询快，可是插入更新删除依然慢
c.建立索引以后，必须命中索引才能有效

hash索引和BTree索引
（1）hash类型的索引：查询单条快，范围查询慢
（2）btree类型的索引：b+树，层数越多，数据量指数级增加（咱们就用它，由于innodb默认支持它）

3.1 普通索引

做用：仅有一个加速查找

create table userinfo(
                   nid int not null auto_increment primary key,
                   name varchar(32) not null,
                   email varchar(64) not null,
                   index ix_name(name)
               );

create index 索引的名字 on 表名(列名)

drop index 索引的名字 on 表名

show index from 表名

3.2 惟一索引

惟一索引有两个功能：加速查找和惟一约束（可含null）

  create table userinfo(
                   id int not null auto_increment primary key,
                   name varchar(32) not null,
                   email varchar(64) not null,
                   unique  index  ix_name(name)
               );

create unique index 索引名 on 表名(列名)

drop index 索引名 on 表名;

3.3 主键索引

主键索引有两个功能：加速查找和惟一约束（不含null）

    create table userinfo(

                   id int not null auto_increment primary key,
                   name varchar(32) not null,
                   email varchar(64) not null,
                   unique  index  ix_name(name)
           )
          or

           create table userinfo(

                   id int not null auto_increment,
                   name varchar(32) not null,
                   email varchar(64) not null,
                   primary key(nid),
                   unique  index  ix_name(name)
         )

alter table 表名 add primary key(列名);

alter table 表名 drop primary key;
alter table 表名  modify  列名 int, drop primary key;

3.4 组合索引

组合索引是将n个列组合成一个索引

其应用场景为：频繁的同时使用n列来进行查询，如：where name = 'alex' and email = 'alex@qq.com'。

create index 索引名 on 表名(列名1,列名2);

4、索引名词

#覆盖索引：在索引文件中直接获取数据
        例如：
        select name from userinfo where name = 'alex50000';


#索引合并：把多个单列索引合并成使用
        例如：
        select * from  userinfo where name = 'alex13131' and id = 13131;

6、正确使用索引的状况

　　数据库表中添加索引后确实会让查询速度起飞，但前提必须是正确的使用索引来查询，若是以错误的方式使用，则即便创建索引也会不奏效。

　　使用索引，咱们必须知道：

　　　　（1）建立索引

　　　　（2）命中索引

　　　　（3）正确使用索引

　准备：

准备300w条数据

测试：

　　　　 - like '%xx'
            select * from userinfo where name like '%al';
        - 使用函数
            select * from userinfo where reverse(name) = 'alex333';
        - or
            select * from userinfo where id = 1 or email = 'alex122@oldbody';
            特别的：当or条件中有未创建索引的列才失效，如下会走索引
                    select * from userinfo where id = 1 or name = 'alex1222';
                    select * from userinfo where id = 1 or email = 'alex122@oldbody' and name = 'alex112'
        - 类型不一致
            若是列是字符串类型，传入条件是必须用引号引发来，否则...
            select * from userinfo where name = 999;
        - !=
            select count(*) from userinfo where name != 'alex'
            特别的：若是是主键，则仍是会走索引
                select count(*) from userinfo where id != 123
        - >
            select * from userinfo where name > 'alex'
            特别的：若是是主键或索引是整数类型，则仍是会走索引
                select * from userinfo where id > 123
                select * from userinfo where num > 123
        - order by
            select email from userinfo order by name desc;
            当根据索引排序时候，选择的映射若是不是索引，则不走索引
            特别的：若是对主键排序，则仍是走索引：
                select * from userinfo order by nid desc;
         
        - 组合索引最左前缀
            若是组合索引为：(name,email)
            name and email       -- 使用索引
            name                 -- 使用索引
            email                -- 不使用索引

什么是最左前缀呢？

最左前缀匹配：
        create index ix_name_email on userinfo(name,email);
                 select * from userinfo where name = 'alex';
                 select * from userinfo where name = 'alex' and email='alex@oldBody';

                 select * from userinfo where  email='alex@oldBody';

             若是使用组合索引如上，name和email组合索引以后，查询
             （1）name和email ---使用索引
             （2）name        ---使用索引
             （3）email       ---不适用索引
              对于同时搜索n个条件时，组合索引的性能好于多个单列索引
　　　　　　　　******组合索引的性能>索引合并的性能*********

7、索引的注意事项

       (1)避免使用select *
       (2)count(1)或count(列) 代替count(*)
       (3)建立表时尽可能使用char代替varchar
       (4)表的字段顺序固定长度的字段优先
       (5)组合索引代替多个单列索引（常用多个条件查询时）
       (6)尽可能使用短索引 （create index ix_title on tb(title(16));特殊的数据类型 text类型）
       (7)使用链接（join）来代替子查询
       (8)连表时注意条件类型需一致
       (9)索引散列（重复少）不适用于建索引，例如：性别不合适

8、执行计划

　　explain + 查询SQL - 用于显示SQL执行信息参数，根据参考信息能够进行SQL优化

mysql> explain select * from userinfo;
    +----+-------------+----------+------+---------------+------+---------+------+---------+-------+
    | id | select_type | table    | type | possible_keys | key  | key_len | ref  | rows    | Extra |
    +----+-------------+----------+------+---------------+------+---------+------+---------+-------+
    |  1 | SIMPLE      | userinfo | ALL  | NULL          | NULL | NULL    | NULL | 2973016 | NULL  |
    +----+-------------+----------+------+---------------+------+---------+------+---------+-------+

    mysql> explain select * from (select id,name from userinfo where id <20) as A;
    +----+-------------+------------+-------+---------------+---------+---------+------+------+-------------+
    | id | select_type | table      | type  | possible_keys | key     | key_len | ref  | rows | Extra       |
    +----+-------------+------------+-------+---------------+---------+---------+------+------+-------------+
    |  1 | PRIMARY     | <derived2> | ALL   | NULL          | NULL    | NULL    | NULL |   19 | NULL        |
    |  2 | DERIVED     | userinfo   | range | PRIMARY       | PRIMARY | 4       | NULL |   19 | Using where |
    +----+-------------+------------+-------+---------------+---------+---------+------+------+-------------+
    2 rows in set (0.05 sec)

参数说明：

select_type：
                查询类型
                    SIMPLE          简单查询
                    PRIMARY         最外层查询
                    SUBQUERY        映射为子查询
                    DERIVED         子查询
                    UNION           联合
                    UNION RESULT    使用联合的结果
table：
                正在访问的表名
type：
                查询时的访问方式，性能：all < index < range < index_merge < ref_or_null < ref < eq_ref < system/const
                ALL             全表扫描，对于数据表从头至尾找一遍
                                select * from userinfo;
                                特别的：若是有limit限制，则找到以后就不在继续向下扫描
                                       select * from userinfo where email = 'alex112@oldboy'
                                       select * from userinfo where email = 'alex112@oldboy' limit 1;
                                       虽然上述两个语句都会进行全表扫描，第二句使用了limit，则找到一个后就再也不继续扫描。

INDEX ：      全索引扫描，对索引从头至尾找一遍
                                select nid from userinfo;

RANGE：        对索引列进行范围查找
                                select *  from userinfo where name < 'alex';
                                PS:
                                    between and
                                    in
                                    >   >=  <   <=  操做
                                    注意：!= 和 > 符号


INDEX_MERGE：  合并索引，使用多个单列索引搜索
                                select *  from userinfo where name = 'alex' or nid in (11,22,33);

REF：       根据索引查找一个或多个值
                                select *  from userinfo where name = 'alex112';

EQ_REF：    链接时使用primary key 或 unique类型
                                select userinfo2.id,userinfo.name from userinfo2 left join tuserinfo on userinfo2.id = userinfo.id;



CONST：常量
            表最多有一个匹配行,由于仅有一行,在这行的列值可被优化器剩余部分认为是常数,const表很快,由于它们只读取一次。
                 select id from userinfo where id = 2 ;

SYSTEM：系统
             表仅有一行(=系统表)。这是const联接类型的一个特例。
                 select * from (select id from userinfo where id = 1) as A;


possible_keys：可能使用的索引

key：真实使用的

key_len：　　MySQL中使用索引字节长度

rows： mysql估计为了找到所需的行而要读取的行数 ------ 只是预估值

extra：
                该列包含MySQL解决查询的详细信息
                “Using index”
                    此值表示mysql将使用覆盖索引，以免访问表。不要把覆盖索引和index访问类型弄混了。
                “Using where”
                    这意味着mysql服务器将在存储引擎检索行后再进行过滤，许多where条件里涉及索引中的列，当（而且若是）它读取索引时，就能被存储引擎检验，所以不是全部带where子句的查询都会显示“Using where”。有时“Using where”的出现就是一个暗示：查询可受益于不一样的索引。
                “Using temporary”
                    这意味着mysql在对查询结果排序时会使用一个临时表。
                “Using filesort”
                    这意味着mysql会对结果使用一个外部索引排序，而不是按索引次序从表里读取行。mysql有两种文件排序算法，这两种排序方式均可以在内存或者磁盘上完成，explain不会告诉你mysql将使用哪种文件排序，也不会告诉你排序会在内存里仍是磁盘上完成。
                “Range checked for each record(index map: N)”
                    这个意味着没有好用的索引，新的索引将在联接的每一行上从新估算，N是显示在possible_keys列中索引的位图，而且是冗余的

9、慢日志记录

开启慢查询日志，可让MySQL记录下查询超过指定时间的语句，经过定位分析性能的瓶颈，才能更好的优化数据库系统的性能。

(1) 进入MySql 查询是否开了慢查询
         show variables like 'slow_query%';
         参数解释：
             slow_query_log 慢查询开启状态  OFF 未开启 ON 为开启
        slow_query_log_file 慢查询日志存放的位置（这个目录须要MySQL的运行账号的可写权限，通常设置为MySQL的数据存放目录）

（2）查看慢查询超时时间
       show variables like 'long%';
       ong_query_time 查询超过多少秒才记录   默认10秒 

（3）开启慢日志（1）（是否开启慢查询日志，1表示开启，0表示关闭。）
           set global slow_query_log=1;
（4）再次查看
              show variables like '%slow_query_log%';

（5）开启慢日志（2）：（推荐）
         在my.cnf 文件中
         找到[mysqld]下面添加：
           slow_query_log =1
   　　　　 slow_query_log_file=C:\mysql-5.6.40-winx64\data\localhost-slow.log
    　　　  long_query_time = 1

    参数说明：
        slow_query_log 慢查询开启状态  1 为开启
        slow_query_log_file 慢查询日志存放的位置
        long_query_time 查询超过多少秒才记录   默认10秒 修改成1秒

10、分页性能相关方案

先回顾一下，如何取当前表中的前10条记录，每十条取一次.......

第1页：
select * from userinfo limit 0,10;
第2页：
select * from userinfo limit 10,10;
第3页：
select * from userinfo limit 20,10;
第4页：
select * from userinfo limit 30,10;
......
第2000010页
select * from userinfo limit 2000000,10;

PS:会发现，越日后查询，须要的时间约长，是由于越日后查，全文扫描查询，会去数据表中扫描查询。

最优的解决方案

（1）只有上一页和下一页
        作一个记录：记录当前页的最大id或最小id
        下一页：
        select * from userinfo where id>max_id limit 10;

        上一页：
        select * from userinfo where id<min_id order by id desc limit 10;


  (2) 中间有页码的状况
           select * from userinfo where id in(
               select id from (select * from userinfo where id > pre_max_id limit (cur_max_id-pre_max_id)*10) as A order by A.id desc limit 10
           );

MySql的相关资操做 01-MySql的前戏 02-数据库概述 03-MySql安装和基本管理 04-基本的mysql语句 05-库的操做 06-表的操做 07-数据类型 08-数据类型(2) 09

MySql的前戏

什么是数据（Data）

什么是数据库（DataBase,简称DB）

什么是数据库管理系统（DataBase Management System）

数据库服务器、数据管理系统、数据库、表与记录的关系（重点理解！！！）

本节掌握内容：

MySQL的介绍安装、启动

MySQL破解密码

MySQL中统一字符编码

应用环境

mysql是什么？

数据库管理软件分类

mysql的下载安装

window版本

windows下登陆设置密码

密码忘记——破解密码

统一字符编码

本节课先对mysql的基本语法初体验。

操做文件夹（库）

增

查

改

删

操做文件（表）

增

查

改

删

操做文件内容（记录）

增

查

改

删

本节重点：

1、系统数据库

2、建立数据库

3、数据库相关操做

4、了解内容

本节掌握

1、存储引擎（了解）

2、mysql支持的存储引擎

3、表介绍

4、建立表

介绍

1、数值类型

2、浮点型

3、日期类型

字符类型

枚举类型和集合类型

1、介绍

2、not null 与default

三、unique

4.primary key

5.auto_increment

6.foreign key

1、介绍

2、重点理解若是找出两张表之间的关系

3、表的三种关系

1、多表链接查询

2、符合条件链接查询

3、子查询

权限管理

1、pymysql的下载和使用

2、execute()之sql注入

3、增、删、改：conn.commit()

4、查：fetchone、fetchmany、fetchall

1、索引的介绍

二 、索引的做用

3、常见的几种索引：

3.1 普通索引

3.2 惟一索引

3.3 主键索引

3.4 组合索引

4、索引名词

6、正确使用索引的状况

什么是最左前缀呢？

7、索引的注意事项

8、执行计划

9、慢日志记录

二、索引的做用