MySql

目录

导入数据命令

DQL（数据查询语言）

简单的查询语句

条件查询

排序

分组函数

查询结果去重

连接查询

子查询

union 

limit

DDL（数据定义语言）

创建表

复制表

删除表

DML（数据操作语言）

insert

update

delete

约束

TCL（事务控制语言）

索引

视图

存储引擎

三范式

---

1、sql、DB、DBMS分别是什么，他们之间的关系？
    DB:：DataBase（数据库，数据库实际上在硬盘上以文件的形式存在）

    DBMS：DataBase Management System（数据库管理系统，常见的有：MySQL Oracle DB2 Sybase SqlServer...）

    SQL：结构化查询语言，是一门标准通用的语言。标准的sql适合于所有的数据库产品。
        SQL属于高级语言。只要能看懂英语单词的，写出来的sql语句，可以读懂什么意思。
        SQL语句在执行的时候，实际上内部也会先进行编译，然后再执行sql。（sql语句的编译由DBMS完成。）
    DBMS负责执行sql语句，通过执行sql语句来操作DB当中的数据。
    DBMS -(执行)-> SQL -(操作)-> DB

2、什么是表？

    表：table是数据库的基本组成单元，所有的数据都以表格的形式组织，目的是可读性强。

    一个表包括行和列：
        行：被称为数据/记录(data)
        列：被称为字段(column)

              每一个字段应该包括哪些属性？
                字段名、数据类型、相关的约束。

3、xxx.sql，这个文件以sql结尾，这样的文件被称为“sql脚本”。什么是sql脚本呢？
    当一个文件的扩展名是.sql，并且该文件中编写了大量的sql语句，我们称这样的文件为sql脚本。
    注意：直接使用source命令可以执行sql脚本。
    sql脚本中的数据量太大的时候，无法打开，请使用source命令完成初始化。

4、SQL语句怎么分类呢？
    DQL（数据查询语言）：查询语句，凡是select语句都是DQL。
    DML（数据操作语言）：insert delete update，对表当中的数据进行增删改。
    DDL（数据定义语言）：create drop alter，对表结构的增删改。
    TCL（事务控制语言）：commit提交事务，rollback回滚事务。(TCL中的T是Transaction)
    DCL（数据控制语言）：grant授权、revoke撤销权限等。

查看mysql的版本号。

select version();

【提示】：
        1、任何一条sql语句以“;”结尾。
        2、sql语句不区分大小写。

\c   命令，结束一条语句。

exit 命令，退出mysql。

导入数据命令

mysql -u“用户名” -p“密码”   登录mysql服务客户端，在Dos窗口操作

mysql -uroot -p333

查看有哪些数据库

show databases;

创建属于我们自己的数据库，下面的ms是数据库的名字

create database ms;

使用名字是ms的数据库

use ms;

查看当前使用的数据库中有哪些表

show tables;

初始化数据，在当前使用的数据库中导入sql脚本

source D:\mysql\resources\ms.sql

删除数据库

drop database ms;

查看表结构,user是这个数据库中的表的名字

desc user;

查看当前使用的是哪个数据库

select database();

查看创建表的语句,对user表操作

show create table user;

DQL（数据查询语言）

简单的查询语句

查看表中数据，语法：select 字段名1,字段名2,字段名3,.... from 表名;

select id,name,age from user;

select * from user;

其中 * 是一个通配符，表示所有的字段。实际开发中不建议使用*，效率较低。

【注意】：字段可以参与数学运算。

select id,name,age * 10 from user;

 给查询结果的列重命名

select id,name,age * 10 as newage from user;

【注意】：别名中有中文，需要加上单引号，标准sql语句中要求字符串使用单引号括起来。虽然mysql支持双引号，尽量别用。

select id,name,age * 10 as '新年龄' from user;

as关键字可以省略

select id,name,age * 10 newage from user;

条件查询

语法：select 字段,字段... from 表名 where 条件;

执行顺序：先from，然后where，最后select

select * from user where id=1001;

select * from user where name='lisi';

 还可以使用 > , >= , < , <= , <> , !=  

and  表示并列的意思。

select * from user where id=1001 and id=1002;

between and在使用的时候必须左小右大。

select * from user where age>10 and age<20;

select * from user where age between 10 and 20;

像下面这种形式是查询不到任何数据

select * from user where age between 20 and 10;

between and除了可以使用在数字方面之外，还可以使用在字符串方面。左闭右开。

select * from user where name between 'a' and 'z';

判断数据库是不是NULL，在数据库当中NULL不是一个值，代表什么也没有，为空。空不是一个值，不能用等号衡量。必须使用 is null或者is not null

select id,name from user where name is null;

or  表示或者的意思

select id,name from user where id=1001 or id=1003;

and和or可以联合起来用，但是注意：当运算符的优先级不确定的时候加小括号。

in等同于or，注意：in后面的值不是区间，是具体的值。

select id,name from user where id in(1001,1003);

like模糊查询，%代表任意多个字符，_代表任意1个字符。

select id,name from user where name like '%n%';

查询字段中带有 _ 的数据，需要使用反斜杠 /

select id,name from user where name like '%\_%';

排序

语法：select 字段,字段... from 表名 order by 字段;

执行顺序：先from，然后select，最后order by

注意：默认是升序。asc表示升序，desc表示降序。

select id,name,age from user order by age;

select id,name,age from user order by age desc;

越靠前的字段越能起到主导作用。只有当前面的字段无法完成排序的时候，才会启用后面的字段。

select id,name,age from user order by age desc, id asc;

联合where使用

语法：select 字段,字段... from 表名 where 条件 order by 字段;

执行顺序：先from，然后where，然后select，最后order by

select id,name,age from user where age=20 order by id desc;

分组函数

分组函数还有另一个名字：多行处理函数。

count 计数，sum 求和， avg 平均值， max 最大值 ，min 最小值

分组函数一共5个。    
分组函数的特点：输入多行，最终输出的结果是1行。

【记住】：所有的分组函数都是对“某一组”数据进行操作的。

找出user表中年龄最低的

select min(age) from user;

【注意】：分组函数自动忽略NULL。不需要额外添加这个过滤条件。

select * from user;

select count(name) from user;

count(*)和count(具体的某个字段)，他们有什么区别？
        count(*)：不是统计某个字段中数据的个数，而是统计总记录条数。（和某个字段无关）
        count(comm)：表示统计comm字段中不为NULL的数据总数量。

单行处理函数：输入一行，输出一行。

ifnull() 空处理函数，属于单行处理函数。
语法：ifnull(可能为NULL的数据,被当做什么处理)

select id,ifnull(name,0) from user;

 【注意】：SQL语句当中有一个语法规则，分组函数不可直接使用在where子句当中。

select id,name from user where age > avg(age);

上面代码对有错误：ERROR 1111 (HY000): Invalid use of group function

因为group by是在where执行之后才会执行的。

【重点记住】语法：select 字段,字段... from 表名 where 条件 group by 字段 having 条件 order by 字段;

执行顺序：先from，然后where，然后group by，然后having，然后select， 最后order by

group by ： 按照某个字段或者某些字段进行分组。
having : having是对分组之后的数据进行再次过滤。

【注意】：分组函数一般都会和group by联合使用，这也是为什么它被称为分组函数的原因。并且任何一个分组函数（count sum avg max min）都是在group by语句执行结束之后才会执行的。当一条sql语句没有group by的话，整张表的数据会自成一组。

记住规则：当一条语句中有group by的话，select后面只能跟分组函数和参与分组的字段。

找出每个班级中最小年龄小于18的学生，class字段是班级

select id,name,class from user group by class having min(age) < 18;

上面这种方式效率较低，可以使用下面的方式，提高效率。

select id,name,class from user where age < 18 group by class;

查询结果去重

distinct关键字去除重复记录，【记住】：distinct只能出现在所有字段的最前面。

select distinct age from user;

连接查询

1、什么是连接查询？
    在实际开发中，大部分的情况下都不是从单表中查询数据，一般都是多张表联合查询取出最终的结果。在实际开发中，一般一个业务都会对应多张表。

2、在表的连接查询方面有一种现象被称为：笛卡尔积现象。（笛卡尔乘积现象）

笛卡尔积现象：当两张表进行连接查询的时候，没有任何条件进行限制，最终的查询结果条数是两张表记录条数的乘积。

用户user表信息如下                                   

        

 地址address表信息如下

 

select name,city from user,address;

 上面的情况就属于，笛卡尔积现象。

关于表的别名：

select u.name,a.city from user u,address a;

    表的别名有什么好处？
        第一：执行效率高。第二：可读性好。

4、加条件进行过滤，可以避免笛卡尔积现象。

显示用户的位置。（这种方式SQL92：不经常用）

select u.name,a.city from user u,address a where u.aid=a.id;

【注意】：避免了笛卡尔积现象，不会减少记录的匹配次数，只不过显示的是有效记录。

3、连接查询的分类？
    根据语法出现的年代来划分的话，包括：
        SQL92，SQL99（比较新的语法）

        SQL99语法结构更清晰一些：表的连接条件和后来的where条件分离了。

    根据表的连接方式来划分，包括：
        内连接：

            假设A和B表进行连接，使用内连接的话，凡是A表和B表能够匹配上的记录查询出来，这就是内连接。AB两张表没有主副之分，两张表是平等的。
            等值连接：最大特点是：条件是等量关系。

                语法：... A join B on 连接条件 where ...

select u.name,a.city from user u join address a on u.aid=a.id;

            非等值连接：最大的特点是：连接条件中的关系是非等量关系。

select u.name,a.city from user u inner join address a on u.aid>a.id;

上面这段代码没什么意义，只是便于理解非等值连接。

            自连接：最大的特点是：一张表看做两张表。自己连接自己。

select a.id as '编号',b.age as '年龄' from user a join user b on a.id=b.age;

上面这段代码没什么意义，只是便于理解自连接。

【注意】：内连接时，join前面可以加上inner的，带着inner目的是可读性好一些。

        外连接：

                假设A和B表进行连接，使用外连接的话，AB两张表中有一张表是主表，一张表是副表，主要查询主表中的数据，顺带查询副表，当副表中的数据没有和主表中的数据匹配上，副表自动模拟出NULL与之匹配。外连接最重要的特点是：主表的数据无条件的全部查询出来。

            左外连接（左连接）：表示左边的这张表是主表。

select a.id as '编号',b.age as '年龄' from user a left join user b on a.id=b.age;

上面这段代码没什么意义，只是便于理解左连接。

            右外连接（右连接）：表示右边的这张表是主表。

select a.id as '编号',b.age as '年龄' from user b right join user a on a.id=b.age;

上面这段代码没什么意义，只是便于理解右连接。

                【注意】：左连接有右连接的写法，右连接也会有对应的左连接的写法。

多个表连接：.... A join B join C on ...

        表示：A表和B表先进行表连接，连接之后A表继续和C表进行连接。
    
        全连接（使用很少）

子查询

select语句当中嵌套select语句，被嵌套的select语句是子查询。

子查询可以出现在：select..(select).. from ..(select).. where ..(select)..

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

select u.* from (select * from user where age > 18) u;

select u.name,(select a.city from address a where u.aid=a.id) as city from user u;

union 

可以将查询结果集相加

select name,age from user where age=21 union select name,age from user where age=25;

 两张不相干的表中的数据拼接在一起显示，但是这种只能显示每个表的一个字段。

select name from user union select city from address;

 多余一个字段就会出错

select name,age from user union select city from address;

limit

limit是mysql特有的，其他数据库中没有，不通用。（Oracle中有一个相同的机制，叫做rownum）

语法机制：
    limit startIndex, length
        startIndex表示起始位置，从0开始，0表示第一条数据。length表示取几个

语法：select ... from ... where ... group by ... having ... order by ... limit ...;

执行顺序：①from ②where ③group by ④having ⑤select ⑥order by ⑦limit

显示年龄最大的3个人

select name,age from user order by age desc limit 0,3;

每页显示pageSize条记录：
        第pageNo页：(pageNo - 1) * pageSize, pageSize

pageSize是每页显示多少条记录，pageNo是显示第几页

DDL（数据定义语言）

创建表

语法格式：

create table 表名(
        字段名1 数据类型,
        字段名2 数据类型,
                ....
);

表名在数据库当中一般建议以：t_或者tbl_开始。

关于MySQL当中字段的常见数据类型
        int        整数型(java中的int)
        bigint    长整型(java中的long)
        float        浮点型(java中的float double)
        char        定长字符串(String)
        varchar    可变长字符串(StringBuffer/StringBuilder)
        date        日期类型 （对应Java中的java.sql.Date类型）
        BLOB      二进制大对象（存储图片、视频等流媒体信息） Binary Large OBject （对应java中的Object）
        CLOB        字符大对象（存储较大文本，比如，可以存储4G的字符串。） Character Large OBject（对应java中的Object）
        ......
    
    char和varchar怎么选择？
        在实际的开发中，当某个字段中的数据长度不发生改变的时候，是定长的，例如：性别、生日等都是采用char。当一个字段的数据长度不确定，例如：简介、姓名等都是采用varchar。

创建学生表：

create table t_student(
    no bigint,
    name varchar(255),
    sex char(1),
    classno varchar(255)
);

创建表的时候，可以在字段后面添加default，表示默认值。

sex char(1) default 1,

复制表

语法：create table 表名 as select语句;   将查询结果当做表创建出来。

create table t1 as select * from user;

删除表

语法：

drop table 表名;

表名前面可以添加条件，判断这个表是否存在，if exists（oracle不支持这种写法）

drop table if exists user; 

解读：如果这个user表存在，就删除。

对于表结构的修改，可以使用工具来操作。

DML（数据操作语言）

insert

插入数据

语法格式：insert into 表名(字段名1,字段名2,字段名3,....) values(值1,值2,值3,....)
【要求】：字段的数量和值的数量相同，并且数据类型要对应相同。

insert into t_student(no,name,sex,classno) values(1,'zhangsan','1',1);

insert into t_student(no) values(2);

上面代码，除no字段之外，剩下的所有字段自动插入NULL。

字段可以省略不写，但是后面的value对数量和顺序都有要求。

insert into t_student values(3,'lisi','1',2);

还可以一次插入多行数据

语法格式：insert into 表名(字段名1,字段名2,字段名3,....) values(值1,值2,值3,....),(值1,值2,值3,....);

insert into t_student(no,name,sex,classno) values(3,'xiaohong','2',2),(4,'wangwu','1',2);

【注意】：当一条insert语句执行成功之后，表格当中必然会多一行记录。即使多的这一行记录当中某些字段是NULL，后期也没有办法在执行insert语句插入数据了，只能使用update进行更新。

将查询结果插入到一张表中

语法：insert into 表名 select语句;

insert into t1 select * from user;

update

修改数据

语法格式：update 表名 set 字段名1=值1,字段名2=值2... where 条件;

【注意】：没有条件整张表数据全部更新。

将id为1001的年龄改成18

update user set age=18 where id=1001;

将所有的aid都改成1

update user set aid=1;

delete

删除数据
语法格式：delete from 表名 where 条件;
【注意】：没有条件全部删除。

删除id为1004的数据

 delete from user where id=1004;

删除表中所有数据

delete from user;

删除大表中的数据

语法：truncate table 表名; 【注意】：表被截断，不可回滚。永久丢失。

truncate table user;

增删改查有一个术语：CRUD操作
Create（增） Retrieve（检索） Update（修改） Delete（删除）

约束

1、什么是约束(Constraint)？
    在创建表的时候，可以给表的字段添加相应的约束，添加约束的目的是为了保证表中数据的合法性、有效性、完整性。
2、常见的约束有哪些呢？
        非空约束(not null)：约束的字段不能为NULL

        唯一约束(unique)：约束的字段具有唯一性，不能重复，但可以为NULL。

        主键约束(primary key)：约束的字段既不能为NULL，也不能重复（简称PK）

        外键约束(foreign key)：...（简称FK）

        检查约束(check)：注意Oracle数据库有check约束，但是mysql没有，目前mysql不支持该约束。

非空约束(not null)

约束的字段不能为NULL

添加在字段类型的后面

create table t_user(
    id int,
    username varchar(255) not null,
    password varchar(255)
);

【注意】：只有列级约束。没有表级约束。

唯一约束(unique)

约束的字段具有唯一性，不能重复，但可以为NULL。

列级约束：字段的一列中不能出现重复的。

create table t_user(
    id int,
    username varchar(255) unique
);

表级约束：多个字段联合起来添加1个约束unique

这些联合起来的字段不能都相同。

create table t_user(
    id int, 
    usercode varchar(255),
    username varchar(255),
    unique(usercode,username)
);

主键约束(primary key)

约束的字段既不能为NULL，也不能重复（简称PK）

1、主键相关的术语？
        主键约束 : primary key
        主键字段 : id字段添加primary key之后，id叫做主键字段
        主键值 : id字段中的每一个值都是主键值。

2、主键有什么作用？
        - 表的设计三范式中有要求，第一范式就要求任何一张表都应该有主键。
        - 主键的作用：主键值是这行记录在这张表当中的唯一标识。（就像一个人的身份证号码一样。）

3、主键的分类？
        根据主键字段的字段数量来划分：
            单一主键（推荐的，常用的。）
            复合主键(多个字段联合起来添加一个主键约束)（复合主键不建议使用，因为复合主键违背三范式。）
        根据主键性质来划分：
            自然主键：主键值最好就是一个和业务没有任何关系的自然数。（这种方式是推荐的）
            业务主键：主键值和系统的业务挂钩，例如：拿着银行卡的卡号做主键，拿着身份证号码作为主键。（不推荐用）最好不要拿着和业务挂钩的字段作为主键。因为以后的业务一旦发生改变的时候，主键值可能也需要随着发生变化，但有的时候没有办法变化，因为变化可能会导致主键值重复。

列级约束

create table t_user(
    id int primary key,
    username varchar(255),
    email varchar(255)
);

表级约束

create table t_user(
    id int,
    username varchar(255),
    primary key(id)
);

【注意】：一张表的主键约束只能有1个。

mysql提供主键值自增

create table t_user(
    id int primary key auto_increment,
    username varchar(255)
);

id字段自动维护一个自增的数字，从1开始，以1递增。

Oracle当中也提供了一个自增机制，叫做：序列（sequence）对象。

外键约束(foreign key)

关于外键约束的相关术语：
        外键约束: foreign key
        外键字段：添加有外键约束的字段
        外键值：外键字段中的每一个值。

这里有一个外键约束案例：

        t_student中的classno字段引用t_class表中的cno字段，此时t_student表叫做子表。t_class表叫做父表。

create table t_class(
    cno int,
    cname varchar(255),
    primary key(cno)
);

create table t_student(
    sno int,
    sname varchar(255),
    classno int,
    primary key(sno),
    foreign key(classno) references t_class(cno)
);

存在外键约束时顺序要求：
            删除数据的时候，先删除子表，再删除父表。
            添加数据的时候，先添加父表，在添加子表。
            创建表的时候，先创建父表，再创建子表。
            删除表的时候，先删除子表，在删除父表。

【注意】：外键可以为NULL。

外键字段引用其他表的某个字段的时候，被引用的字段不一定是主键，但需要具有unique约束。

检查约束(check)

【注意】Oracle数据库有check约束，但是mysql没有，目前mysql不支持该约束。

TCL（事务控制语言）

1、什么是事务？

        一个事务是一个完整的业务逻辑单元，不可再分。
        比如银行转账行为至少两条DML语句必须同时成功，或者同时失败，不允许出现一条成功，一条失败。要想保证以上的两条DML语句同时成功或者同时失败，那么就需要使用数据库的“事务机制”。

2、和事务相关的语句只有：DML语句。（insert delete update）
        因为它们这三个语句都是和数据库表当中的“数据”相关的。事务的存在是为了保证数据的完整性，安全性。

3、假设所有的业务都能使用1条DML语句搞定，就不需要事务机制，但实际情况不是这样的，通常一个“事儿（事务【业务】）”需要多条DML语句共同联合完成。

4、事务包括四大特性：ACID
        A: 原子性：事务是最小的工作单元，不可再分。
        C: 一致性：事务必须保证多条DML语句同时成功或者同时失败。
        I：隔离性：事务A与事务B之间具有隔离。
        D：持久性：持久性说的是最终数据必须持久化到硬盘文件中，事务才算成功的结束。

5、关于事务之间的隔离性
        事务隔离性存在隔离级别，理论上隔离级别包括4个：
            第一级别：读未提交（read uncommitted）
                对方事务还没有提交，我们当前事务可以读取到对方未提交的数据。读未提交存在脏读（Dirty Read）现象：表示读到了脏的数据。

            第二级别：读已提交（read committed）
                对方事务提交之后的数据我方可以读取到。这种隔离级别解决了：脏读现象没有了。读已提交存在的问题是：不可重复读。

            第三级别：可重复读（repeatable read）
                这种隔离级别解决了：不可重复读问题。这种隔离级别存在的问题是：读取到的数据是幻象。

            第四级别：序列化读/串行化读（serializable） 
                解决了所有问题。效率低。需要事务排队。
【注意】： mysql数据库默认的隔离级别是：可重复读。oracle数据库默认的隔离级别是：读已提交。

mysql事务默认情况下是自动提交的。
        自动提交：只要执行任意一条DML语句则提交一次。

        关闭自动提交：start transaction;

commit;  提交事务

rollback;  回滚事务

设置隔离级别;

        第1级别：读未提交

set global transaction isolation level read uncommitted;

        第2级别：读已提交

set global transaction isolation level read committed;

        第3级别：可重复读

set global transaction isolation level repeatable read;

索引

1、什么是索引？有什么用？
        索引就相当于一本书的目录，通过目录可以快速的找到对应的资源。
        在数据库方面，查询一张表的时候有两种检索方式：
            第一种方式：全表扫描
            第二种方式：根据索引检索（效率很高）

        索引为什么可以提高检索效率呢？
            其实最根本的原理是缩小了扫描的范围。

        索引虽然可以提高检索效率，但是不能随意的添加索引，因为索引也是数据库当中的对象，也需要数据库不断的维护。是有维护成本的。比如，表中的数据经常被修改这样就不适合添加索引，因为数据一旦修改，索引需要重新排序，进行维护。

        添加索引是给某一个字段，或者说某些字段添加索引。

select id,name,age from user where name='lisi';

        当name字段上没有添加索引的时候，以上sql语句会进行全表扫描，扫描name字段中所有的值。
        当name字段上添加索引的时候，以上sql语句会根据索引扫描，快速定位。

2、创建索引对象：create index 索引名称 on 表名(字段名);
      删除索引对象：drop index 索引名称 on 表名;

3、什么时候考虑给字段添加索引？
        * 数据量庞大。（根据客户的需求，根据线上的环境）
        * 该字段很少的DML操作。（因为字段进行修改操作，索引也需要维护）
        * 该字段经常出现在where子句中。（经常根据哪个字段查询）

4、【注意】：主键和具有unique约束的字段自动会添加索引。根据主键查询效率较高。尽量根据主键检索。

5、查看sql语句的执行计划：

 explain select id,name,age from user where name='lisi';

         给名字name字段添加索引：        

create index user_name_index on user(name);

 explain select id,name,age from user where name='lisi';

6、索引底层采用的数据结构是：B + Tree

7、索引的实现原理？
        通过B Tree缩小扫描范围，底层索引进行了排序，分区，索引会携带数据在表中的“物理地址”，最终通过索引检索到数据之后，获取到关联的物理地址，通过物理地址定位表中的数据，效率是最高的。

select id,name,age from user where name='lisi';

            通过索引转换为：

select id,name,age from user where 物理地址 = 0x3;

8、索引的分类？
        单一索引：给单个字段添加索引
        复合索引: 给多个字段联合起来添加1个索引
        主键索引：主键上会自动添加索引
        唯一索引：有unique约束的字段上会自动添加索引
        ....

9、索引什么时候失效？

select id,name from user where name like '%s%';

        模糊查询的时候，第一个通配符使用的是%，这个时候索引是失效的。

视图

1、什么是视图(view)？
        站在不同的角度去看到数据。（同一张表的数据，通过不同的角度去看待）。

2、创建视图

create view myview as select * from user;

删除视图

drop view myview;

【注意】：只有DQL语句才能以视图对象的方式创建出来。

3、对视图进行增删改查，会影响到原表数据。（通过视图影响原表数据的，不是直接操作的原表）可以对视图进行CRUD操作。

4、视图的作用
        视图可以隐藏表的实现细节。保密级别较高的系统，数据库只对外提供相关的视图，java程序员只对视图对象进行CRUD。

存储引擎

1、完整的建表语句

CREATE TABLE `t_x` (
    `id` int(11) DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

【注意】：在MySQL当中，凡是标识符是可以使用飘号括起来的。最好别用，不通用。

        建表的时候可以指定存储引擎，也可以指定字符集。

        mysql默认使用的存储引擎是InnoDB方式。默认采用的字符集是UTF8

2、什么是存储引擎呢？
        存储引擎这个名字只有在mysql中存在。（Oracle中有对应的机制，但是不叫做存储引擎。Oracle中没有特殊的名字，就是“表的存储方式”）

        mysql支持很多存储引擎，每一个存储引擎都对应了一种不同的存储方式。每一个存储引擎都有自己的优缺点，需要在合适的时机选择合适的存储引擎。

3、查看当前mysql支持的存储引擎？

show engines \G

4、常见的存储引擎？

            Engine: MyISAM
                  Support: YES
                  Comment: MyISAM storage engine
            Transactions: NO
                         XA: NO
              Savepoints: NO

            MyISAM这种存储引擎不支持事务。MyISAM是mysql最常用的存储引擎，但是这种引擎不是默认的。
            MyISAM采用三个文件组织一张表：
                xxx.frm（存储格式的文件）
                xxx.MYD（存储表中数据的文件）
                xxx.MYI（存储表中索引的文件）
            优点：可被压缩，节省存储空间。并且可以转换为只读表，提高检索效率。
            缺点：不支持事务。

                  Engine: InnoDB
                  Support: DEFAULT
                  Comment: Supports transactions, row-level locking, and foreign keys
            Transactions: YES
                         XA: YES
              Savepoints: YES

            优点：支持事务、行级锁、外键等。这种存储引擎数据的安全得到保障。
            表的结构存储在xxx.frm文件中
            数据存储在tablespace这样的表空间中（逻辑概念），无法被压缩，无法转换成只读。
            这种InnoDB存储引擎在MySQL数据库崩溃之后提供自动恢复机制。
            InnoDB支持级联删除和级联更新。

                    Engine: MEMORY
                  Support: YES
                  Comment: Hash based, stored in memory, useful for temporary tables
            Transactions: NO
                         XA: NO
              Savepoints: NO

            缺点：不支持事务。数据容易丢失。因为所有数据和索引都是存储在内存当中的。
            优点：查询速度最快。
            以前叫做HEPA引擎。

DBA命令

1、将数据库当中的数据导出
        在windows的dos命令窗口中执行：（导出整个库）

 mysqldump ms>D:\ms.sql -uroot -p333

        在windows的dos命令窗口中执行：（导出指定数据库当中的指定表）

 mysqldump ms user>D:\ms.sql -uroot –p123

2、导入数据

create database ms;
use ms;
source D:\ms.sql

三范式

1、什么是设计范式？
        设计表的依据。按照这个三范式设计的表不会出现数据冗余。

2、三范式都是哪些？

        第一范式（1NF）：任何一张表都应该有主键，并且每一个字段原子性不可再分。

        第二范式（2NF）：建立在第一范式的基础之上，所有非主键字段完全依赖主键，不能产生部分依赖。（多对多，三张表，关系表两个外键）

        比如：学生和老师之间。

        第三范式（3NF）：建立在第二范式的基础之上，所有非主键字段直接依赖主键，不能产生传递依赖。（一对多，两张表，多的表加外键）

        比如：学生和班级之间。