数据库--mysql

一.数据库
1.数据库(database,DB)
是指长期存储在计算机内的，有组织，可共享的数据的集合，存储数据的仓库。
2.数据库管理系统软件
(1)数据库管理系统(Database Management System)是一种操纵和管理数据库的大型软件，用于建立、使用和维护数据库，简称DBMS。
(2)数据库管理系统对数据库进行统一的管理和控制，以保证数据库的安全性和完整性。用户通过DBMS访问数据库中的数据，数据库管理员也通过dbms进行数据库的维护工作。它可使多个应用程序和用户用不同的方法在同时或不同时刻去建立，修改和询问数据库。大部分DBMS提供数据定义语言DDL（Data Definition Language）和数据操作语言DML（Data Manipulation Language），供用户定义数据库的模式结构与权限约束，实现对数据的追加、删除等操作。
(3)数据库管理系统是数据库系统的核心，是管理数据库的软件。数据库管理系统就是实现把用户意义下抽象的逻辑数据处理，转换成为计算机中具体的物理数据处理的软件。有了数据库管理系统，用户就可以在抽象意义下处理数据，而不必顾及这些数据在计算机中的布局和物理位置。
(4)常见的数据库管理软件：甲骨文的oracle,IBM的db2，sql server, Access,Mysql(开源,免费,跨平台)
3.数据库系统DBS(Data Base System,简称DBS)
通常由软件、数据库和数据管理员组成。其软件主要包括操作系统、各种宿主语言、实用程序以及数据库管理系统。数据库由数据库管理系统统一管理，数据的插入、修改和检索均要通过数据库管理系统进行。数据管理员负责创建、监控和维护整个数据库，使数据能被任何有权使用的人有效使用。
二.mysql数据库管理软件
1.sql及其规范
(1)sql：是Structured Query Language(结构化查询语言)的缩写。SQL是专为数据库而建立的操作命令集，是一种功能齐全的数据库语言。
<1>在数据库系统中，SQL语句不区分大小写(建议用大写) 。但字符串常量区分大小写。建议命令大写，表名库名小写；
<2>SQL语句可单行或多行书写，以“;”结尾。关键词不能跨多行或简写。
<3>用空格和缩进来提高语句的可读性。子句通常位于独立行，便于编辑，提高可读性。
<4>注释：单行注释：--   多行注释：/*......*/
<5>sql语句可以折行操作
<6>sql语句包含：DDL定义语言,DML操作语言和DCL控制语言
2.数据库操作(DDL)
(1)创建数据库(在磁盘上创建一个对应的文件夹)
语法：create database 数据库名字;
语句：

create database db_name;

(2)查看数据库
<1>查看所有数据库

show databases;

<2>查看数据库的创建方式

show create database db_name; 

+----------+------------------------------------------------------------------+
| Database | Create Database                                                  |
+----------+------------------------------------------------------------------+
| boss_ui  | CREATE DATABASE `db_name` /*!40100 DEFAULT CHARACTER SET utf8 */ |
+----------+------------------------------------------------------------------+
1 row in set
(3)修改数据库编码
语法：alter database 库名 character set utf8;
(4)删除数据库
语法：drop database 库名;  
(5)切换数据库
语法：use 库名;   
注意：进入到某个数据库后没办法再退回之前状态，但可以通过use进行切换查看当前使用的数据库 select database();
3.mysql数据类型,MySQL支持多种类型，大致可以分为三类：数值、日期/时间和字符串(字符)类型。
(1)数值类型
<1>TINYINT(及小型)，年龄，包含在0-255之间
<2>SMALLINT(小型)，端口号，包含在0-65535之间
<3>MEDIUMINT(中型)，中小型网站注册会员，1600万够用
<4>INT(普通型)，身份证编号，42亿可以用很久
<5>BIGINT(大型)，微博量，几百亿
注意：由于mysql中不存在布尔型，所以一般来说我们可以使用TINYINT(1)来创建字段，用0表示false,1表示true
(2)日期/时间类型分别为：DATE,DATETIME,TIME,YEAR,TIMESTAMP。
<1>YEAR类型：包含1个字节，最小值1901，最大值2155
YEAR占用1个字节，包含年份，长度默认为4位，无法设置
<2>TIME类型：包含3个字节，最小值-838:59:89，最大值838:59:59
TIME占用3个字节，包含时分秒，长度0到6之间，用于设置微秒。对于TIME的范围是-838到838的原因，是印伟TIME类型不但可以保存一天的时，还可以包含时间之间的间隔。
<3>DATE类型：包含4个字节，最小值1000-01-01，最大值9999-12-31
DATE占用3个字节，包含年月日，范围和DATETIME一样。DATE长度是0，无法设置。
<4>TIMESTAMP类型：包含4个字节，最小值1970-01-01 00:00:00，最大值2038-01-19 03:14:07
TIMESTAMP占4个字节，可以包含完整的年月日时分秒，无法指定长度，不能存储微秒。范围只能存储1970年至2038年，对于想存储前后久远的时间就无法满足了。比较合适存储经常插入或者更新日期为当前系统时间的环境，比如注册时间或者登录时间的存储，由于TIMESTAMP固定为19个字符，且范围比DATETIME小，所以所占空间就小。
TIMESTAMP有几个特点：
①当更新一条数据的时候，设置此类型根据当前系统更新可以自动更新时间
②如果插入一条NULL，也会自动插入当前系统时间。
③创建字段时，系统会给一个默认值
④会根据当前时区来存储和查询时间，存储时对当前时区进行转换，查询时再转换为当前的时区。
查看当前时区：默认是东八区
语句：

SHOW VARIABLES LIKE '%time_zone%';

+------------------+--------------+
| Variable_name    | Value  |
+------------------+--------------+
| system_time_zone | CST |
| time_zone        | SYSTEM|
+------------------+--------------+
设置时区：设置为东九区，查询时间就会加一小时

SET time_zone='+9:00';

<5>DATETIME类型：包含8个字节，最小值1000-01-01 00:00:00，最大值9999-12-31 23:59:59
DATETIME占用8个字节，可以包含完整的年月日时分秒，范围很大不必考虑。当创建类型的时候，可以设置它的长度0到6位之间，如果是0，只包含年月日时分秒；如果是1-6之间，就包含M为的微秒。DATETIME类型直接保存日期时间格式，取值赋值也比较方便，并且没有时区的问题，问题是占用空间最大。
注意：对于日期格式要求相对宽松，主要有以下几种：
①2017-10-10 10:10:10
②2017/10/10 10+10+10
③20171010101010
④17/10/10 10@10@10
(3)字符串(字符)类型
(1)CHAR字节M(0-255)字节，设置M为固定长度的字符
(2)VARCHAR字节M(0-N)字符，设置M为最大长度的字符，最大的字节为65535，在UTF8下，N最大是21844
CHAR是保存定长字符串，而VARCHAR则是保存变长字符串。CHAR(5)表示必须保存5个字符，而VARCHAR(5)则表示最大保存字符为5。
创建CHAR(5)和VARCHAR(5)，分别输入一个字符：“a”。通过查询语句来查看他们的长度
查看CHAR的长度
SELECT LENGTH(char1) FROM think_test;
+---------------+
| LENGTH(char1) |
+---------------+
|             1 |
+---------------+
1 row in set
查看varchar的长度
SELECT LENGTH(varchar1) FROM think_test;
+------------------+
| LENGTH(varchar1) |
+------------------+
|                1 |
+------------------+
1 row in set
这里的char和varchar的长度俩个结果都为1，单位是字节，也就是说"a"字符插入到CHAR和VARCHAR中所占的空间为1个字节，而实际上CHAR占了5个字节，VARCHAR为1+1=2个字节
虽然在SELECT语句自动删除了空白，但CHAR类型内部还是存储了5个字符。可以通过SQL_MODE设置为PAD_CHAR_TO_FULL_LENGTH来查看完整的长度。
SET SQL_MODE='PAD_CHAR_TO_FULL_LENGTH';
Query OK, 0 rows affected
设置完整的长度后查看CHAR的长度
SELECT LENGTH(char1) FROM think_test;
+---------------+
| LENGTH(char1) |
+---------------+
|             5 |
+---------------+
1 row in set
如果是UTF8编码下，长度为5的CHAR类型，最多插入5个字符，最多可以存储15字节，也就是5个汉子的内容。因为一个汉子占3个字节。
由于CHAR类型是定长，MYSQL会根据定义的长度进行分配空间，在处理速度上比VARCHAR快的多，所以适合存储如手机，身份证这种定长的字符，否则就会造成浪费。、
那么CHAR类型最大可以插入255个字符，最多可以存储765个字节。
对于VARCHAR变长类型，适合存储不定长度的字符串。不管设置了多长的字符，它会按需求分配字节存储空间，不会浪费，当然，在插入0-255字节时，会占用额外1个字节用于计算长度，大于255的则需要2个字节，那么其实真正有效存储的字节数为65533。而对于UTF8编码下，一个字符最大占用3个字节，那么其实VARCHAR(M)中的M最大21844个字符。
注意：虽然VARCHAR理论上最大长度是21844字符，当这个表还包含其他字段时，还要减去其他字段所占的字符数。
在变长VARCHAR(5)和VARCHAR(1000)中，保存童颜的一条数据"a",所占用的空间是一样的，但问题是，长度设置越大，在分配内存处理的时候会消耗更多。所以，我们最好的策略是设置一个最恰当的长度。
(3)BINARY字节M(0-255)字节，存储固定长度的二进制字符串
(4)VARBINARY字节M(0-65535)字节，存储最大长度的字节，最大是65533
BINARY和VARBINARY是采用二进制存储的，没有字符集概念，意义在于防止字符集的问题导致数据丢失，存储中文会占用俩个字符，会乱码，半截会问号。因为是蚕蛹二进制存储，在比较字符和排序的时候，都是二进制进行的，所以只有需要操作二进制时才需要使用。
上面四个了解定长和变长的字符类型，这四种类型都适合短字符存储。那么还有八种适合文本内容的大数据类型：TINYTEXT,TEXT,MEDIUMTEXT,LONGTEXT,TINYBLOG,BLOB,MEDIUMTEXT,LONGTEXT。这里比较主要的就是TEXT类型和BLOB类型，一个是普通文本类型，一个是二进制存储的文本类型。
(5)TINYTEXT范围：0-255所占空间是本身长度+2
(6)TEXT范围：0-65535所占空间是本身长度+2
(7)MEDIUMTEXTf范围：0-167772150所占空间是本身长度+3
(8)LONGTEXT范围：0-4294967295所占空间是本身长度+4
一般我们把TEXT等类型理解为数据超大的VARCHAR类型，当我们输入的字符长度超过VARCHAR本身最大长度，就会自动换成MEDIUMTEXT或LONGTEXT俩种类型。
(9)TINYBLOG范围：0-255所占空间是本身长度+2
(10)BLOB范围：0-65535所占空间是本身长度+2
(11)MEDIUMTEXT范围：0-16777215所占空间是本身长度+3
(12)LONGTEXT范围：0-4294967295所占空间是本身长度+4
注意：我们把短小定长的字符存储在CHAR类型，把短小变长的字符存VARCHAR，把内容较多的文本或各种内容存TEXT以及更大的类型中，另外，CHAR和VARCHAR在创建时可以设置默认值，而TEXT没有默认值，且TEXT不需要设置长度。
TEXT一组文本类型可以保存文章文字内容，而BLOB是二进制存储，可以保存比如图片之类的信息。
TEXT的范围和存储空间，我们可以用TINYEXT做测试。它的范围是(0-255)字节，那么我们通过村满发现，可以存85个汉子，即255字节，最终占用空间还要+2，其他三种以此类推。
(13)ENUM最大支持65535个成员
(14)SET最大支持64个成员
ENUM类型成为枚举类型，创建此类型一般用于单选操作，比如性别，最大支持65535个成员。1-255占1个字节，大于255占2个字节，用于单选。
SET和ENUM相对，创建此类型一般用于多选操作，比如兴趣爱好。1-8占1个字节，9-16占2个字节，17-24占3个字节，25-32占4个字节，33-64占8个字节，用于多选。
虽然显示的字符串，但存储的是int整型
<1>CHAR和VARCHAR类型类似，但它们保存和检索的方式不同。它们的最大长度和是否尾部空格被保留等方面也不同。在存储或检索过程中不进行大小写转换。
<2>BINARY和VARBINARY类类似于CHAR和VARCHAR，不同的是它们包含二进制字符串而不要非二进制字符串。也就是说，它们包含字节字符串而不是字符字符串。
<3>BLOB是一个二进制大对象，可以容纳可变数量的数据。有4种BLOB类型：TINYBLOB、BLOB、MEDIUMBLOB和LONGBLOB。它们只是可容纳值的最大长度不同。
<4>有4种TEXT类型：TINYTEXT、TEXT、MEDIUMTEXT和LONGTEXT。这些对应4种BLOB类型，有相同的最大长度和存储需求。
4.数据表操作
(1)完整性约束条件之主键约束
<1>单字段主键特点：非空且唯一
<2>多字段联合主键:
1)一张表只能有一个主键
2)主键类型不一定非是整型
(2)创建表：
<1>语法：
create table 表名(
            id 类型 primary key(非空且唯一,能够唯一区分出当前记录的字段称为主键) auto_increment(自增,主键字段必须是数字类型)
            字段名 类型[完整性约束条件],
            字段名 类型,
            ...
            字段名 类型
        );
<2>创建一个员工表xixi语句：

create table xixi(
            id int primary key auto_increment,  
            name varchar(20)
          );

(3)查看表信息
<1>查看表结构语句：desc xixi;  
+-------+-------------+------+-----+---------+----------------+
| Field | Type        | Null | Key | Default | Extra          |
+-------+-------------+------+-----+---------+----------------+
| id    | int(11)     | NO   | PRI | NULL    | auto_increment |
| name  | varchar(20) | YES  |     | NULL    |                |
+-------+-------------+------+-----+---------+----------------+
<2>查看当前数据库中的所有的表语句：show tables;
+----------------+
| Tables_in_xixi |
+----------------+
| xixi           |
+----------------+
<3>查看当前数据库表建表语句:show create table xixi;
(4)修改表结构
<1>增加列(字段)
1)增加一个字段：
语法：alter table 表名 add [column] 列名 类型［完整性约束条件］［first｜after 字段名］;

alter table xixi add entry_date date not null;

+------------+-------------+------+-----+---------+----------------+
| Field      | Type        | Null | Key | Default | Extra          |
+------------+-------------+------+-----+---------+----------------+
| id         | int(11)     | NO   | PRI | NULL    | auto_increment |
| name       | varchar(20) | YES  |     | NULL    |                |
| entry_date | date        | NO   |     | NULL    |                |
+------------+-------------+------+-----+---------+----------------+
2)增加多个字段语句：

alter table xixi
            add addr varchar(20),
            add age  int first,
            add birth varchar(20) after name;

+------------+-------------+------+-----+---------+----------------+
| Field      | Type        | Null | Key | Default | Extra          |
+------------+-------------+------+-----+---------+----------------+
| age        | int(11)     | YES  |     | NULL    |                |
| id         | int(11)     | NO   | PRI | NULL    | auto_increment |
| name       | varchar(20) | YES  |     | NULL    |                |
| birth      | varchar(20) | YES  |     | NULL    |                |
| entry_date | date        | NO   |     | NULL    |                |
| addr       | varchar(20) | YES  |     | NULL    |                |
+------------+-------------+------+-----+---------+----------------+
<2>删除列
1)删除一列
语法：alter table 表名 DROP [column] 列名;

alter table xixi DROP resume;

+------------+-------------+------+-----+---------+----------------+
| Field      | Type        | Null | Key | Default | Extra          |
+------------+-------------+------+-----+---------+----------------+
| age        | int(11)     | YES  |     | NULL    |                |
| id         | int(11)     | NO   | PRI | NULL    | auto_increment |
| name       | varchar(20) | YES  |     | NULL    |                |
| birth      | varchar(20) | YES  |     | NULL    |                |
| entry_date | date        | NO   |     | NULL    |                |
+------------+-------------+------+-----+---------+----------------+
2)删除多列语句：

alter table xixi DROP birth,DROP entry_date;

+-------+-------------+------+-----+---------+----------------+
| Field | Type        | Null | Key | Default | Extra          |
+-------+-------------+------+-----+---------+----------------+
| age   | int(11)     | YES  |     | NULL    |                |
| id    | int(11)     | NO   | PRI | NULL    | auto_increment |
| name  | varchar(20) | YES  |     | NULL    |                |
+-------+-------------+------+-----+---------+----------------+
<3>修改一列类型
语法：alter table tab_name modify 列名 类型 [完整性约束条件]［first｜after 字段名］;
修改xixi表里的age列的Type改成smallint，Null不能为空，Default默认值18移动到id的后面

alter table xixi modify age smallint not null default 18 after id;

+-------+-------------+------+-----+---------+----------------+
| Field | Type        | Null | Key | Default | Extra          |
+-------+-------------+------+-----+---------+----------------+
| id    | int(11)     | NO   | PRI | NULL    | auto_increment |
| age   | smallint(6) | NO   |     | 18      |                |
| name  | varchar(20) | YES  |     | NULL    |                |
+-------+-------------+------+-----+---------+----------------+
<4>修改列名    
语法：alter table 表名 change [column] 列名 新列名 类型 [完整性约束条件]［first｜after 字段名］;
修改xixi表里的age改为Age，类型还是smallint放到name后面
语句：

alter table xixi change age Age smallint after name;

+-------+-------------+------+-----+---------+----------------+
| Field | Type        | Null | Key | Default | Extra          |
+-------+-------------+------+-----+---------+----------------+
| id    | int(11)     | NO   | PRI | NULL    | auto_increment |
| name  | varchar(20) | YES  |     | NULL    |                |
| Age   | smallint(6) | YES  |     | NULL    |                |
+-------+-------------+------+-----+---------+----------------+
<5>修改表名
语法：rename table 旧表名 to 新表名;

rename table xixi to wangxixi;

+----------------+
| Tables_in_xixi |
+----------------+
| wangxixi       |
+----------------+
(5)删除表
语法：drop table 表名;
5.表纪录操作之增，删，改
+----------+-------------+------+-----+---------+----------------+
| Field    | Type        | Null | Key | Default | Extra          |
+----------+-------------+------+-----+---------+----------------+
| id       | int(11)     | NO   | PRI | NULL    | auto_increment |
| name     | varchar(20) | NO   | UNI | NULL    |                |
| birthday | varchar(20) | YES  |     | NULL    |                |
| salary   | float(7,2)  | YES  |     | NULL    |                |
+----------+-------------+------+-----+---------+----------------+
(1)增加记录
<1>增加一条记录
方式一：
语法：insert ［into］ 表名 (字段1,字段2,.......) values (值1,值2,.......);
语句：

insert into xixi (id,name,birthday,salary) values (1,'xixi','2000-20-20',2000);

+----+------+------------+---------+
| id | name | birthday   | salary  |
+----+------+------------+---------+
|  1 | xixi | 2000-20-20 | 2000.00 |
+----+------+------------+---------+
方式二：
语句：

insert into xixi (name,salary) values ('wang',1000);

+----+------+------------+---------+
| id | name | birthday   | salary  |
+----+------+------------+---------+
|  1 | xixi | 2000-20-20 | 2000.00 |
|  2 | wang | NULL       | 1000.00 |
+----+------+------------+---------+
<2>插入多条数据
方式一：

insert into xixi values
       (4,'shi','2001-20-21',3000),
       (5,'yao','2002-20-22',5000);

+----+------+------------+---------+
| id | name | birthday   | salary  |
+----+------+------------+---------+
|  1 | xixi | 2000-20-20 | 2000.00 |
|  2 | wang | NULL       | 1000.00 |
|  4 | shi  | 2001-20-21 | 3000.00 |
|  5 | yao  | 2002-20-22 | 5000.00 |
+----+------+------------+---------+
方式二：

INSERT INTO xixi (name,salary) VALUES ('chi',6000),
    ('he',9000);

+----+------+------------+---------+
| id | name | birthday   | salary  |
+----+------+------------+---------+
|  1 | xixi | 2000-20-20 | 2000.00 |
|  2 | wang | NULL       | 1000.00 |
|  4 | shi  | 2001-20-21 | 3000.00 |
|  5 | yao  | 2002-20-22 | 5000.00 |
|  6 | chi  | NULL       | 6000.00 |
|  7 | he   | NULL       | 9000.00 |
+----+------+------------+---------+
方式三：
语法：set插入: insert ［into］ 表名 set 字段名=值

insert into xixi set id=8,name="wan";

+----+------+------------+---------+
| id | name | birthday   | salary  |
+----+------+------------+---------+
|  1 | xixi | 2000-20-20 | 2000.00 |
|  2 | wang | NULL       | 1000.00 |
|  4 | shi  | 2001-20-21 | 3000.00 |
|  5 | yao  | 2002-20-22 | 5000.00 |
|  6 | chi  | NULL       | 6000.00 |
|  7 | he   | NULL       | 9000.00 |
|  8 | wan  | NULL       |    NULL |
+----+------+------------+---------+
(2)修改数据：
语法：update 表名 set 字段=修改的值,字段2=修改的值,......[where 语句]
UPDATE语法可以用新值更新原有表行中的各列。
SET子句指示要修改哪些列和要给予哪些值。
WHERE子句指定应更新哪些行。如没有WHERE子句,则更新所有的行。

update xixi set birthday="2018-12-24" WHERE id=1;

修改id=1的birthday改为2018-12-24
+----+------+------------+---------+
| id | name | birthday   | salary  |
+----+------+------------+---------+
|  1 | xixi | 2018-12-24 | 2000.00 |
|  2 | wang | NULL       | 1000.00 |
|  4 | shi  | 2001-20-21 | 3000.00 |
|  5 | yao  | 2002-20-22 | 5000.00 |
|  6 | chi  | NULL       | 6000.00 |
|  7 | he   | NULL       | 9000.00 |
|  8 | wan  | NULL       |    NULL |
+----+------+------------+---------+
(3)删除表纪录
语法：delete from 表名 [where ....]
如果不跟where语句则删除整张表中的数据，delete只能用来删除一行记录，delete语句只能删除表中的内容，不能删除表本身，想要删除表，用drop TRUNCATE TABLE也可以删除表中的所有数据，词语句首先摧毁表，再新建表。此种方式删除的数据不能在事务中恢复
<1>删除一条语句：删除表中名称为’chi’的记录。

delete from xixi where name='chi';

+----+------+------------+---------+
| id | name | birthday   | salary  |
+----+------+------------+---------+
|  1 | xixi | 2018-12-24 | 2000.00 |
|  2 | wang | NULL       | 1000.00 |
|  4 | shi  | 2001-20-21 | 3000.00 |
|  5 | yao  | 2002-20-22 | 5000.00 |
|  7 | he   | NULL       | 9000.00 |
|  8 | wan  | NULL       |    NULL |
+----+------+------------+---------+
<2>删除多条语句：删除表中名称为’he’和'wan'的记录。

delete from xixi where name='he' OR name='wan';

+----+------+------------+---------+
| id | name | birthday   | salary  |
+----+------+------------+---------+
|  1 | xixi | 2018-12-24 | 2000.00 |
|  2 | wang | NULL       | 1000.00 |
|  4 | shi  | 2001-20-21 | 3000.00 |
|  5 | yao  | 2002-20-22 | 5000.00 |
+----+------+------------+---------+
<3>删除所有记录
方式一：删除方式是一条一条删
语法：delete from 表名;  --注意auto_increment没有被重置:alter table employee auto_increment=1;

DELETE FROM xixi;

方式二：是把表删掉在创建一个一样的表
truncate table 表名;

truncate table xixi;

6.表纪录操作之查(单表查询)
<1>查找表内容
1)查询表里所有内容
语法：select * from 表名     --其中from指定从哪张表筛选，*表示查找所有列

select * from ExamResult;

+----+------+------+--------+-----------+
| id | name | JS   | Django | OpenStack |
+----+------+------+--------+-----------+
|  1 | xixi |   98 |     98 |        98 |
|  2 | wang |   35 |     98 |        67 |
|  3 | shi  |   59 |     59 |        62 |
|  4 | yao  |   88 |     89 |        82 |
|  5 | chi  |   88 |     98 |        67 |
|  6 | wan  |   86 |    100 |        55 |
+----+------+------+--------+-----------+
2)查询表中单独俩列：所有学生的name和对应的JS成绩
语法：select 字段1,字段2，......  from 表名   --可以指定一个列。表明确指定要查找的列

select name,JS from ExamResult;

+------+------+
| name | JS   |
+------+------+
| xixi |   98 |
| wang |   35 |
| shi  |   59 |
| yao  |   88 |
| chi  |   88 |
| wan  |   86 |
+------+------+
3)过滤表中重复数据
语法：select [distinct] 字段1,字段2，..... from 表名  --distinct用来剔除重复行。

select distinct JS from ExamResult;

+------+
| JS   |
+------+
|   98 |
|   35 |
|   59 |
|   88 |
|   86 |
+------+
<2>使用表达式查询
1)在所有学生分数上加10分特长分显示。

select name,JS+10,Django+10,OpenStack+10 from ExamResult;

+------+-------+-----------+--------------+
| name | JS+10 | Django+10 | OpenStack+10 |
+------+-------+-----------+--------------+
| xixi |   108 |       108 |          108 |
| wang |    45 |       108 |           77 |
| shi  |    69 |        69 |           72 |
| yao  |    98 |        99 |           92 |
| chi  |    98 |       108 |           77 |
| wan  |    96 |       110 |           65 |
+------+-------+-----------+--------------+
2)统计每个学生的总分显示

select name,JS+Django+OpenStack from ExamResult;

+------+---------------------+
| name | JS+Django+OpenStack |
+------+---------------------+
| xixi |                 294 |
| wang |                 200 |
| shi  |                 180 |
| yao  |                 259 |
| chi  |                 253 |
| wan  |                 241 |
+------+---------------------+
3)使用别名显示学生总分
语法：select 字段1 as 别名,字段2 as 别名 from 表名;

select name as 姓名,JS+Django+OpenStack as 总成绩 from ExamResult;

+--------+-----------+
| 姓名   | 总成绩    |
+--------+-----------+
| xixi   |       294 |
| wang   |       200 |
| shi    |       180 |
| yao    |       259 |
| chi    |       253 |
| wan    |       241 |
+--------+-----------+
<3>使用where子句，进行过滤查询
1)比较运算符：> < >= <= <> !=
查询姓名为xixi的学生成绩

select * from ExamResult where name='xixi';

+----+------+------+--------+-----------+
| id | name | JS   | Django | OpenStack |
+----+------+------+--------+-----------+
|  1 | xixi |   98 |     98 |        98 |
+----+------+------+--------+-----------+
查询JS成绩大于80分的同学

select id,name,JS from ExamResult where JS>80;

+----+------+------+
| id | name | JS   |
+----+------+------+
|  1 | xixi |   98 |
|  4 | yao  |   88 |
|  5 | chi  |   88 |
|  6 | wan  |   86 |
+----+------+------+
查询总分大于250分的所有同学

select name,JS+Django+OpenStack as 总成绩 from ExamResult where JS+Django+OpenStack>250 ;

+------+-----------+
| name | 总成绩    |
+------+-----------+
| xixi |       294 |
| yao  |       259 |
| chi  |       253 |
+------+-----------+
2)between 80 and 100：值在80到100之间
查询JS分数在80－100之间的同学

select name ,JS from ExamResult where JS between 80 and 100;

+------+------+
| name | JS   |
+------+------+
| xixi |   98 |
| yao  |   88 |
| chi  |   88 |
| wan  |   86 |
+------+------+
3)in(80,90,100)：值是80或90或100
查询Django分数为59,89,100的同学。

select name ,Django from ExamResult where Django in (59,89,100);

+------+--------+
| name | Django |
+------+--------+
| shi  |     59 |
| yao  |     89 |
| wan  |    100 |
+------+--------+
4)like 'xixi%'：pattern可以是%或者_，如果是%则表示任意多字符，此例如唐僧,唐国强，如果是_则表示一个字符唐_，只有唐僧符合。两个_则表示两个字符：__逻辑运算符：在多个条件直接可以使用逻辑运算符 and or not
查询所有名字xi开头的学生成绩。

select * from ExamResult where name like 'xi%';

+----+------+------+--------+-----------+
| id | name | JS   | Django | OpenStack |
+----+------+------+--------+-----------+
|  1 | xixi |   98 |     98 |        98 |
+----+------+------+--------+-----------+
5)查找缺考Django的学生的姓名

select name from ExamResult where Django is null;

<4>Order by指定排序的列，排序的列即可是表中的列名，也可以是select语句后指定的别名。
语法：select *|field1,field2... from tab_name order by field [Asc|Desc]   ---Asc升序、Desc 降序，其中asc为默认值ORDER BY子句应位于SELECT语句的结尾。
1)对JS成绩排序后输出(默认从小到大)。

select name,JS from ExamResult order by JS;

+------+------+
| name | JS   |
+------+------+
| wang |   35 |
| shi  |   59 |
| wan  |   86 |
| yao  |   88 |
| chi  |   88 |
| xixi |   98 |
+------+------+
2)对总分排序按从高到低的顺序输出
语法：select name,总成绩 from 表名 order by 总成绩 desc;

select name,(ifnull(JS,0)+ifnull(Django,0)+ifnull(OpenStack,0)) 总成绩 from ExamResult order by 总成绩 desc;

+------+-----------+
| name | 总成绩    |
+------+-----------+
| xixi |       294 |
| yao  |       259 |
| chi  |       253 |
| wan  |       241 |
| wang |       200 |
| shi  |       180 |
+------+-----------+
3)对姓w开头的学生成绩从高到底排序输出
语法：select name,总成绩 from 表名 where like 'w开头' order by 总成绩 desc;

select name ,(ifnull(JS,0)+ifnull(Django,0)+ifnull(OpenStack,0))总成绩 from ExamResult where name like 'w%' order by 总成绩 desc;

+------+-----------+
| name | 总成绩    |
+------+-----------+
| wan  |       241 |
| wang |       200 |
+------+-----------+
<5>group by分组查询：按分组条件分组后每一组只会显示第一条记录
+----+------+------+--------+-----------+
| id | name | JS   | Django | OpenStack |
+----+------+------+--------+-----------+
|  1 | xixi |   98 |     98 |        98 |
|  2 | wang |   35 |     98 |        67 |
|  3 | shi  |   59 |     59 |        62 |
|  4 | yao  |   88 |     89 |        82 |
|  5 | chi  |   88 |     98 |        67 |
|  6 | wan  |   86 |    100 |        55 |
|  7 | xixi |   88 |     68 |        99 |
|  8 | xixi |   55 |     64 |        78 |
+----+------+------+--------+-----------+
1)按照字段名字筛选
按照name分类

select * from ExamResult group by name;

+----+------+------+--------+-----------+
| id | name | JS   | Django | OpenStack |
+----+------+------+--------+-----------+
|  5 | chi  |   88 |     98 |        67 |
|  3 | shi  |   59 |     59 |        62 |
|  6 | wan  |   86 |    100 |        55 |
|  2 | wang |   35 |     98 |        67 |
|  1 | xixi |   98 |     98 |        98 |
|  4 | yao  |   88 |     89 |        82 |
+----+------+------+--------+-----------+
2)按照位置字段筛选by 1等于第一列
按照name分类

select * from ExamResult group by 1;

+----+------+------+--------+-----------+
| id | name | JS   | Django | OpenStack |
+----+------+------+--------+-----------+
|  1 | xixi |   98 |     98 |        98 |
|  2 | wang |   35 |     98 |        67 |
|  3 | shi  |   59 |     59 |        62 |
|  4 | yao  |   88 |     89 |        82 |
|  5 | chi  |   88 |     98 |        67 |
|  6 | wan  |   86 |    100 |        55 |
|  7 | xixi |   88 |     68 |        99 |
|  8 | xixi |   55 |     64 |        78 |
+----+------+------+--------+-----------+
3)对成绩表按name类名分组后显示JS类成绩的总和

select name, sum(JS) from ExamResult group by name;

+------+---------+
| name | sum(JS) |
+------+---------+
| chi  |      88 |
| shi  |      59 |
| wan  |      86 |
| wang |      35 |
| xixi |     241 |
| yao  |      88 |
+------+---------+
4)对成绩表按name类名分组后，显示每一类名字的Django的分数总和>150的类的名字和django总分

select name, SUM(Django) from ExamResult group by name HAVING SUM(Django)>150;

+------+-------------+
| name | SUM(Django) |
+------+-------------+
| xixi |         230 |
+------+-------------+
having和where两者都可以对查询结果进行进一步的过滤，差别有：
-where语句只能用在分组之前的筛选，having可以用在分组之后的筛选；
-使用where语句的地方都可以用having进行替换
-having中可以用聚合函数，where中就不行。
<5>聚合函数： 把要求的内容查出来再包上聚合函数即可。(一般和分组查询配合使用)
1)COUNT(列名)：count(*)统计所有行，count(字段)不统计null值
统计一个班级共有多少学生？先查出所有的学生，再用count包上

select count(*) from ExamResult;

+----------+
| count(*) |
+----------+
|        8 |
+----------+
统计JS成绩大于70的学生有多少个

select count(JS) from ExamResult where JS>70;

+-----------+
| count(JS) |
+-----------+
|         5 |
+-----------+
统计一个班级共有多少学生？先查出所有的学生，再用count包上

select count(name) from ExamResult where (ifnull(JS,0)+ifnull(Django,0)+ifnull(OpenStack,0))>280;

+-------------+
| count(name) |
+-------------+
|           1 |
+-------------+
2)AVG(列名)：
求一个班级JS平均分？先查出所有的JS分，然后用avg包上。

select avg(ifnull(JS,0)) from ExamResult;

+-------------------+
| avg(ifnull(JS,0)) |
+-------------------+
|            74.625 |
+-------------------+
求一个班级总分平均分:null和所有的数计算都是null，所以需要用ifnull将null转换为0

select avg((ifnull(JS,0)+ifnull(Django,0)+ifnull(OpenStack,0))) from ExamResult;

+----------------------------------------------------------+
| avg((ifnull(JS,0)+ifnull(Django,0)+ifnull(OpenStack,0))) |
+----------------------------------------------------------+
|                                                  234.875 |
+----------------------------------------------------------+
3) Max、Min
求班级所有成绩总和的最高分(数值范围在统计中特别有用)

select Max((ifnull(JS,0)+ifnull(Django,0)+ifnull(OpenStack,0))) 最高分 from ExamResult;

+-----------+
| 最高分    |
+-----------+
|       294 |
+-----------+
求班级所有成绩总和的最低分

select Min((ifnull(JS,0)+ifnull(Django,0)+ifnull(OpenStack,0))) 最低分 from ExamResult;

+-----------+
| 最低分    |
+-----------+
|       180 |
+-----------+
<6>limit
显示第一条

SELECT * from ExamResult limit 1;

+----+------+------+--------+-----------+
| id | name | JS   | Django | OpenStack |
+----+------+------+--------+-----------+
|  1 | xixi |   98 |     98 |        98 |
+----+------+------+--------+-----------+
显示二到四条

SELECT * from ExamResult limit 2,4;

+----+------+------+--------+-----------+
| id | name | JS   | Django | OpenStack |
+----+------+------+--------+-----------+
|  3 | shi  |   59 |     59 |        62 |
|  4 | yao  |   88 |     89 |        82 |
|  5 | chi  |   88 |     98 |        67 |
|  6 | wan  |   86 |    100 |        55 |
+----+------+------+--------+-----------+
<7>使用正则表达式查询
ExamResult表里name字段xi开头的所有名字

SELECT * FROM ExamResult WHERE name REGEXP '^xi';

+----+------+------+--------+-----------+
| id | name | JS   | Django | OpenStack |
+----+------+------+--------+-----------+
|  1 | xixi |   98 |     98 |        98 |
|  7 | xixi |   88 |     68 |        99 |
|  8 | xixi |   55 |     64 |        78 |
+----+------+------+--------+-----------+
ExamResult表里name字段g结尾的所有名字

SELECT * FROM ExamResult WHERE name REGEXP 'g$';

+----+------+------+--------+-----------+
| id | name | JS   | Django | OpenStack |
+----+------+------+--------+-----------+
|  2 | wang |   35 |     98 |        67 |
+----+------+------+--------+-----------+
7.外键约束
(1)每一个老师会对应多个学生,而每个学生只能对应一个老师
主表：被绑定的表

CREATE TABLE Teacher(
       id TINYINT PRIMARY KEY auto_increment,
       name VARCHAR (20),
       age INT ,
       is_marriged boolean
);

插入内容：

INSERT INTO Teacher (name,age,is_marriged) VALUES ("xixi",18,0),
                                                       ("dongdong",16,0),
                                                       ("beibei",32,0),
                                                       ("nannan",21,0),
                                                       ("baibai",25,0);

显示内容：
+----+----------+------+-------------+
| id | name     | age  | is_marriged |
+----+----------+------+-------------+
|  1 | xixi     |   18 |           0 |
|  2 | dongdong |   16 |           0 |
|  3 | beibei   |   32 |           0 |
|  4 | nannan   |   21 |           0 |
|  5 | baibai   |   25 |           0 |
+----+----------+------+-------------+
子表创建外键：
语法：FOREIGN KEY (teacher_id) REFERENCES 主表(id)
注意：teacher_id作为外键一定要和关联主键的id数据类型保持一致

CREATE TABLE Student(
       id INT PRIMARY KEY auto_increment,
       name VARCHAR (20),
       teacher_id TINYINT,
       FOREIGN KEY (teacher_id) REFERENCES Teacher(id)
)ENGINE=INNODB; 

插入内容：

INSERT INTO Student(name,teacher_id) VALUES ("alvin1",2),
                                            ("alvin2",4),
                                            ("alvin3",1),
                                            ("alvin4",3),
                                            ("alvin5",1),
                                            ("alvin6",3),
                                            ("alvin7",2);

显示内容：
+----+--------+------------+
| id | name   | teacher_id |
+----+--------+------------+
|  1 | alvin1 |          2 |
|  2 | alvin2 |          4 |
|  3 | alvin3 |          1 |
|  4 | alvin4 |          3 |
|  5 | alvin5 |          1 |
|  6 | alvin6 |          3 |
|  7 | alvin7 |          2 |
+----+--------+------------+
主表从表关联后：执行删除name=dongdong
语句：DELETE FROM Teacher WHERE name="dongdong";
会报关联后不可以删除
ERROR 1451 (23000): Cannot delete or update a parent row: a foreign key constraint fails (`xixi`.`Student`, CONSTRAINT `Student_ibfk_1` FOREIGN KEY (`teacher_id`) REFERENCES `Teacher` (`id`))
外键约束对子表的含义:如果在父表中找不到候选键,则不允许在子表上进行insert/update
外键约束对父表的含义:在父表上进行update/delete以更新或删除在子表中有一条或多条对应匹配行的候选键时,父表的行为取决于：在定义子表的外键时指定的on update/on delete子句
(2)增加外键和删除外键
<1>增加外键

ALTER TABLE 从表名  ADD CONSTRAINT 外键名字 FOREIGN KEY(teacher_id) REFERENCES  主表名(id);

<2>删除外键

ALTER TABLE 从表名 DROP FOREIGN KEY 外键名字;

8.INNODB支持的ON语句(四种方式)
<1>级联删除:
主表：
+----+--------+------+-------------+
| id | name   | age  | is_marriged |
+----+--------+------+-------------+
|  1 | xixi   |   18 |           0 |
|  2 | beibei |   18 |           0 |
|  4 | nannan |   21 |           0 |
|  5 | baibai |   25 |           0 |
+----+--------+------+-------------+
cascade方式在父表上update/delete记录时，同步update/delete掉子表的匹配记录
外键的级联删除：如果父表中的记录被删除，则子表中对应的记录自动被删除

FOREIGN KEY (charger_id) REFERENCES 主表(id) ON DELETE CASCADE

级联子表创建外键：

CREATE TABLE Student2(
       id INT PRIMARY KEY auto_increment,
       name VARCHAR (20),
       teacher_id TINYINT,
       FOREIGN KEY (teacher_id) REFERENCES Teacher(id) ON DELETE CASCADE
)ENGINE=INNODB; 

子表插入内容：

INSERT INTO Student2(name,teacher_id) VALUES ("alvin1",1),
                                            ("alvin2",4),
                                            ("alvin3",1),
                                            ("alvin4",2),
                                            ("alvin5",1),
                                            ("alvin6",2),
                                            ("alvin7",4);

当前子表数据：
+----+--------+------------+
| id | name   | teacher_id |
+----+--------+------------+
| 15 | alvin1 |          1 |
| 16 | alvin2 |          4 |
| 17 | alvin3 |          1 |
| 18 | alvin4 |          2 |
| 19 | alvin5 |          1 |
| 20 | alvin6 |          2 |
| 21 | alvin7 |          4 |
+----+--------+------------+                                    
删除主表里的name="beibei"

delete from Teacher where name="beibei";

删除后子表数据内容：
+----+--------+------------+
| id | name   | teacher_id |
+----+--------+------------+
| 15 | alvin1 |          1 |
| 16 | alvin2 |          4 |
| 17 | alvin3 |          1 |
| 19 | alvin5 |          1 |
| 21 | alvin7 |          4 |
+----+--------+------------+
<2>set null方式
在父表上update/delete记录时，将子表上匹配记录的列设为null,要注意子表的外键列不能为not null
语法：FOREIGN KEY (charger_id) REFERENCES 主表(id) ON DELETE SET NULL
级联子表创建外键：

CREATE TABLE Student3(
       id INT PRIMARY KEY auto_increment,
       name VARCHAR (20),
       teacher_id TINYINT,
       FOREIGN KEY (teacher_id) REFERENCES Teacher(id) ON DELETE SET NULL
)ENGINE=INNODB;

子表插入内容：

INSERT INTO Student3(name,teacher_id) VALUES ("alvin1",1),
                                            ("alvin2",4),
                                            ("alvin3",1),
                                            ("alvin4",2),
                                            ("alvin5",1),
                                            ("alvin6",2),
                                            ("alvin7",4);

当前子表内容
+----+--------+------------+
| id | name   | teacher_id |
+----+--------+------------+
|  1 | alvin1 |          1 |
|  2 | alvin2 |          4 |
|  3 | alvin3 |          1 |
|  4 | alvin4 |          2 |
|  5 | alvin5 |          1 |
|  6 | alvin6 |          2 |
|  7 | alvin7 |          4 |
+----+--------+------------+
删除主表里的name="beibei"

delete from Teacher where name="beibei";

删除后子表数据内容：
+----+--------+------------+
| id | name   | teacher_id |
+----+--------+------------+
|  1 | alvin1 |          1 |
|  2 | alvin2 |          4 |
|  3 | alvin3 |          1 |
|  4 | alvin4 |       NULL |
|  5 | alvin5 |          1 |
|  6 | alvin6 |       NULL |
|  7 | alvin7 |          4 |
+----+--------+------------+
<3>Restrict方式
拒绝对父表进行删除更新操作(了解)
<4>No action方式
在mysql中同Restrict,如果子表中有匹配的记录,则不允许对父表对应候选键,进行update/delete操作（了解）
9.多表查询
准备两张表
创建A表：

create table A(
       id int primary key,
       name varchar(100)
      );

给B表插入数据

insert into A values
      (1,'dongdong'),
      (2,'nannan'),
      (3,'xixi'),
      (4,'beibei');

显示A表数据：
+----+----------+
| id | name     |
+----+----------+
|  1 | dongdong |
|  2 | nannan   |
|  3 | xixi     |
|  4 | beibei   |
+----+----------+
~~~~~~~~~~~~~~~~~~~~~~~~~~~
创建B表：

create table B(
      id int primary key,
      name varchar(50),
      tableA_id int
      );

给B表插入数据

insert into B(id,name,tableA_id) values
        (1,'A',1),
        (2,'B',1),
        (3,'C',2),
        (4,'D',2),
        (5,'E',4);

显示B表数据：
+----+------+-----------+
| id | name | tableA_id |
+----+------+-----------+
|  1 | A    |         1 |
|  2 | B    |         1 |
|  3 | C    |         2 |
|  4 | D    |         2 |
|  5 | E    |         4 |
+----+------+-----------+
(1)多表查询之连接查询
<1>笛卡尔积查询：俩张表中一条一条对应记录，m条记录和n条记录查询，最后得到m*n条记录，其中很多错误数据。
语法：SELECT * FROM 表1,表2;

SELECT * FROM A,B;

+----+----------+----+------+-----------+
| id | name     | id | name | tableA_id |
+----+----------+----+------+-----------+
|  1 | dongdong |  1 | A    |         1 |
|  2 | nannan   |  1 | A    |         1 |
|  3 | xixi     |  1 | A    |         1 |
|  4 | beibei   |  1 | A    |         1 |
|  1 | dongdong |  2 | B    |         1 |
|  2 | nannan   |  2 | B    |         1 |
|  3 | xixi     |  2 | B    |         1 |
|  4 | beibei   |  2 | B    |         1 |
|  1 | dongdong |  3 | C    |         2 |
|  2 | nannan   |  3 | C    |         2 |
|  3 | xixi     |  3 | C    |         2 |
|  4 | beibei   |  3 | C    |         2 |
|  1 | dongdong |  4 | D    |         2 |
|  2 | nannan   |  4 | D    |         2 |
|  3 | xixi     |  4 | D    |         2 |
|  4 | beibei   |  4 | D    |         2 |
|  1 | dongdong |  5 | E    |         4 |
|  2 | nannan   |  5 | E    |         4 |
|  3 | xixi     |  5 | E    |         4 |
|  4 | beibei   |  5 | E    |         4 |
+----+----------+----+------+-----------+
<2>内连接查询:
方式一：
语法：select * from 表1 inner join 表2 on 表1.id = 表2.tableA_id;

select * from A inner join B on A.id = B.tableA_id;

+----+----------+----+------+-----------+
| id | name     | id | name | tableA_id |
+----+----------+----+------+-----------+
|  1 | dongdong |  1 | A    |         1 |
|  1 | dongdong |  2 | B    |         1 |
|  2 | nannan   |  3 | C    |         2 |
|  2 | nannan   |  4 | D    |         2 |
|  4 | beibei   |  5 | E    |         4 |
+----+----------+----+------+-----------+
方式二：两张表中都有的关联数据,相当于利用条件从笛卡尔积结果中筛选出了正确的结果。
语法：select * from 表1,表2 where 表1.id = 表2.tableA_id;

select * from A,B where A.id = B.tableA_id;

+----+----------+----+------+-----------+
| id | name     | id | name | tableA_id |
+----+----------+----+------+-----------+
|  1 | dongdong |  1 | A    |         1 |
|  1 | dongdong |  2 | B    |         1 |
|  2 | nannan   |  3 | C    |         2 |
|  2 | nannan   |  4 | D    |         2 |
|  4 | beibei   |  5 | E    |         4 |
+----+----------+----+------+-----------+
查询A表的id和name以及他对应B表的name
语法：select 表1.id,表1.name,表2.name from 表1,表2 where 表1.id = 表2.tableA_id;

select A.id,A.name,B.name from A,B where A.id = B.tableA_id;

+----+----------+------+
| id | name     | name |
+----+----------+------+
|  1 | dongdong | A    |
|  1 | dongdong | B    |
|  2 | nannan   | C    |
|  2 | nannan   | D    |
|  4 | beibei   | E    |
+----+----------+------+
查询A表name=dongdong以及他对应B表的name
语法：select 表1.name,表2.name from 表1,表2 where 表1.id = 表2.tableA_id AND A表.name="条件";

SELECT A.name,B.name FROM A,B WHERE A.id = B.tableA_id AND A.name= "dongdong";

+----------+------+
| name     | name |
+----------+------+
| dongdong | A    |
| dongdong | B    |
+----------+------+
<3>外连接:
1)左外连接：在内连接的基础上增加左边有右边没有的结果

select * from A left join B on A.id = B.tableA_id;

+----+----------+------+------+-----------+
| id | name     | id   | name | tableA_id |
+----+----------+------+------+-----------+
|  1 | dongdong |    1 | A    |         1 |
|  1 | dongdong |    2 | B    |         1 |
|  2 | nannan   |    3 | C    |         2 |
|  2 | nannan   |    4 | D    |         2 |
|  4 | beibei   |    5 | E    |         4 |
|  3 | xixi     | NULL | NULL |      NULL |
+----+----------+------+------+-----------+
2)右外连接：在内连接的基础上增加右边有左边没有的结果

select * from A RIGHT JOIN B on A.id = B.tableA_id;

+------+----------+----+------+-----------+
| id   | name     | id | name | tableA_id |
+------+----------+----+------+-----------+
|    1 | dongdong |  1 | A    |         1 |
|    1 | dongdong |  2 | B    |         1 |
|    2 | nannan   |  3 | C    |         2 |
|    2 | nannan   |  4 | D    |         2 |
|    4 | beibei   |  5 | E    |         4 |
+------+----------+----+------+-----------+
3)全外连接：在内连接的基础上增加左边有右边没有的和右边有左边没有的结果
mysql不支持全外连接 full JOIN
mysql可以使用UNION此种方式间接实现全外连接

select * from A RIGHT JOIN B on A.id = B.tableA_id UNION select * from A LEFT JOIN B on A.id = B.tableA_id;

+------+----------+------+------+-----------+
| id   | name     | id   | name | tableA_id |
+------+----------+------+------+-----------+
|    1 | dongdong |    1 | A    |         1 |
|    1 | dongdong |    2 | B    |         1 |
|    2 | nannan   |    3 | C    |         2 |
|    2 | nannan   |    4 | D    |         2 |
|    4 | beibei   |    5 | E    |         4 |
|    3 | xixi     | NULL | NULL |      NULL |
+------+----------+------+------+-----------+
注意：union与union all的区别：union会去掉相同的纪录
9.多表查询之复合条件连接查询
当前A表：
+----+----------+
| id | name     |
+----+----------+
|  1 | dongdong |
|  2 | nannan   |
|  3 | xixi     |
|  4 | beibei   |
+----+----------+
当前B表:
+----+------+-----------+------+
| id | name | tableA_id | age  |
+----+------+-----------+------+
|  1 | A    |         1 |   15 |
|  2 | B    |         1 |   26 |
|  3 | C    |         2 |   27 |
|  4 | D    |         2 |   23 |
|  5 | E    |         4 |   33 |
+----+------+-----------+------+
查询B表年龄大于等于25岁的对应A表名字

SELECT A.name FROM A,B where A.id = B.tableA_id AND B.age > 25;

+----------+
| name     |
+----------+
| dongdong |
| nannan   |
| beibei   |
+----------+
10.多表查询之子查询
子查询是将一个查询语句嵌套在另一个查询语句中。
内层查询语句的查询结果，可以为外层查询语句提供查询条件。
子查询中可以包含：IN、NOT IN、ANY、ALL、EXISTS 和 NOT EXISTS等关键字
当前A表：
+----+----------+
| id | name     |
+----+----------+
|  1 | dongdong |
|  2 | nannan   |
|  3 | xixi     |
|  4 | beibei   |
+----+----------+
当前B表:
+----+------+-----------+------+
| id | name | tableA_id | age  |
+----+------+-----------+------+
|  1 | A    |         1 |   15 |
|  2 | B    |         1 |   26 |
|  3 | C    |         2 |   27 |
|  4 | D    |         2 |   23 |
|  5 | E    |         4 |   33 |
+----+------+-----------+------+
<1>带IN关键字的子查询
查询A表的名字name,但必须包含在B表对应的tableA_id

select * from A where id IN (select tableA_id from B);

+----+----------+
| id | name     |
+----+----------+
|  1 | dongdong |
|  2 | nannan   |
|  4 | beibei   |
+----+----------+
<2>带比较运算符的子查询,包含比较运算符：= 、 !=、> 、<的子查询
查询A表的名字name,但必须包含在B表对应的tableA_id且age年龄大于等于27

select * from A where id IN (select tableA_id from B where age>=27);

<3>带EXISTS关键字的子查询
EXISTS关字键字表示存在。在使用EXISTS关键字时，内层查询语句不返回查询的记录。
而是返回一个真假值。Ture或False
当返回Ture时，外层查询语句将进行查询；当返回值为False时，外层查询语句不进行查询
三.mysql索引
1.索引简介
(1)索引在mysql中也叫做"键",是存储引擎用于快速找到记录的一种数据结构。索引对于良好的性能非常关键，尤其是当表中的数据量越来越大时，索引对于性能影响愈发重要。
(2)索引特点：创建与维护索引会消耗很多时间与磁盘空间，但查询速度大大提高。
2.索引语法
create table 表名(
       字段1 数据类型 [完整性约束条件...],
       字段2 数据类型 [完整性约束条件...],
       [UNIQUE(唯一索引) | FULITEXT(全局索引) | SPATIAL(空间索引)] INDEX(创建普通索引) | KEY(创建普通索引) [索引名] (字段名[长度]) (ASC | DESC)
      );
3.创建索引：
(1)创建普通索引
通过INDEX给name创建普通索引，索引名index_name

create table emp(
       id INT,
       name varchar(20),
       INDEX index_name (name)
      );

索引结果：KEY `index_name` (`name`)
(2)创建唯一索引(字段不能重复)
通过UNIQUE(唯一索引) INDEX给name创建普通索引，索引名index_name

    create table emp1(
       id INT,
       name varchar(20),
       UNIQUE INDEX index_name (name)
      );  

索引结果：UNIQUE KEY `index_name` (`name`)
(3)创建全文索引：
(4)创建多列索引：
4.添加索引：
语法：CREATE [UNIQUE(唯一索引) | FULITEXT(全局索引) | SPATIAL(空间索引)] INDEX(创建普通索引) [索引名] ON 表名 (字段名[长度]) (ASC | DESC);
5.删除索引
语法：DROP INDEX 索引名 on 表名
四.mysql事务
1.事务：指逻辑上的一组操作，组成这组操作的各个单元，要不全部成功，要不全部不成功。
+------+--------+---------+
| id   | name   | balance |
+------+--------+---------+
|    1 | xixi   |   10000 |
|    2 | beibei |   10000 |
+------+--------+---------+
2.数据库开启事务命令     
(1)开启事务

start transaction;

给xixi减去5000修改语句：

UPDATE account set balance=balance-5000 WHERE name="xixi";

当前查看：开启事务后，在没有提交事务之前所操作的都不成功
+------+--------+---------+
| id   | name   | balance |
+------+--------+---------+
|    1 | xixi   |   10000 |
|    2 | beibei |   10000 |
+------+--------+---------+
(2)回滚事务(即撤销指定的sql语句[只能回退insert delete update语句]，回滚到上一次commit的位置)

Rollback;

执行回滚事务后查询：
+------+--------+---------+
| id   | name   | balance |
+------+--------+---------+
|    1 | xixi   |   10000 |
|    2 | beibei |   10000 |
+------+--------+---------+
(3)提交事务，提交未存储的事务
语法：Commit;
给xixi减去5000修改语句：

UPDATE account set balance=balance-5000 WHERE name="xixi";

给beibei加5000修改语句：

UPDATE account set balance=balance+5000 WHERE name="beibei";

提交事务语句：

Commit;

查看：
+------+--------+---------+
| id   | name   | balance |
+------+--------+---------+
|    1 | xixi   |    5000 |
|    2 | beibei |   15000 |
+------+--------+---------+
(4)保留点，事务处理中设置的临时占位符 你可以对它发布回退(与整个事务回退不同)
语法:savepoint 名字;
当前test表：
+----+----------+
| id | name     |
+----+----------+
|  1 | dongdong |
|  2 | xixi     |
|  3 | nannan   |
+----+----------+
开启事务：

start transaction;

插入一条数据：

insert into test (name)values('beibei');

查看当前test表：
+----+----------+
| id | name     |
+----+----------+
|  1 | dongdong |
|  2 | xixi     |
|  3 | nannan   |
|  4 | beibei   |
+----+----------+
设置保留点：

savepoint insert1;

再插入一条数据：

insert into test (name)values('yeye');

再设置保留点：

savepoint insert2;

当前表结构：
+----+----------+
| id | name     |
+----+----------+
|  1 | dongdong |
|  2 | xixi     |
|  3 | nannan   |
|  4 | beibei   |
|  5 | yeye     |
+----+----------+
删除三条语句：

delete from test where id=1;

delete from test where id=3;

delete from test where id=4;

当前表结构：
+----+------+
| id | name |
+----+------+
|  2 | xixi |
|  5 | yeye |
+----+------+
返回insert1节点语句：

rollback to insert1;

查看当前表结构：
+----+----------+
| id | name     |
+----+----------+
|  1 | dongdong |
|  2 | xixi     |
|  3 | nannan   |
|  4 | beibei   |
+----+----------+