Mysql快速入门

1.数据库：高效的存储和处理数据的介质（介质主要有两种：硬盘和内存）。

2.数据库的分类：
一：按数据库存储介质的不一样
    1)关系型数据库DBMS
    2)非关系型数据库NoSQL(not only SQL)

3.数据库产品：
一：关系型数据库产品：
    1)大型：Oracle、DB2
    2)中型：SQLServer、Mysql
    3)小型：access
二：非关系型数据库产品：
    membird、mongodb、redis

4.两种数据库的区别：
一：关系型数据库：安全（保存在磁盘数据基本不可能丢失）、浪费空间
二：非关系型数据库：效率高（保存在磁盘）、数据（断电）容易丢失

5.关系型数据库：

(1)关系型数据库：是一种创建在关系模型（数学模型）上的数据库。

(2)关系模型：一种创建在关系上的模型，关系模型包含三个方面：
    数据结构：解决数据存储的问题、二维表（行、列）
    操做指令集合：全部的SQL语句
    完整性约束：表内数据约束（字段与字段），表与表之间的约束（外键）

(3)关系型数据库的设计？
    从须要存储的需求中分析，若是是一类数据（实体）应该设计成一张二维表，
    表是由表头（字段名：用来规定数据的名称）和数据（实际存储的数据单元）部分组成。
    案例：分析教学系统进行处理：讲师负责教学，教学生，在教室教学生
    1)找出系统中存在的实体：
        讲师表、学生表、班级表
    2)找出实体中存在的数据信息：
        讲师：姓名、性别、年龄、工资
        学生：姓名、性别、学号、学科
        班级：班级名称、教室编号

(4)关系型数据库维护的关系：维护实体内部，实体与实体之间的联系。

(5)

(6)

-- ============================

数据库操做：

一：建立：
CREATE DATABASE DBNAME [DEFAULT] CHARACTER SET UTF8 COLLATE UTF8_GENERAL_CI;
字符集：CHARACTER SET UTF8            CHARACTER SET = CHARSET
校对集：COLLATE UTF8_GENERAL_CI       CI不区分大小写、CS区分大小写
###### 校对集依赖于字符集
#显示全部的校对集: SHOW COLLATION [LIKE 'pattern(%_)']
#显示全部的字符集：SHOW CHARACTER SET [LIKE 'pattern(%_)']        CHARACTER SET = CHARSET

例子：
CREATE DATABASE 中国 DEFAULT CHARACTER SET UTF8 COLLATE UTF8_GENERAL_CI;
SET NAMES GBK; -- 告诉服务器SQL使用的编码

二：删除：DROP DATABASE DBNAME;

三：查询：
1）查看数据库：SHOW DATABASES [LIKE 'pattern(%_)'];
2）查看数据库建立语法：SHOW CREATE DATABASE DBNAME;

四：修改数据库：
1）修改数据库名称：低版本支持（5.1.7）、高版本不支持（5.1.23）
2）修改数据库字符集：ALTER DATABASE DBNAME [DEFAULT] CHARACTER SET GBK/UTF8
3）修改数据库校对集：ALTER DATABASE DBNAME [DEFAULT] COLLATE UTF8_GENERAL_CI
4）修改字符集和校对集：ALTER DATABASE DBNAME [DEFAULT] CHARACTER SET UTF8 COLLATE UTF8_GENERAL_CI;

五：进入数据库环境：USE DBNAME[;]

表操做：

一：建立表：
CREATE TABLE [IF NOT EXISTS] [DBNAME.]TABLENAME(
    字段名称1 数据类型1 约束1,
    字段名称2 数据类型2 约束2,
    ......
    字段名称n 数据类型n 约束n
)[表选项];

IF NOT EXISTS：检查做用

表选项：控制表的表现：
1）字符集：CHARACTER SET/CHARSET 具体字符集、保证表中存储数据的字符集
2）校对集：COLLATE 具体的校对集
3）存储引擎：ENGINE具体的存储引擎（innodb、myisam）

二：删除数据表：
    DROP TABLE TABLENAME1,TABLENAME2,... ;
    当删除数据表的SQL指定执行以后，该表和表中的数据都会被删除。
    ******删除有危险，操做需谨慎（不可逆）
    
三：查看表
1）查看表：SHOW TABLES [LIKE 'pattern(%_)'];
2）查看表建立语法：SHOW CREATE TABLE TABLENAME \G （纵向）\g（横向）
3）查看表结构：SHOW COLUMNS FROM/DESC/DESCRIBE TABLENAME;

四：修改数据表：

表自己存在，还包含字段：

1）修改表自己：
    修改表名：RENAME TABLE OLDTABLENAME TO NEWTABLENAME;
    修改表选项：ALTER TABLE TABLENAME OPTION [=] OPTIONVALUE
        例如：ALTER TABLE t_test1 CHARSET [=] GBK;

2)修改表字段：
    新增字段：
        ALTER TABLE TABLENAME ADD COLUMNNAME 数据类型 [约束] [POSITION(FIRST/AFTER)];
        FIRST : 第一个位置。
        AFTER : 在哪一个字段的后面。
    删除字段：
        ALTER TABLE TABLENAME DROP COLUMNNAME;    
    修改字段：
        修改字段类型或属性：
            ALTER TABLE TABLENAME MODIFY COLUMNNAME 数据类型 [属性] [POSITION(FIRST/AFTER)];
        修改字段名称：
            ALTER TABLE TABLENAME CHANGE OLDCOLUMNNAME NEWCOLUMNNAME 数据类型 [属性] [POSITION(FIRST/AFTER)];
    
    ******若是表中字段已经存在数据，删除字段会删除该字段的全部数据，并且是不可逆的。

数据操做：

一：新增数据：
    INSERT INTO TABLENAME VALUES(...),(...),...;
    INSERT INTO TABLENAME(FIELD1,FIELD2,FIELD3...) VALUES(...),(...),...;
    ******有时候使用VALUE代替VALUES也能够。
    
二：删除数据：
    DELETE FROM 
    
三：查看数据
    SELECT */COLUMN1,COLUMN2,... FEROM TABLENAME1,TABLENAME2,... [WHERE条件];

四：更新数据：
    UPDATE TABLE1,TABLE2,... SET COLUMN1=VALUE1,COLUMN2=VALUE2,...[WHERE条件];

中文数据问题：
    SHOW CHARACTER SET [LIKE 'pattern(%_)']; -- 查看数据库支持的字符集
    SHOW VARIABLES [LIKE 'pattern(%_)']; -- 查看数据库变量
    查看服务器对外使用的字符集：
        SHOW VARIABLES LIKE 'CHARACTER_SET%';
    修改服务器默认客户端使用的字符集：
        SET CHARACTER_SET_CLIENT=GBK;
    修改服务器给定客户端使用的字符集：
        SET CHARACTER_SET_RESULTS=GBK;
        
    ******SET 变量=值; -- 只是会话级别的修改，只对当前客户端窗口有效。
    
    设置服务器对客户端的字符集的认知：
        SET NAMES GBK;

校对集：
    数据比较的方式。

三种格式：
    _bin:binary,二进制进行比较，取出二进制位，一位一位的比较，
        从左到右，区分大小写。
    _cs:case sensitive,大小写敏感。
    _ci:case insensitive,大小写不敏感。

查看数据库全部的校对集：
    SHOW COLLATION [LIKE 'pattern(%_)'];

******校对集应用：
    只有当数据进行比较的时候，校对集才会生效。
校对集必须在没有数据以前声明好，
若是有了数据，再声明校对集，那么校对集对数据无效。

列属性：
    空属性：NULL、NOT NULL
    默认值：DEFAULT
    注解：COMMENT
    主键：PRIMARY KEY    
    惟一键：UNIQUE KEY
    自增加：AUTO_INCREMENT
    

CREATE TABLE t_pri(
    stu_code VARCHAR(50) PRIMARY KEY, 
        -- 第一种方式建立PRIMARY KEY
        -- 优势：很是直接、缺点：只能只用一个字段;
    stu_name VARCHAR(20) NOT NULL
)ENGINE INNODB DEFAULT CHARSET UTF8 COLLATE UTF8_GENERAL_CI;

CREATE TABLE db_test1.t_pri2(
    univ_code VARCHAR(50),
    stu_code VARCHAR(50),
    PRIMARY KEY(univ_code,stu_code)
        -- 第二种方式建立PRIMARY KEY
        -- 能够建立复合主键
)ENGINE INNODB DEFAULT CHARSET UTF8 COLLATE UTF8_GENERAL_CI;

-- 第三种方式：追加主键
ALTER TABLE TABLENAME MODIFY COLUMNNAME ...;
ALTER TABLE TABLENAME ADD PRIMARY KEY(主键字段);

删除主键：一个表只能有一个主键，因此删除起来很方便
ALTER TABLE TABLENAME DROP PRIMARY KEY;

自增加：AUTO_INCREMENT
如何肯定下一次自增加呢？
经过查看表的建立语句就能够看到。

修改下一个自增加的值：
只能向上修改，向下修改对自增加无效。
ALTER TABLE TABLENAME AUTO_INCREMENT = 值;

查看自增加变量：
SHOW VARIABLES LIKE 'AUTO_INCREMENT%';
修改自增加起始值、步长是对整个数据的修改
会话级修改(SET)：
SET AUTO_INCREMENT_INCREMENT = 值;
SET AUTO_INCREMENT_OFFSET = 值;

删除自增加：
ALTER TABLE TABLENAME MODIFY COLUMNNAME DATATYPE;

惟一键：UNIQUE KEY
一张表能够有多个惟一键。

删除惟一键：（删除索引）
ALTER TABLE TABLENAME DROP INDEX 索引名称;

索引：
    几乎全部的索引都是创建在字段之上。
    索引：系统根据某种算法，将已经有的数据（将来可能新增的数据），
        单独创建一个文件；可以实现快速的匹配数据，而且可以快速的找到对应
        表中的记录。
索引的意义：
    提高数据的查询效率、
    约束数据的有效性。
    
增长索引的前提条件：
    索引自己会产生索引文件（
    有时候可能比数据文件大）
    会很是耗费磁盘空间。
    若是某个字段须要做为查询的常用，
    那么可使用索引（必定会想办法增长）
若是某个字段须要进行数据的有效性约束，
也可能使用索引。

MySQL中提供了多种索引：
1）主键索引：PRIMARY KEY
2)惟一索引：UNIQUE KEY
3)全文索引：FULLTEXT INDEX
4)普通索引：INDEX

全文索引：FULLTEXT
    针对文章内部的关键字进行索引。
    全文索引的最大问题：在于如何肯定关键字。
    英文很容易：英文单词与单词之间都有空格。
    中文肯定关键字很难：
        没有空格、并且中文能够各类随意组合（分词：SPHINX）

修改索引：
ALTER TABLE TABLENAME ADD INDEX INDEXNAME ON COLUMNNAME 数据类型;

表关系：
将实体与实体之间的关系最终反应到数据库表的设计上来，
将关系分为三种：一对1、一对多（多对一）、多对多
全部的关系都是指表与表之间的关系。

范式：
NORMAL FORMAT,是一种离散数学中的知识，是为了
解决一种数据的存储与优化的问题：保存数据存储以后，
凡是可以经过关系找出来的数据，坚定再也不重复存储。
范式的终极目标是为了减小数据的冗余。

范式：是一种分层结构的规范。
能够分为六层。每一层都比上一层更加严格。
若要知足下一层的范式，前提是须要知足上一层的范式。
1NF、2NF、3NF、4NF、5NF、6NF

MYSQL属于关系型数据库：
有空间的浪费，为了致力于节省存储空间的，与范式全部
解决的问题不谋而合，在设计数据库的时候，会利用范式来知
指导设计。
可是数据库不单是要解决空间问题、还要保证效率问题、
可是范式只为解决空间问题，因此数据库的设计又不可能彻底按照范式的要求实现，通常状况下，数据库设计
只须要吗，知足前三种范式的需求便可。
范式在数据库的设计当中具备指导的意义，
但不是强制规范。

-- =================================================
数据的高级操做：
1.新增数据：
基本语法：
INSERT INTO 代表[(字段列表)] VALUES(值列表1),(值列表2)...(值列表n);

在插入数据的时候，假设主键对应的值已经存在
插入时必定会失败。
问题：主键冲突?
当主键存在冲突的时候、咱们能够选择性的进行处理、
更新和替换。

主键冲突时更新操做？
INSERT INTO 代表[(字段列表（包含主键）)]
VALUES(值列表) ON DUPLICATE KEY UPDATE
字段=新值;
主键冲突时替换操做？
REPLACE INTO 代表[(字段列表（包含主键）)] VALUES(值列表);

蠕虫复制：
蠕虫：分裂生长
从已有的数据中去获取数据，而后又将数据进行新增操做、
数据成倍的增长。

表建立的高级操做：从已有的表中新建表结构。
CREATE TABLE 表名 LIKE 数据库名称.表名称;

蠕虫复制：先查询出表数据，而后将查出来的数据新增一遍
INSERT INTO 代表[(字段列表)] SELECT 字段列表/* FROM 表名;

蠕虫复制的意义：
从已有表复制数据到新表。
能够迅速让表中的数据膨胀到必定的数量级别、
测试表的压力和效率。

2.更新数据：
基本语法：
UPDATE 表名 SET 字段=值 [WHERE条件];

高级新增语法：
UPDATE 表名 SET 字段=值 [WHERE条件][LIMIT 更新数量];

3.删除数据：

与更新相似、可使用LIMIT来限制删除数量
DELETE FROM 表名 [WHERE条件][LIMIT 删除数量];

删除：若是表中存在自增加、那么当删除表中数据以后、
自增加不会还原。

先删除表、又新建立表：
清空表、重置自增加。
TRUNCATE 表名称;

4.查询数据：
完整语句结构：
SELECT [SELECT选项(ALL(默认)、DISTINCT)] 字段/* FROM 
表名称1,表名称2,...,表名称n
[WHERE子句] [GROUP BY子句] [HAVING 子句]
[ORDER BY子句] [LIMIT 子句];

字段别名：
当数据进行查询出来的时候、有时候名字不必定知足需求(多表查询时),
可能会出现字段重名的状况、这时就须要对字段名称进行重命名、别名

字段 [AS] 别名

外键(FOREIGN KEY)：外面的键（再也不本身的表）
若是一张表中有一个字段（非主键）指向另外一张表的
主键，那么该字段被称为外键。
外键能够在建立表的时候或建立表以后增长（可是要考虑数据的问题）

一张表能够有多个外键。

外键的建立方式：
1.建立表的时候增长外键：
在全部表字段以后，格式：
[CONSTRAINT 外键名字(方便维护外键)] FOREIGN KEY(外键字段) REFERENCES(外键的引用) 另外一张表(表字段);

2.在新增表以后增长外键：
ALTER TABLE 表名 ADD [CONSTRAINT 外键名字] FOREIGN KEY REFERENCES 另外一张表(表字段);

修改(删除)外键：
外键不可修改、只能先删除、后新增。
格式：
ALTER TABLE 表名 DROP FOREIGN KEY 外键名字;
(一张表能够有多个外键、可是每一个外键的名字不能相同!)

外键的删除不能经过查看表结构语句体现、
能够经过查看表的建立语句体现。

外键的做用：
默认有两点做用：
1.对父表的约束：
父表进行读写操做时，（删除、更新都涉及到主键自己），
若是对应的主键在表中已经被数据所引用，那么就不容许操做。

2.对子表的约束：子表在进行数据的读写操做时，外键字段值
在父表中不存在、则操做失败。

外键条件：
1.外键要存在：首先必须保证表的存储引擎是INNODB（MYSQL 默认的存储引擎）
若是不是INNODB存储引擎、那么外键虽然能够建立成功、
可是没有约束效果

2.外键字段的字段类型（列类型）必须与父表的主键类型彻底一致。

3.一张表中的外键名字不能重复。

4.增长外键的字段数据已经存在，必须保证数据和父表中的数据相对应。

外键的约束模式：
外键的约束指的是外键的做用。
上面讲得做用，都是外键默认的做用。
外键有三种约束模式：（都是针对父表的约束）
1.DISTRICT:严格模式（默认的）、父表不能删除或更新一个已经被子表数据引用的记录。
2.CASCADE：级联模式、父表的操做、对应的子表也跟着被删除。
3.SET NULL：置空模式、父表操做以后、子表对应的数据（外键字段）被置空。

一般一个合理的约束模式：
    删除的时候子表置空、更新的时候子表级联操做。

指定外键约束模式的语法格式：
FOREIGN KEY(外键字段) REFERENCES 父表（主键字段） 
ON DELETE SET NULL
ON UPDATE CASCADE;

****** 删除置空的前提条件：外键字段容许为空。
若是不知足条件、外键没法建立。

外键虽然很强大、可以进行各类约束、
可是对于JAVA来讲、外键的约束下降了JAVA对程序的可控性、
一般在实际开发中，不多使用外键来处理。

外键在关系型数据库中的地位很是重要、可是咱们不多使用。

联合查询：
讲屡次查询（多SELECT语句），在记录数上进行拼接（字段不增长）。

基本语法：
多条SELECT语句构成：每一条SELECT语句获取的字段数必须严格一致。
格式：
SELECT 语句1
UNION[UNION ALL]
SELECT 语句2
...
UNION[UNION ALL]
SELECT 语句n;

UNION 选项：链接两个SELECT语句。
UNION ALL：保留全部（无论重复）
      DISTINCT：去重（整个重复）默认的。

联合查询只要求字段数同样，

联合查询的意义：
1.查询同一张表、可是需求不一样。
2.多张表的结构是彻底同样的，保存的数据（结构）也是同样的。

【数据库分表】
1.垂直分表。
2.水平分表。

******联合查询中ORDER BY 的使用：
在联合查询中要使用ORDER BY进行排序、
要使用"()"将SELECT语句括起来

******要使得联合查询中的ORDER BY语句生效，
SELECT查询语句还得搭配LIMIT使用。

子查询：SUB QUERY,就是在某个查询的结果之上进行的。
（一条SELECT语句内包含了另一条SELECT语句。）

子查询分类：
子查询有两种分类方式：
1.按位置分类。
2.按结果分类。

按位置分类：
    1)FROM 子查询：子查询跟在FROM以后。
    2)WHERE 子查询：子查询出如今WHERE条件中。
    3)EXISTS子查询：子查询出如今EXISTS里面。

按结果分类：
    根据子查询获得的数据进行分类（
    理论上任何一个查询的结果均可以理解为二维表）
    1)标量子查询：结果是一行一列。
    2）列子查询：一列多行（一排记录）
    3）行子查询：子查询获得的结果是多列一行或多行多列。
        1)、2)、3)出如今WHERE以后。
    4）表子查询获得的结果是多行多列（出如今FROM以后）

标量子查询：
SELECT 一个字段名 FROM 表名 WHERE 字段名=(SELECT 字段名 FROM ...)

列子查询：
SELECT id FROM ... WHERE id IN(SELECT id FROM ...)
几个相似的条件：ALL 、SOME 、ANY
ANY 、SOME 在确定句中两个条件是同样的。
ANY 、SOME 在否认句中是不同的。
=ANY
=SOME
=ALL
!=ANY
!=SOME
!=ALL
******NULL空字段值不参与比较。

行子查询：
SELECT * FROM ... WHERE (age,height) = (SELECT MAX(age),MAX(height) FROM ...)
******行元素的比较(age,height) = (SELECT MAX(age),MAX(height) FROM ...)

表子查询：
    子查询结果返回的是一个多行多列的二维表。
    子查询返回的结果当作二维表来使用。

EXISTS子查询：
    EXISTS：是否存在的意思。
    用来判断某些条件是否知足、一般是跨表的条件。
    EXISTS是接在WHERE以后，返回的结果是0或1。
    
SELECT * FROM ... WHERE EXISTS(SELECT * FROM ... WHERE ...)

视图：view
是一种有结构（行、列）可是没结果（结构中不真实存放数据）的虚拟表。
虚拟表的结构来源不是本身定义，而是从对应的基表中产生（视图的数据来源）。

建立视图基本语法：
CREATE VIEW 视图名称 
AS (SELECT ... [普通查询|链接查询|联合查询|子查询]);

建立单表视图：
    基表来源只有一个。
建立多表视图：
    基原本源至少有两个。
    *注意字段重名问题。

查看视图：
    查看视图的结构。
    SHOW TABLES [LIKE ''];
    SHOW CREATE TABLE/VIEW 视图名称;
    DESC 视图名称;
    
使用视图：
    主要是为了查询，将视图当作表同样查询就OK.
    视图的执行：
        其实本质就是执行封装的SELECT语句。
        应用于封装基表的查询。

修改视图：
    视图自己不可修改，可是视图自己的来源是能够修改。
    修改视图语法：
        ALTER VIEW 视图名称 AS 新的SELECT语句;

删除视图：
    语法：DROP VIEW 视图名称;

视图的意义：
    1.视图能够减小SQL语句，将一条复杂的查询语句使用视图进行保存，
    之后能够直接对视图进行操做。
    2.数据安全，视图操做主要是针对查询的，若是的视图进行结构处理，
    不会影响基表数据（相对安全）。
    3.视图每每是在大项目中使用，并且是多系统使用.
    能够对外可提供有用的数据，隐藏关键数据，数据安全。
    4.视图能够对外提供友好型，不一样的视图提供不一样的数据，
    对外好像专门设计。
    5.视图能够更好的进行权限控制。
    
视图数据操做：
视图确实是能够进行数据写操做的，可是有不少限制。
将数据直接在视图上进行操做。

视图新增数据：
单表视图能够新增数据、可是表中包含不为空字段可是不出如今视图中
就不能够插入。

视图删除数据:
多表视图不能删除。
单表视图能够删除。

视图更新数据：
单表、多表视图均可以更新数据。

******视图更新数据限制：WITH CHECK OPTION , 若是对视图
进行新增的时候，限定了某个字段有限制：
那么对视图进行数据更新操做，系统会进行验证：要
保证更新以后，数据依然能够被实体查询出来，不然不让更新。

视图算法：
    系统对视图以及外部查询视图的SELECT语句的一种解析方式。
    视图算法分为三种：
        1.UNDEFINED:未定义（默认的），
            这不是一种实际使用的算法，告诉系统，视图没有定义算法。
        2.TEMPTABLE:临时表算法。系统应该先执行视图的SELECT
            语句，后执行外部查询语句。
        3.MERGE:合并算法，系统现将视图对应的SELECT语句与外部视图的
        的算法进行合并查询,效率高。
    指定视图算法的语法规则：
        CREATE ALGORITHM=视图算法 VIEW 视图名称 AS SELECT ...;
    如何选用视图算法：
        若是视图语句中会包含一个查询子句（五子句），并且颇有可能
        顺序比外部查询语句高后，必定要使用TENPTABLE算法，
        其余状况能够不用指定（默认便可）。
    
数据的备份与还原：
备份：将当前已有的数据或者记录保留。
还原：将已经保存的数据恢复到对应表中。

为何要作备份还原？
1.防止数据丢失：被盗，误操做。
2.保存数据记录。

数据备份还原的方式有不少种：
1.数据表备份
2.单表数据备份
3.SQL备份
4.增量备份

数据表备份：不须要经过sql备份：
直接进入到数据库文件夹复制对应的表结构以及
数据文件，之后还原的时候，直接将备份的内容放进去便可。

数据表备份有前提条件：
根据不一样的存储引擎有不一样的区别

存储引擎：
MYSQL进行数据存储的方式：
1.INNODB
2.MYISAM

对比MYISAM和INNODB：
INNODB:自由表结构，数据所有存储到ibdata1文件中
依赖当前数据库
MYISAM:表、数据、索引所有单独分开存储。
不依赖任何数据库,直接放到对应的数据库下便可使用。

单表数据备份：
每次只能备份一张表，只能备份数据，不能备份表结构。
一般的应用：将表中的数据进行导出到文件。
备份：从表中选出一部分数据保存到外部的文件。
语法：(前提：外部文件不存在)
    SELECT */字段列表 INTO OUTFILE 文件所在路径 FROM 数据源;

高级备份语法：
    本身制定字段和行的处理方式。
字段处理FIELDS:
    ENCLOSED BY : 字段使用什么内容包裹，默认是空字符串''。
    TERMINATED BY : 字段以什么结束，默认是tab键'\t'
行处理LIENS：
    STARTING BY : 每行以什么开始，默认是''空字符串
    TERMINATED BY : 每行以什么结束，默认是换行符'\r\n'

SELECT */字段列表 INTO OUTFILE 文件所在路径 
FIELDS
    ...
LINES
    ...
FROM 数据源;

单表数据还原：
    将一个外部保存的数据恢复到表中（若是表不存在，那么SORRY）
LOAD DATA INFILE 文件路径 INTO TABLE 表名
FIELDS
    ...
LINES
    ...;

SQL备份：
备份的是SQL语句，系统就会对表结构以及数据进行处理，
编程对应的SQL语句，而后进行备份，还原的时候只要执行
SQL指令就能够了。

MYSQL自己没有提供备份的指令。
须要利用MYSQL提供的备份软件：MYSQLDUMP.EXE指令

MYSQLDUMP.EXE也是一种客户端，须要操做服务器，必须进行
链接认证。

语法：·
MYSQLDUMP/MYSQLDUMP.EXE -H ip -P 端口 -U 用户 -P 密码
数据库名称 [数据表1][数据表2]...[数据表n]
> 文件所在路径

整个数据库备份：
MYSQLDUMP/MYSQLDUMP.EXE -H ip -P 端口 -U 用户 -P 密码
数据库名称
> 文件所在路径

SQL还原：
两种方式：
1.MYSQL客户端还原：
MYSQL/MYSQL.EXE -H ip -P 端口 -U 用户 -P 密码 数据库名称 < 备份文件路径

2.使用SQL指令：SOURCE
语法：SOURCE 文件所在路径;

SQL备份的以优缺点：
1.优势：能够备份表、库结构。
2.缺点：会浪费空间（增长额外的SQL指令）。

增量备份：
不是针对数据或者SQL指令进行备份，
是针对MYSQL服务器的日志文件进行备份。

增量备份：指定时间段开始备份，备份数据不会重复，
并且全部的操做都会备份。

事务安全：
事务（transaction）：一系列要发生的连续的操做。
事务安全：一种保护连续操做同时知足（实现）的一种机制。
事务安全的意义：保证数据操做的完整性。

事务操做：
事务操做分为两种：
    1.自动事务
    2.手动事务

手动事务：
    1.开启事务：告诉系统一下全部的增删改操做，不要直接操做数据表，
    先存放到事务日志。
    START TRANSACTION;
    2.操做数据表。
    3.关闭事务：
        选择性的将日志文件中的操做结果保存到数据表或
        清空事务日志。
        a)提交事务：COMMIT
        b)回滚事务：ROLLBACK

使用事务的前提：
    数据库的存储引擎必须是INNODB(免费)、BDB(收费)

事务原理：
事务操做原理：事务开启以后，全部的操做都会保存到事务日志，
事务日志只有在获得COMMIT命令才会同步到数据表，其它任何命令
都会清空事务日志。

客户端                    服务端                                                        数据库
1.链接认证：            验证身份，创建链接
                        开启一个临时事务日志（当前用户当次链接有效）
                        临时日志文件

2.直接SQL增删改操做        接收SQL语句，执行SQL语句：                        ---->同步到数据库
                        结果直接写入到数据表。

3.开启事务：            改变原来的操做机制：
                        后续的全部写操做，先写入临时
                        日志文件。

SQL操做：                接收SQL语句，执行SQL语句：
                        结果先写入临时事务日志文件。

查询操做结果：            会从数据表查询，通过临时日志文件
                        结果加工后返回。

事务结束：COMMIT/        清空临时事务日志文件：
          ROLLBACK/        COMMIT会同步日志结果到数据表，
          其它            ROLLBACK是直接清空日志文件。

事务：回滚点
回滚点：在某个成功的操做完成以后，
后续的操做有可能成功或失败，可是无论后续的
操做时成功或失败，前面操做都已经成功，能够在当前成功的
位置，设置一个回滚点，能够供后续失败操做返回到该位置，
而不是返回全部操做。

设置回滚点语法：
    SAVEPOINT 回滚点名称;
回滚到回滚点语法：
    ROLLBACK TO 回滚点名称;

自动事务处理：
在MYSQL中，默认的都是自动事务处理，
用户操做完会当即同步到数据表中。

自动事务：系统经过AUTOCOMMIT变量控制。

查看系统自动事务变量：
SHOW VARIABLES LIKE 'AUTOCOMMIT';

关闭自动事务：
SET AUTOCOMMIT = OFF;

注意：一般状况下都会使用自动事务。

事务特性：
事务的四大特性：
    1.ATOMIC原子性。事务的整个操做是一个总体，不可分割，
    要么所有成功，要么所有失败。
    2.CONSISTENCY，一致性，事务操做先后，数据表中的数据没有变化。
    3.ISOLATION,隔离性，事务操做相互隔离不受影响。
    4.DURBILITY,持久性，数据一旦提交，不可改变，永久的改变数据表数据。

锁机制：
    在MYSQL中，INNODB存储引擎默认使用的是行锁，
    当在事务操做的过程当中，若是没有使用索引，SQL操做
    就会全表检索，锁机制就会自动升级到表锁。

事务的隔离级别：
    READ UNCOMMITTED
    READ COMMITTED
    REAPTABLE READ
    SERIALIZABLE

SQL变量：
变量分为两种：
    系统变量和自定义变量。

查看系统变量：
    SHOW VARIABLES [LIKE '%_'];
查看系统具体变量值：
    SELECT @@变量名1,@@变量名2,...,@@变量名n;
修改系统变量：
    两种方式：
        会话级别的修改和全局级别的修改
会话级别：
    SET 变量名 = 值;或SET @@变量名 = 值;
全局级别：
    SET GLOBAL 变量名 = 值;
    
自定义变量：
系统为了区分系统变量，
规定用户自定义变量必须使用一个@符号。
定义自定义变量：
    SET @变量名 = 值;
    SET @变量名 := 值;
查看自定义变量：
    SELECT @变量名;

MYSQL容许从数据表中获取数据，而后赋值给变量，
两种方式：
方案一：
    SELECT @变量名1 := 字段名1,@变量名2 := 字段名2,...,@变量名n := 字段名n FROM ...;
方案二：
    只有赋值，不看结果，要求很严格，数据记录最多只容许获取一条，
    由于MYSQL不支持数组。
        SELECT 字段名1,字段名2,...,字段名n FROM ... INTO 变量名1,变量名2,...,变量名n;

******全部的自定义变量都是会话级别，当次用户链接有效，不区分数据库。

MYSQL触发器TRIGGER：

需求：有两张表，一张订单表，一张商品表，每生成一个订单，
意味着商品的库存要对应的减小。

触发器trigger：事先为某张表绑定好一段代码，当表中的某些内容
发生改变的时候(增删改)，系统会自动触发（执行）代码。

触发器：事件类型、触发事件、触发对象
事件类型：增INSERT 删DELETE 改UPDATE 三种类型。
触发时间：BEFORE AFTER
触发对象：表中的每一条记录（行）。

******一张表中只能拥有一种触发时间的一种类型的触发器：
最多一张表有6个触发器。

建立触发器：
语法格式：
-- 临时修改语句结束符
-- 自定义符号：后续代码中只有遇到自定义符号才算结束。
DELIMITER
CREATE TRIGGER 触发器名称 事件类型 ON 表名 FOR EACH ROW
BEGIN -- 表明左大括号，开始

END -- 表明右大括号，结束
-- 语句结束符
-- 自定义符号
-- 将临时结束符号修正：
DELIMITER ;

***在MYSQL中，没有大括号和小括号之说。

对需求制做触发器：订单生成一个，商品库存对应减小。

查看触发器：
SHOW TRIGGERS [LIKE '%_']

查看触发器建立语句：
SHOW CRAETE TRIGGER 触发器名称;

***全部的触发器都会保存到一张表中：INFOMATION_SCHEMA.TRIGGERS

使用触发器：
不须要手动调用，而是某种状况发生时，触发器会自动触发（执行）。

修改触发器和删除触发器：
触发器不能修改、只能先删除后新增。

删除触发器语法：
    DROP TRIGGER 触发器名称;

触发器记录：
触发器记录：是使无论触发器是否触发了，
只要是当某种操做准备执行，系统就会将当前要操做的记录的当前状态
和即将执行以后的新的状态分别保留下来，供触发器使用。其中要操做当前状态
保存到old中，操做以后的可能形态保存到new中.

触发器的意义: 
    能够很好的协调表内部的数据处理顺序和关系. 
    可是从Java角度出发, 触发器会增长数据库维护的难度, 因此较少使用触发器.

MYSQL代码执行结构：
循环控制: 在循环内部进行循环判断和控制.
Mysql中没有对应continue和break. 可是有替代品.
Iterate: 迭代 , 相似continue, 后面的代码不执行, 循环从新来过.
Leave: 离开, 相似break,整个循环接收.
使用方式: Iterate/Leave 循环名字;

MYSQL代码执行结构：
1.顺序结构（默认）
2.判断结构
3.循环结构

2.判断结构：
结构语法：
IF express1 THEN handlerResult1
    ELSEIF express2 THEN handlerResult2
    ...
    ELSEIF expressn THEN handlerResultn
    ELSE handlerResultELSE
END IF;

3.循环结构：
循环名称:WHILE ... DO ... END WHILE;
循环名称:REPEAT ... UNTIL ... END REPEAT;
循环名称:LOOP ... 判断语句(iterate/leave) END LOOP;

MYSQL中if , case 语句使用总结：
1.IF函数：
    IF(express1,express2,express3)
    express1为true,函数返回express2,不然返回express3.
2.IFNULL函数：
    IFNULL(express1,express2)
    express1不为空返回自己，不然返回express2.
3.CASE表达式：
结构：
    CASE 字段名 
        WHEN 值1 THEN 结果值1
        WHEN 值2 THEN 结果值2
        ...
        WHEN 值n THEN 结果值n
    ELSE 结果值else
    END
4.IF判断语句：
语法格式：
IF express1 THEN handlerResult1
    ELSEIF express2 THEN handlerResult2
    ...
    ELSEIF expressn THEN handlerResultn
    ELSE handlerResultELSE
END IF;

MYSQL函数：
函数：讲一段代码块封装到一个结构中，在须要执行
代码块的时候，调用结构执行便可。

系统函数：系统定义好的函数，直接调用便可。
任何函数都有返回值，所以函数的调用是经过SELECT调用。

MYSQL中，字符串的基本操做单位（最多见的是字符）

自定义函数：
函数的要素：
    1.函数名
    2.参数列表（形参、实参）
    3.返回值
    4.函数体（做用域）
建立函数：
格式：
DELIMITER $$
CREATE FUNCTION 函数名([形参列表]) RETURNS 数据类型
BEGIN
    函数体;
    RETURN 返回值;
END
$$
DELIMITER ;

自定义函数和系统函数的调用方式同样。

查看函数：
SHOW FUNCTION STATUS [LIKE '%_'];

******函数属于特定的数据库下。

查看函数的建立语法：
SHOW CREATE FUNCTION 函数名;

修改和删除函数：
    函数不能修改，只能先删除再建立。
删除语法：
    DROP FUNCTION 函数名;

函数参数：
参数分为两种：
    定义的参数叫形参。
    调用时的参数叫实参。能够是数值，也能够是变量。
形参：必须指定类型。

******@定义的变量为全局变量，没有@定义的变量为局部变量。

全局变量能够在任何地方使用，局部变量只能在函数内部使用。
局部函数只能在函数体执行以前定义。

全局变量声明语法：
    SET @变量名 = 值;
局部变量声明语法：
    DECLARE 变量名 变量类型 DEFAULT 值;

******要修改变量必须使用SET关键字，无论是全局变量仍是局部变量。

存储过程：
存储过程简称过程PROCEDURE,是一种用来处理数据的方式。
存储过程是一种没有返回值的函数。

建立存储过程：
语法格式：
DELIMITER $$
CREATE PROCEDURE 存储过程名称([参数列表])
BEGIN
    过程体;
END
$$
DELIMITER ;

查看存储过程：
    SHOW PROCEDURE STATUS [LIKE '%_'];

查看存储过程建立语法：
    SHOW CREATE PROCEDURE 存储过程名称;

调用存储过程：
存储过程没有返回值，意味着不能使用SELECT来调用。
    CALL 存储过程名称([实参列表]);

修改和删除存储过程：
存储过程只能先删除后新增。
删除存储过程格式：
DROP PROCEDURE 储存过程名称;

存储过程参数：

函数的参数须要数据类型指定, 过程比函数更严格.

存储过程还有本身的类型限定: 三种类型
IN: 数据只是从外部传入给内部使用(值传递): 能够是数值也能够是变量
OUT: 只容许过程内部使用(不用外部数据), 给外部使用的.(引用传递: 外部的数据会被先清空才会进入到内部): 只能是变量
INOUT: 外部能够在内部使用,内部修改也能够给外部使用: 典型的引用传递: 只能传变量

******OUT和INOUT类型属于引用传递，内部改变影响外部值。

******存储过程对于变量的操做(返回)是滞后的: 是在存储过程调用结束的时候,
才会从新将内部修改的值赋值给外部传入的全局变量.

******在存储过程调用结束以后：OUT类型和INOUT类型会将内部 对应的局部变量值从新返回给传入的对应全局变量。