一、介绍
- 索引
- 事务ACID
锁机制
二、初识SQL语句
三、SQL语句：
出现的错误
- 一.
- 二、
存储引擎
日志管理
- binlog日志操作命令
- 二进制记录格式
文件复制原理
优化方案

一、介绍

是一个关系数据库管理系统
是一个单进程多线程结构的数据库
将数据保存在不同的表中，而不是将数据放在一个大的仓库内，大大增加了灵活性

MySQL ——>甲骨文

mariadb——>mysql的分支，开源的

查看yum上提供的mysql版本

[root@localhost ~]# yum list | grep mysql

安装mariadb服务：
- yum install mariadb-server mariadb -y ``` [root@localhost ~]# systemctl start mariadb # 打开MySQL服务 [root@localhost ~]# mysql_secure_installation # 初始化操作

NOTE: RUNNING ALL PARTS OF THIS SCRIPT IS RECOMMENDED FOR ALL MariaDB SERVERS IN PRODUCTION USE! PLEASE READ EACH STEP CAREFULLY!

In order to log into MariaDB to secure it, we’ll need the current password for the root user. If you’ve just installed MariaDB, and you haven’t set the root password yet, the password will be blank, so you should just press enter here.

Enter current password for root (enter for none): # 当前root用户密码为空，所以直接敲回车 OK, successfully used password, moving on…

Setting the root password ensures that nobody can log into the MariaDB root user without the proper authorisation.

Set root password? [Y/n] y #设置root密码 New password: Re-enter new password: Sorry, passwords do not match.

New password: Re-enter new password: Password updated successfully! Reloading privilege tables.. … Success!

By default, a MariaDB installation has an anonymous user, allowing anyone to log into MariaDB without having to have a user account created for them. This is intended only for testing, and to make the installation go a bit smoother. You should remove them before moving into a production environment.

Remove anonymous users? [Y/n] y # 删除匿名用户 … Success!

Normally, root should only be allowed to connect from ‘localhost’. This ensures that someone cannot guess at the root password from the network.

Disallow root login remotely? [Y/n] y # 允许root远程登录 … Success!

By default, MariaDB comes with a database named ‘test’ that anyone can access. This is also intended only for testing, and should be removed before moving into a production environment.

Remove test database and access to it? [Y/n] y # 删除test数据库

Dropping test database… … Success!
Removing privileges on test database… … Success!

Reloading the privilege tables will ensure that all changes made so far will take effect immediately.

Reload privilege tables now? [Y/n] y # 刷新授权表，让初始化生效 … Success!

Cleaning up…

All done! If you’ve completed all of the above steps, your MariaDB installation should now be secure.

Thanks for using MariaDB! [root@localhost ~]# mysql -uroot -p1 # 登录 root用户密码为1 Welcome to the MariaDB monitor. Commands end with ; or \g. Your MariaDB connection id is 18 Server version: 5.5.60-MariaDB MariaDB Server

Type ‘help;’ or ‘\h’ for help. Type ‘\c’ to clear the current input statement.

几个基本命令：

MariaDB [(none)]> SHOW DATABASES; #显示数据库 +——————————+ | Database | +——————————+ | information_schema | | mysql | | performance_schema | +——————————+ 3 rows in set (0.10 sec) MariaDB [(none)]> use mysql; #进入数据库 Reading table information for completion of table and column names You can turn off this feature to get a quicker startup with -A

Database changed

MariaDB [mysql]> SHOW TABLES; #显示数据库中的表 +—————————————-+ | Tables_in_mysql | +—————————————-+ | columns_priv | | db | | event | | func | | general_log | | help_category | | help_keyword | | help_relation | | help_topic | | host | | ndb_binlog_index | | plugin | | proc | | procs_priv | | proxies_priv | | servers | | slow_log | | tables_priv | | time_zone | | time_zone_leap_second | | time_zone_name | | time_zone_transition | | time_zone_transition_type | | user | +—————————————-+ 24 rows in set (0.00 sec) MariaDB [mysql]> desc user; #查看user表中的数据结构 +————————————+—————————————————-+———+——-+————-+———-+ | Field | Type | Null | Key | Default | Extra | +————————————+—————————————————-+———+——-+————-+———-+ | Host | char(60) | NO | PRI | | | | User | char(16) | NO | PRI | | | | Password | char(41) | NO | | | | | Select_priv | enum(‘N’,’Y’) | NO | | N | | | Insert_priv | enum(‘N’,’Y’) | NO | | N | | | Update_priv | enum(‘N’,’Y’) | NO | | N | | | Delete_priv | enum(‘N’,’Y’) | NO | | N | | | Create_priv | enum(‘N’,’Y’) | NO | | N | | | Drop_priv | enum(‘N’,’Y’) | NO | | N | | | Reload_priv | enum(‘N’,’Y’) | NO | | N | | | Shutdown_priv | enum(‘N’,’Y’) | NO | | N | | | Process_priv | enum(‘N’,’Y’) | NO | | N | | | File_priv | enum(‘N’,’Y’) | NO | | N | | | Grant_priv | enum(‘N’,’Y’) | NO | | N | | | References_priv | enum(‘N’,’Y’) | NO | | N | | | Index_priv | enum(‘N’,’Y’) | NO | | N | | | Alter_priv | enum(‘N’,’Y’) | NO | | N | | | Show_db_priv | enum(‘N’,’Y’) | NO | | N | | | Super_priv | enum(‘N’,’Y’) | NO | | N | | | Create_tmp_table_priv | enum(‘N’,’Y’) | NO | | N | | | Lock_tables_priv | enum(‘N’,’Y’) | NO | | N | | | Execute_priv | enum(‘N’,’Y’) | NO | | N | | | Repl_slave_priv | enum(‘N’,’Y’) | NO | | N | | | Repl_client_priv | enum(‘N’,’Y’) | NO | | N | | | Create_view_priv | enum(‘N’,’Y’) | NO | | N | | | Show_view_priv | enum(‘N’,’Y’) | NO | | N | | | Create_routine_priv | enum(‘N’,’Y’) | NO | | N | | | Alter_routine_priv | enum(‘N’,’Y’) | NO | | N | | | Create_user_priv | enum(‘N’,’Y’) | NO | | N | | | Event_priv | enum(‘N’,’Y’) | NO | | N | | | Trigger_priv | enum(‘N’,’Y’) | NO | | N | | | Create_tablespace_priv | enum(‘N’,’Y’) | NO | | N | | | ssl_type | enum(‘’,’ANY’,’X509’,’SPECIFIED’) | NO | | | | | ssl_cipher | blob | NO | | NULL | | | x509_issuer | blob | NO | | NULL | | | x509_subject | blob | NO | | NULL | | | max_questions | int(11) unsigned | NO | | 0 | | | max_updates | int(11) unsigned | NO | | 0 | | | max_connections | int(11) unsigned | NO | | 0 | | | max_user_connections | int(11) | NO | | 0 | | | plugin | char(64) | NO | | | | | authentication_string | text | NO | | NULL | | +————————————+—————————————————-+———+——-+————-+———-+ 42 rows in set (0.00 sec) MariaDB [mysql]> flush privileges; #刷新数据库信息 Query OK, 0 rows affected (0.00 sec)


<a name="i1kX6"></a>
## 体系结构
组成部分：连接池组件、管理服务和工具组件、SQL接口组件、查询分析器组件、优化器组件、缓冲组件、插件式存储引擎、物理文件<br />![image.png](https://cdn.nlark.com/yuque/0/2020/png/407678/1602546158171-6334e5e6-ea3b-4013-89a8-a5a9d30a5e52.png#align=left&display=inline&height=578&margin=%5Bobject%20Object%5D&name=image.png&originHeight=764&originWidth=845&size=114451&status=done&style=none&width=639)<br />**四层**<br />**最上层：客户端连接**<br />1.连接处理：客户端与数据库服务层建立tcp连接，连接管理模块会建立连接，并请求一个连接线程<br />2.授权认证和安全机制<br />**第二层：核心服务**<br />包括：查询解析、分析、优化、缓存以及所有的内置函数。<br />所有的跨存储引擎的功能都在这一层，实现存储过程、触发器、视图等<br />**第三层：存储引擎**<br />负责MySql中数据的存储和提取<br />存储引擎是底层物理结构实现的，基于表而不是数据库<br />服务器通过API和存储引擎进行通信。这些接口屏蔽了不同存储引擎之间的差异，使得这些差异对上层的查询过        程透明化。存储引擎API包括十几个底层函数，用于执行”开始一个事务“等操作。但存储引擎一般不回去解析        SQL，不同存储引擎之间也不会通信，而只是简单的响应上层的服务请求。<br />**第四层：文件系统**<br />所有表结构和数据以及用户操作的日志最终还是以文件的形式存储在硬盘中
<a name="a6022c33"></a>
## 常见的数据库对象

视图（view）：从表中抽象出的逻辑上相关的数据集合，是一个虚拟的表，在数据库中实际不存在。数据不存储在磁盘上，不占用磁盘空间

序列（sequence）：提供有规律的数值，主要用于提供主键值

索引（index）：适当的建立索引可提高对数据的查询效率。实际存储在磁盘上，占用磁盘空间

同义词（SYNONYM）：给对象起别名，简化缩写

约束：增强数据的完整性，完整性约束是一种规则，存储在数据字典中，不占用任何数据库空间

过程和函数：区别主要是调用方式的不同。<br />过程和函数都以编译后的形式存放在数据库中，每个函数的参数个数>=0，返回值为1个；过程的参数个数>=0，没有返回值

包：将过程、函数和数据结构捆绑在一起的容器，有两部分<br />包规范：函数头、过程头、外部可视化数据结构<br />包主体：所有被捆绑的过程和函数的声明、执行、异常处理部分

触发器（Triggers）：是一种自动执行响应数据变换的程序，可以设置为在触发器事件之前或之后触发或执行

数据字典：由Oracle Server自动创建的一组表，且包含数据库信息
<a name="BKHof"></a>
## 数据类型
<a name="tUpGT"></a>
#### 数值数据类型
• int                   4字节  大整数   2147483647 int最大值范围        <br />• bigint              8字节   极大整数值<br />• smallint           2字节   大数据值<br />• tinyint             1字节    小数值<br />• float                4字节    单精度浮点数值<br />• double            8字节     双精度浮点类型<br />• float（n，m）     n：显示位数     m：小数部分     eg：create table t2 （num1 float （5，1），num2 float （5，2））
<a name="4FbRn"></a>
#### 时间数据类型
• DATE  3 YYYY-MM-DD<br />• TIME  3  HH:MM:SS<br />• YEAR  1 YYYY<br />• DARETIME    8    YYYY-MM-DD HH:MM:SS<br />• TIMESTAMP  4    YYYYMMDD HHMMSS
<a name="jhbO5"></a>
#### 字符串类型：
• char  定长字符串  定长：会将空格算作字符<br />• vchar 变长字符串  不定长：会省略空格字符<br />• text  上文本数据（备注信息）<br />• longtext 极长文本数据、
<a name="Gn8gU"></a>
## 表的约束条件
防止不规范的数据插入到数据库当中，DBMS自动按照一定的约束条件对数据进行检测，确保数据库中存储的数据正确有效<br />分类：<br />**NOT NULL**：非空约束，不支持对not null插入NULL值，只能在列级上<br />**UNIQUE**：唯一约束，指定某列或者某几列组合不能够重复，列级和表级，一张表可以有多个唯一约束，唯一约束可以为空（空也只能空一个）<br />**PRIMARY KEY**：主键，唯一标识一条记录，为了保证表中的每一个数据的该字段在表格中是唯一的。主键必须唯一，主键值为非空，且可以是单一字段，也可以是多字段组合创建主键的方式 ：创建的时候创建、在已有的表上添加主键   列级约束和表级约束一张表只允许有一个主键，删除主键：需要先删除约束条件，再删除主键<br />**FOREGIN KEY**：外键，从属于主表的一条记录关系式式建立在两张表之间的，用来限定插入数据删除数据的约束的时候取值只能从reference后面跟的另一张表的括号里面的那一列中取，且括号中只能填写唯一约束值<br />**AUTO_INCREMENT**：自增，不支持对自增长字段插入NULL值<br />**DEFAULT**：默认值<br />完整性约束条件是对字段进行限制，要求用户对该属性进行的操作符合特定的要求。如果不满足完整性约束条件，数据库系统将不执行用户的操作<br />数据库约束条件就是保证数据库中数据的完整性<br />直接跟在行后面的就是行级约束，所有字段定义完成之后才进行约束的就是表级约束
```bash
--eg中a表就是另一张表，sno就是a表中有唯一约束的那一列

语法：
create table 表名(
字段名 char foreign key references
另一张表名(另一张表中的有唯一约束的字段)
--唯一约束：primary key、unique
)
eg:
create table b(
sno char foreign key references a(sno
)

索引

索引的功能就是快速查找
类型：

普通索引，最基本的索引，它没有任何限制，用于快速查询
唯一索引，索引列的值必须唯一，但允许有空值。如果是组合索引，则列值的组合必须唯一。
主键索引，是一种特殊的唯一索引，一个表只能有一个主键，不允许有空值。一般是在建表的时候同时创建主键索引
组合索引，指多个字段上创建的索引，只有在查询条件中使用了创建索引时的第一个字段，索引才会被使用。使用组合索引时遵循最左前缀集合
全文索引，主要用来查找文本中的关键字，而不是直接与索引中的值相比较
事务ACID
事务是指一系列对数据库的操作集合，是数据库管理系统（DBMS)定义的一个执行单位
mysql事务主要用于处理操作量大、复杂度高的数据
事务的作用：
1.在并发访问数据库的场景中，利用事务来隔离多个应用程序的操作，避免多个操作彼此之间相互影响
2.提供一种从失败中恢复到正常状态的方法，同时提供数据库即使在异常状态仍能保持一致性的方法
事务的基本要素：
1.(atomicity)原子性：
事务开始后所有操作，要么全部做完，要么全部不做，不可能停滞在中间环节。事务执行过程中出错，会回滚到事务开始前的状态，所有操作就像没有发生一样
2.(consistency)一致性：
事务开始前和结束后，数据库的完整性约束没有被破坏
3.(isolation)隔离性：
同一时间，只允许一个事务请求数据，不同事务之间彼此没有任何干扰。
4.(durability)持久性：
事务完成后，事务对数据库的所有更新将保存到数据库中，不能回滚。即修改即使出现致命性的系统故障也将一致保持
脏读不可重复读幻读
脏读Drity Read：
一个事务读到了另一个事务未提交的更改。事务A读取了事务B更新的数据，然后B回滚操作，那么A读取到的数据是脏数据，与表中最终的实际数据不一致
不可重复读Non-repeatable read：
一个事务读到了另一个事务已提交的更新数据。在一个事务的两次查询之中数据不一致，这可能是查询过程中间插入了一个事务更新的数据
幻读Phantom Read：
一个事务读到了另一个事务已提交的数据。在一个事务的两次查询中数据笔数不一致，eg：一个事务查询了几列内容，另一个事务在此时插入了新的几列数据，先前的事务在接下来的查询中，机会发现几列数据是先前没有的。
ps：不可重复读侧重于修改，幻读侧重于新增或删除。解决不可重复读的问题只需锁住满足条件的行，解决幻读需要锁表。
事务隔离级别
四种级别

级别	脏读	不可重复读	幻读
读未提交（read-uncommitted）所有事务都可以看到其他未提交事务的执行结果安全性低，效率高	会产生	会产生	会产生
读已提交（read-committed）它满足了隔离的简单定义：一个事务只能看见已经提交事务所做的改变安全性较低，效率较高因为同一事务的其他实例在该实例处理其间可能会有新的commit，所以同一select可能返回不同结果	不会	会产生	会产生
可重复读（repeatable-read）该隔离级别保证了在同一个事务中多次读取同样记录,结果是一致的安全性较高，效率较好是MySQL默认隔离级别	不会	不会	会产生
串行化（serializable）事务之间以一种串行的方式执行安全性非常高，但是效率低它通过强制事务排序，使之不可能相互冲突，从而解决幻读问题。简言之，它是在每个读的数据行上加上共享锁。在这个级别，可能导致大量的超时现象和锁竞争读写数据都会锁住整张表	不会	不会	不会

mysql默认的事务隔离级别为repeatable-read
对于多数应用程序，可以优先考虑把数据库系统的隔离级别设为Read Committed，它能够避免脏读取，而且具有较好的并发性能。
隔离级别越高，越能保证数据的完整性和一致性，但是对并发性能的影响也越大

隔离级别与并发性能的关系图

锁机制

锁是计算机协调多个进程或线程并发访问某一资源的机制。
锁保证数据并发访问的一致性、有效性；锁冲突也是影响数据库并发性能的一个重要因素。
锁是mysql在服务层和存储引擎层的并发控制。
加锁是消耗资源的，锁的各种操作，包括获得锁、检测锁是否已解除、释放锁等

分类：

1.按照锁的互斥程度来划分<br />        共享锁**S**锁（读锁）：其他事务可以读，但不能写，可以提高读并发。多个用户可以同时读，但是不能允许有人修改<br />        排他锁**X**锁（写锁）：其他事务不可以读取，也不能写，一个锁在某一时刻只能被一个线程占有，其它线程必须等待锁被释放之后才可能获取到锁。任何时候只能由一个用户写入资源<br />    2.按照锁的粒度来分<br />        行锁：记录锁、间隙锁、临键锁、插入意向锁，行锁能大大减少数据库操作的冲突。其加锁粒度最小，但加锁的开销也最大。有可能会出现死锁的情况<br />        表锁：意向锁、自增锁，资源开销比行锁少，不会出现死锁的情况，锁粒度大，发生锁冲突的概率很大<br />        页锁 ：锁的粒度介于行级锁和表级锁中间的一种锁，所能提供的并发处理能力也同样介于两者之间，可能死锁的情况。

死锁

指两个事务或者多个事务在同一资源上互相占用，并请求对方所占用的i资源，从而造成恶性循环的现象
当两个事务同时执行，一个锁住了主键索引，在等待其他相关索引。另一个锁定了非主键索引，在等待主键索引。这样就会发生死锁。
产生原因
1.系统资源不足2.进程运行推进的顺序不当3.资源分配不当
产生死锁的四个必要条件
1.互斥条件：一个资源只能被一个进程使用
2.请求和保持条件：进行获得一定资源，又对其他资源发起了请求，但是其他资源被其他线程占用，请求阻塞，但是也不会释放自己占用的资源
3.不可剥夺条件：指进程所获得的资源，不可能被其他进程剥夺，只能自己释放
4.环路等待条件：进程发生死锁，必然存在进程-资源之间的环形链
处理死锁的方法
预防、避免、检测、解除死锁
Mysql的InnoDB ：死锁发生以后，只有部分或完全回滚其中一个事务，才能打破死锁，将持有最少行级排他锁的事务进行回滚

避免死锁

核心思想：系统对进程发出每一个资源申请进行动态检查，并根据检测结果决定是否分配资源，如果配合后系统可能发生死锁，则不予分配，否则予以分配。是保证系统不进入不安全或者死锁状态的动态策略
1.加锁顺序：对所有的资源加上序号，确保所有的线程都是按照相同的顺序获得锁
2.获取锁的请求加一个超时时间，这就意味着在尝试获取锁的过程中若超过了这个时限该线程则放弃对该锁请求，同时放弃掉自己已经成功获得的所有资源的锁，然后等待一段随机的时间再重试
3.死锁的提前检测，银行家算法银行家算法思想：
在进程首次申请资源时，要测试该进程对资源的最大需求量，如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。当进程在执行中继续申请资源时，先测试该资源进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量，如果超过则拒绝分配，如果没有超过则再测试系统现存的资源能否，满足该进程尚需的最大资源量，如果能满足则按当前的申请量分配资源，否则也要推迟分配

预防死锁

主要时通过设置某些外部条件去破环死锁产生的四个必要条件中的一个或者几个
破环互斥条件，一般不采用，资源的互斥性有时候是我们需要的
破环请求和保持条件：可以一次性为一个进程或者线程分配它所需要的全部资源，这样在后面就不会发起请求资源的情况，但是这样资源的利用效率很低
破环不可剥夺条件：当一个已保持了某些不可剥夺资源的进程，请求新的资源而得不到满足时，它必须释放已经保持的所有字眼，待以后需要时再重新申请，但是释放已获得的资源可能造成前一阶段工作的失效，反复申请和释放资源会增加系统开下，降低系统吞吐量
破环循环等地啊条件：可采用顺序资源分配法。

乐观锁和悲观锁

乐观锁(Optimistic Lock)：
假设不会发生并发冲突，只在提交操作时检查是否违反数据完整性，是一种在最后提交的时候检测冲突的手段
是在应用系统层面和数据的业务逻辑层次上（实际上并没有加锁）
实现大部分是基于版本控制系统的
乐观锁不能解决脏读的问题。
悲观锁(Pessimistic Lock)：
假定会发生并发冲突，屏蔽一切可能违反数据完整性的操作，是一种避免冲突的手段
在数据库中可以使用可重复度来减小悲观锁
开销较大，而且加锁时间较长，对于并发的访问性支持不好
乐观锁和悲观锁之间进行选择的标准：
发生冲突的频率和严重性冲突很少，或者冲突的结果不会太严重，选择乐观锁，它能得到更好的并发性
冲突多或者冲突的结果对于用户来说痛苦的，就需要使用悲观锁，能够避免冲突的发售那个

加锁协议

在运用X锁和S锁对数据对象加锁时，还需要约定一些规则，这些规则未封锁协议（Locking Protocol）。
对封锁方式规定不同的规则，就形成了个字节不同的封锁协议。不同的封锁协议，在不同程度上为并发操作的正确调度提供一定的保证

一级封锁协议

事务T在修改数据R之间必须先对其加X锁（写锁，排他锁），直到事务结束才释放。
事务结束包括正常结束（COMMIT）和非正常结束（ROLLBACK)
一级封锁协议可以防止丢失修改，并保证事务T是可以恢复的。使用一级封锁协议可以解决丢失修改问题。
在一级封锁协议中，如果仅仅是读数据不对其进行修改，是不需要加锁的，它不能保证可重复度和不读‘脏’数据

二级封锁协议

二级封锁协议加上事务T在读取数据R之前必须先对其加上S锁，读完之后才可释放S锁（读锁，共享锁）
二级封锁协议除了防止丢失修改，还可以进一步防止读‘脏’数据。单子二级封锁协议中，由于读完数据后即可释放S锁，所欲不能保证可重复读

三级封锁协议

三级封锁协议加上事务T在读取数据R之前必须先对其加S锁，直到事务结束后才释放
三级封锁协议除了防止丢失修改和不读脏数据外，还进一步防止了不可重复读SQL语句

DDL：数据定义语句，数据库、表、列、索引、存储过程等操作，主要由create、alter、drop和truncate（删除，truncate只删除数据不删除表的结构(定义)，释放空间）四个关键字完成
DML：数据管理语言，增删改查数据等操作，主要由insert、update和delete三个关键字完成
DCL：数据控制语言，用户权限访问控制等操作，主要由grant和revoke两个关键字完成事务控制语句：主要由commit、rollback和savepoint 三个关键字完成查询语句：主要由select 关键字完成，查询语句是SQL 语句中最复杂、功能最丰富的语句

多版本并发控制

MVCC Multi-Version Concurrency Control多版本并发控制系统
MVCC是一种并发控制的方法，一般在数据库管理系统中，实现对数据库的并发访问
在mysql中，MyISQM使用的是表锁，InnoDB使用的是行锁。

二、初识SQL语句

[root@localhost ~]# mysql --help
mysql  Ver 15.1 Distrib 5.5.60-MariaDB, for Linux (x86_64) using readline 5.1
Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab and others.

Usage: mysql [OPTIONS] [database]

Default options are read from the following files in the given order:
/etc/mysql/my.cnf /etc/my.cnf ~/.my.cnf 
The following groups are read: mysql client client-server client-mariadb

常用选项

-u：user 指定登录用户
-p：password 指定登录用户密码
-h：host 指定登录主机 127.0.0.1代表本地主机 x.x.x.x 代表远程主机默认：本地主机
-P：port 指定数据库连接端口号默认： 3306
-e：excute 指定sql语句
-D：Database 指定数据库

[root@localhost ~]# mysql -uroot -p1   # 使用root用户 密码为1登录mysql
Welcome to the MariaDB monitor.  Commands end with ; or \g.
Your MariaDB connection id is 3
Server version: 5.5.60-MariaDB MariaDB Server

Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab and others.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.
MariaDB [(none)]>      # 查询当前用户
+----------------+
| user()         |
+----------------+
| root@localhost |
+----------------+
1 row in set (0.00 sec)

修改密码：

set password = password (‘2’); #修改当前用户的密码为2

创建用户：

MariaDB [(none)]> help create user;   #帮助的语法，前面加help
Name: 'CREATE USER'
Description:
Syntax:
CREATE USER user_specification
    [, user_specification] ...

user_specification:
    user
    [
        IDENTIFIED BY [PASSWORD] 'password'
      | IDENTIFIED WITH auth_plugin [AS 'auth_string']
    ]

1.创建用户

create user 'hh'@'%' identified by '1';  #创建一个名为lh密码为1的用户，%代表这个账户可以在任何主机登录
CREATE USER 'jeffrey'@'localhost' IDENTIFIED BY 'mypass';    #指定用户 
CREATE USER 'jeffrey'@'%' IDENTIFIED BY 'mypass';     #指定所有
CREATE USER 'jeffrey'@'192.168.10.0' IDENTIFIED BY 'mypass'  #指定地址段     
CREATE USER 'jeffrey'@'192.168.10.10' IDENTIFIED BY 'mypass';  #指定ip地址

2.授权操作：

[peivillege1,privillege2……]
```
grant all privileges on *.* to 'hh'@'%';
```

3.刷新使授权立即生效

flush privileges;

create user [username]@'%' identified by '[password]';  创建用户 
grant all privileges on *.* to 'username'@'%';  授权
等同于：
grant all privileges on *.* to 'username'@'%' identified by '[passwd]';
先创建用户，再授权

注意：
- 要关闭防火墙
- 要关闭 selinux

[root@localhost ~]# systemctl stop firewalld
[root@localhost ~]# getenforce  # 查看selinux 的状态
Disabled

三、SQL语句：

DDL语句：数据定义语句，数据库、表、列、索引、存储过程等操作.主要由create（添加）、alter（修改）、drop（删除）和 truncate（删除）四个关键字完成。
DDL操作是隐性提交的！不能rollback**DML语句**：数据管理语句增删改查数据等操作。主要由insert（插入）、update（更新）、delete（删除）三个关键字完成。
DCL语句：数据控制语句用户权限访问控制等操作。主要由grant（授权）、rollback（回滚）、commit（提交）三个关键字完成。
DQL语句：数据查询语言，数据查询语言DQL基本结构是由SELECT子句，FROM子句，WHERE子句组成的查询块：

操作数据库：

增：create database [create_specification]

[create_specification] eg：CREATE DATABASE lh ;

查：show databases;
改：alter database lh charset utf8; #改字符编码方式
删除：drop database lh;

操作表

创建表
语法：
create table tablename（
filedname1 数据类型（宽度）[ 约束条件]，
filedname2 数据类型（宽度）[ 约束条件]，
filedname3 数据类型（宽度）[ 约束条件]，
)
ps：1.在同一个表中，字段名不能相同
2.宽度和约束都是可选项
3.字段名和数据类型必须要有

复制表
1.只复制表结构及约束，但不复制数据

 create table ccy2 like ccy;

2.复制表结构及数据，但不复制约束

create table ccy3 as select * from ccy;

插入数据

insert

insert into tablename (xxx,xxx);
insert into ccc values(1,’sss’);插入语句

1.插入完整数

insert into tablename (field1,field2,....) values(value1,value2,...)
insert into tablename values(value1,value2,...)
insert into ccc values(1,'sss');插入语句

2.指定字段插数据

 insert into ccy (lll,brith) values('kjjj','1999-11-9');

3.插入多条数据

insert into tablename values(value1,value2...),(value1,value2...)
insert into ccy values(2,'lars','b','dd','1999.2.9'),(3,'dd','boy','ss','1998-8-10');

4.插入查询结果

insert into tablename (field1,field2....) select (field1,field2...)
    from tablename2 where ....

load data

#创建一个文本文件
[root@node5 ~]# vim 3.txt

1       gyon    boy     \N      1998-19-9
#对于缺少的值可以用 \N（反斜杠，大写N） 来表示
#加载文件到数据库中
MariaDB [mxh]>  load data local infile '3.txt' into table ccy;
Query OK, 1 row affected, 2 warnings (0.00 sec)      
Records: 1  Deleted: 0  Skipped: 0  Warnings: 2

MariaDB [mxh]> select * from ccy;
+------+------+------+-----+-----------+
| id   | name | sex  | lll | brith     |
+------+------+------+-----+-----------+
|    1 | gggg | NULL |     |           |
|    1 | gyon | b    | l   | 1998-19-9 |
|    1 | gyon | b    |     | 1998-19-9 |
+------+------+------+-----+-----------+
3 rows in set (0.00 sec)

修改表结构 alter

1.添加字段

alter table 表名称 add 字段名字段约束

2.添加索引

ALTER TABLE 表名称 ADD INDEX 索引名称 (字段名)

3.添加主键

ALTER TABLE 表名称 ADD PRIMARY KEY (字段名)
ALTER TABLE 表名称 ADD UNIQUE KEY (字段名)

4.添加外键约束

--eg中a表就是另一张表，sno就是a表中有唯一约束的那一列
语法：
create table 表名(
字段名 char foreign key references
另一张表名(另一张表中的有唯一约束的字段)
--唯一约束：primary key、unique
)
eg:
create table b(
sno char foreign key references a(sno)
)

5.修改字段类型

ps：注意字段类型的兼容性及精度，除非该列全部数据为null
ALTER TABLE 表名称 CHANGE NAME 修改字段修改为字段类型

MariaDB [mxh]> alter table employee rename ccy;
Query OK, 0 rows affected (0.00 sec)

ALTER TABLE 表名称 MODIFY 修改字段修改为字段类型

MariaDB [mxh]> alter table ccy modify name char(10);
Query OK, 6 rows affected (1.81 sec)               
Records: 6  Duplicates: 0  Warnings: 0

6.禁用和启用约束

ALTER TABLE 表名称 DISABLE KEYS #禁用约束
ALTER TABLE 表名称 ENABLE KEYS #启用约束

7.删除表字段、主键、索引、外键约束

alter table tablename drop fieldname
ALTER TABLE 表名称 DROP PRIMARY KEY //删除主键
ALTER TABLE 表名称 DROP INDEX 索引的字段名 //删除索引
ALTER TABLE 表名称 DROP FOREIGN KEY 外键的字段名 //删除外键约束

8.修改表名

ALTER TABLE 修改前表名称 RENAME 修改后表名称

更新数据

update t1 set id=2 where usename=‘k’；

删除数据

删：delete from t1 where id =2；#这个操作会很慢
清空表：
delete from t1 #如果有自增id，增加的数据，仍然是以删除前的最后一样作为起始
truncate table t1 #数据量大，删除速度比上一条快，且直接从零开始

truncate 与drop的区别：
truncate只删除数据不删除表的结构(定义)，释放空间

查询数据

• 查询所有  ：select * from employee
• 查询指定字段：select employee.id,employee.emp_name from employee
• 关键词  ： DISTINCT 去除重复记录
• select DISTINCT post from employee
• 四则运算： 
• select emy_name,age-18 as new_age from employee

语法的优先级

from
where 分组之前的过滤条件
group by 分组依据
having 分组之后的过滤条件
order by 排序字段
limit 显示的条数

1.找表 from
2.用where指定的条件，去表中一条条的取数据
3.将去除的数据进行group by，如果没有group by，则整体作为一组
4.执行select操作
5.将分组的结果通过having过滤
6.将结果按条件进行排序：order by
7.限制结果的显示条数

where：条件

1.支持比较运算符：大于、小于、等于、不等于
2.支持逻辑运算符 and or not
3.in(list) eg：in（value1，value2）值是value1或value
4.支持通配符 like %代表任意多个字符代表一个字符
b% 以b开头的内容
%fy 以by结尾的内容
%w% 查找包含的名称w
_ 要查找正好包含2个字符的名称

MariaDB [mxh]> select * from ccy where id like'%1';  #LIKE模糊查询
+------+------+------+-----+-----------+
| id   | name | sex  | lll | brith     |
+------+------+------+-----+-----------+
|    1 | gggg | NULL |     |           |
|    1 | gyon | b    | l   | 1998-19-9 |
|    1 | gyon | b    |     | 1998-19-9 |
+------+------+------+-----+-----------+
• 关键字IS NULL 查询：
• select emp_name,post,salary from employee where post_comment IS NULL
MariaDB [mxh]> select *from ccy where name like'__';
+----+------+------------+------------+--------+
| id | name | brith      | go         | sex    |
+----+------+------------+------------+--------+
|  1 | mj   | 1991-01-09 | 2018-11-02 | male   |
|  5 | cc   | 1992-02-04 | 2020-03-04 | female |
+----+------+------------+------------+--------+

1点.匹配任何单个字符
2字符类[……] 与方括号内的任何字符匹配。eg：[abc]匹配a， b或c。要命名字符范围，请使用破折号。[a-z] 匹配任何字母，而[0-9] 匹配任何数字
3 匹配零个或多个其前面的实例。例如，x 匹配任意数量的x字符， [0-9]匹配任意数量的数字，以及.任意数量的任何东西。
4.锚定的图案，使得它必须使用匹配的值的开头或结尾正在测试中，^在开始时或$在图案的端部

单条件查询：
- eg:select emp_name,post from employee where post =’sale’
多条件查询：
- eg:select emp_name,post,salary from employee where post=’sale’ and salary >500
关键字BETWEEN AND/NOT BETWEEN AND 查询：
关键字IS NULL 查询：
- select emp_name,post,salary from employee where post_comment IS NULL
关键字IN/NOT IN集合查询：
关键字LIKE模糊查询：
group by：关键字分组

如果分组的字段是post，那么select查询的字段只能是post，想要获取组内其他信息需要借助函数、
如果使用unique
多条记录之间有有规字段值相同，该字段通常作为分组的依据

MariaDB [mxh]> select sex, count(*) from ccy group by sex;
+--------+----------+
| sex    | count(*) |
+--------+----------+
| NULL   |        1 |
| male   |        4 |
| female |        1 |
+--------+----------+
MariaDB [mxh]> SELECT name, brith, CURDATE(),TIMESTAMPDIFF(YEAR,brith,CURDATE()) AS age FROM ccy ORDER BY brith; 
+------+------------+------------+------+
| name | brith      | CURDATE()  | age  |
+------+------------+------------+------+
| NULL | NULL       | 2020-04-11 | NULL |
| mj   | 1991-01-09 | 2020-04-11 |   29 |
| cc   | 1992-02-04 | 2020-04-11 |   28 |
| gyon | 1997-05-10 | 2020-04-11 |   22 |
| ccy  | 1998-01-14 | 2020-04-11 |   22 |
| lars | 1999-04-13 | 2020-04-11 |   20 |
+------+------------+------------+------+

聚合函数

聚合函数聚合的是组的内容，若没有分组，则默认一组

selsct count（1）from employee #建议使用1

eg:

# TIMESTAMPDIFF()的参数是要表示结果的单位，以及两个日期之间的差值
MariaDB [mxh]> SELECT name, brith, CURDATE(),TIMESTAMPDIFF(YEAR,brith,CURDATE()) AS age FROM ccy;
+------+------------+------------+------+
| name | brith      | CURDATE()  | age  |
+------+------------+------------+------+
| mj   | 1991-01-09 | 2020-04-11 |   29 |
| ccy  | 1998-01-14 | 2020-04-11 |   22 |
| lars | 1999-04-13 | 2020-04-11 |   20 |
| gyon | 1997-05-10 | 2020-04-11 |   22 |
| cc   | 1992-02-04 | 2020-04-11 |   28 |
| NULL | NULL       | 2020-04-11 | NULL |
+------+------------+------------+------+
6 rows in set (0.00 sec)
#COUNT(*)计算行数
MariaDB [mxh]> select count(*) from ccy;
+----------+
| count(*) |
+----------+
|        6 |
+----------+
MariaDB [mxh]> select name, count(*) from ccy;
+------+----------+
| name | count(*) |
+------+----------+
| mj   |        6 |
+------+----------+
MariaDB [mxh]> select mj.hobby,ccy.brith  from mj right  join ccy on mj.name=ccy.name ; 
+---------+------------+
| hobby   | brith      |
+---------+------------+
| mmmmm   | 1991-01-09 |
| cccccc  | 1998-01-14 |
| lllllll | 1999-04-13 |
| ggggggg | 1997-05-10 |
| hhhh    | 1992-02-04 |
| NULL    | NULL       |
+---------+------------+

having过滤

执行的优先级：

where >group>having

where发生在分组前，having发生在分组后，因此where是任意字段（不要使用内聚函数），having是分组中的字段

order by 排序

ASC：正序

DESC：反序

MariaDB [mxh]> SELECT name, brith FROM ccy ORDER BY brith;
+------+------------+
| name | brith      |
+------+------------+
| gggg | 0000-00-00 |
| gyon | 0000-00-00 |
| gyon | 0000-00-00 |
| dd   | 1998-08-10 |
| NULL | 1999-11-09 |
+------+------------+
5 rows in set (0.00 sec)

MariaDB [mxh]> SELECT name, brith FROM ccy ORDER BY brith DESC;
+------+------------+
| name | brith      |
+------+------------+
| NULL | 1999-11-09 |
| dd   | 1998-08-10 |
| gggg | 0000-00-00 |
| gyon | 0000-00-00 |
| gyon | 0000-00-00 |
+------+------------+

limit 显示有限行

MariaDB [mxh]> SELECT article, dealer, price
    -> FROM shop
    -> ORDER BY price DESC
    -> LIMIT 1;
+---------+--------+-------+
| article | dealer | price |
+---------+--------+-------+
|       4 | D      | 19.95 |
+---------+--------+-------+

多表查询

1.交叉链接

不适合任何匹配条件，会生成一个笛卡尔积（会有错误数据，基本不用）

2.内连接查询

在交叉连接的基础上，使用外键约束作为查询条件

隐式内连接:
         select * from 表A , 表B where A.主键 = B . 主键

显示外连接:
         select * from 表A [inner] join 表B on A.主键 = B.主键
         on后面可以继续使用where条件查询
MariaDB [mxh]> select * from mj inner join ccy on mj.name=ccy.name ;
+------+------+---------+----+------+------------+------------+--------+
| id   | name | hobby   | id | name | brith      | go         | sex    |
+------+------+---------+----+------+------------+------------+--------+
|    1 | mj   | mmmmm   |  1 | mj   | 1991-01-09 | 2018-11-02 | male   |
|    2 | ccy  | cccccc  |  2 | ccy  | 1998-01-14 | 2020-04-10 | male   |
|    3 | lars | lllllll |  3 | lars | 1999-04-13 | 2020-06-01 | male   |
|    4 | gyon | ggggggg |  4 | gyon | 1997-05-10 | 2020-05-30 | male   |
|    5 | cc   | hhhh    |  5 | cc   | 1992-02-04 | 2020-03-04 | female |
+------+------+---------+----+------+------------+------------+--------+
5 rows in set (0.00 sec)

3.外链接

在交叉连接的基础上 , 使用外键约束作为查询条件.

select 字段列表 from t1 inner | left | right t2 on t1.field =t2.field
- - left：左连接以左为主，先显示左表，让右表通过匹配字段连接
  - right：右连接以右为主，先显示右表，让左表通过匹配字段连接
  - 为空用NULL填充

MariaDB [mxh]> select * from mj left  join ccy on mj.name=ccy.name ;
+------+------+---------+------+------+------------+------------+--------+
| id   | name | hobby   | id   | name | brith      | go         | sex    |
+------+------+---------+------+------+------------+------------+--------+
|    1 | mj   | mmmmm   |    1 | mj   | 1991-01-09 | 2018-11-02 | male   |
|    2 | ccy  | cccccc  |    2 | ccy  | 1998-01-14 | 2020-04-10 | male   |
|    3 | lars | lllllll |    3 | lars | 1999-04-13 | 2020-06-01 | male   |
|    4 | gyon | ggggggg |    4 | gyon | 1997-05-10 | 2020-05-30 | male   |
|    5 | cc   | hhhh    |    5 | cc   | 1992-02-04 | 2020-03-04 | female |
+------+------+---------+------+------+------------+------------+--------+
5 rows in set (0.00 sec)
MariaDB [mxh]> select * from mj right  join ccy on mj.name=ccy.name ;
+------+------+---------+----+------+------------+------------+--------+
| id   | name | hobby   | id | name | brith      | go         | sex    |
+------+------+---------+----+------+------------+------------+--------+
|    1 | mj   | mmmmm   |  1 | mj   | 1991-01-09 | 2018-11-02 | male   |
|    2 | ccy  | cccccc  |  2 | ccy  | 1998-01-14 | 2020-04-10 | male   |
|    3 | lars | lllllll |  3 | lars | 1999-04-13 | 2020-06-01 | male   |
|    4 | gyon | ggggggg |  4 | gyon | 1997-05-10 | 2020-05-30 | male   |
|    5 | cc   | hhhh    |  5 | cc   | 1992-02-04 | 2020-03-04 | female |
| NULL | NULL | NULL    |  6 | NULL | NULL       | NULL       | NULL   |
+------+------+---------+----+------+------------+------------+--------+
MariaDB [mxh]> select mj.hobby,ccy.brith  from mj right  join ccy on mj.name=ccy.name ; 
+---------+------------+
| hobby   | brith      |
+---------+------------+
| mmmmm   | 1991-01-09 |
| cccccc  | 1998-01-14 |
| lllllll | 1999-04-13 |
| ggggggg | 1997-05-10 |
| hhhh    | 1992-02-04 |
| NULL    | NULL       |
+---------+------------+

4.子查询

1.嵌套

2.内层查询语句的查询结果可以作为外层查询语句提高查询条件

3.子查询中可以包含：IN NOT ANY……

4.还可以包含比较运算符：><=……

带IN关键字的子查询
带比较运算符的子查询
带EXSTS关键字的子查询

一条select语句结果作为另一条select语句的（查询条件，查询结果等）。
a.子查询作为查询条件:
         select * from表B where 字段 = (select 字段 from 表A [where 条件])
b.子查询作为另一张表: (内连接)
        select * from 表B,(select * from 表A [where 条件])
        where A.主键 = B.外键;

MariaDB [mxh]> select mj.hobby,ccy.brith  from mj right  join ccy on mj.name=ccy.name =(select hobby from mj where hobby='hhhh') ;
+---------+------------+
| hobby   | brith      |
+---------+------------+
| mmmmm   | 1998-01-14 |
| mmmmm   | 1999-04-13 |
| mmmmm   | 1997-05-10 |
| mmmmm   | 1992-02-04 |
| cccccc  | 1991-01-09 |
| cccccc  | 1999-04-13 |
| cccccc  | 1997-05-10 |
| cccccc  | 1992-02-04 |
| lllllll | 1991-01-09 |
| lllllll | 1998-01-14 |
| lllllll | 1997-05-10 |
| lllllll | 1992-02-04 |
| ggggggg | 1991-01-09 |
| ggggggg | 1998-01-14 |
| ggggggg | 1999-04-13 |
| ggggggg | 1992-02-04 |
| hhhh    | 1991-01-09 |
| hhhh    | 1998-01-14 |
| hhhh    | 1999-04-13 |
| hhhh    | 1997-05-10 |
| NULL    | NULL       |
+---------+------------+

常见的查询

1.求列的最大值

MariaDB [mxh]> select max(article)as article from shop;
+---------+
| article |
+---------+
|       4 |
+---------+
1 row in set (0.00 sec)

2.保留某列最大值的行

MariaDB [mxh]> SELECT article, dealer, price
    -> FROM shop
    -> ORDER BY price DESC
    -> LIMIT 1;
+---------+--------+-------+
| article | dealer | price |
+---------+--------+-------+
|       4 | D      | 19.95 |
+---------+--------+-------+

MariaDB [mxh]> SELECT s1.article, s1.dealer, s1.price
    -> FROM shop s1
    -> LEFT JOIN shop s2 ON s1.price < s2.price
    -> WHERE s2.article IS NULL;
+---------+--------+-------+
| article | dealer | price |
+---------+--------+-------+
|       4 | D      | 19.95 |
+---------+--------+-------+

3.每组最大列数

MariaDB [mxh]> select article ,max(price) as price
    -> from shop
    -> group by article
    -> order by article;
+---------+-------+
| article | price |
+---------+-------+
|       1 |  3.99 |
|       2 | 10.99 |
|       3 |  1.69 |
|       4 | 19.95 |
+---------+-------+

4.保持某一列的分组最大值的行

MariaDB [mxh]> select article,dealer,price
    -> from shop s1
    -> where price=(select max(s2.price) from shop s2 where s1.article=s2.article)
    -> order by article;
+---------+--------+-------+
| article | dealer | price |
+---------+--------+-------+
|       1 | B      |  3.99 |
|       2 | A      | 10.99 |
|       3 | C      |  1.69 |
|       4 | D      | 19.95 |
+---------+--------+-------+

查看表结构

1.describle ; #表的信息

MariaDB [mxh]> desc ccy;
+-------+-------------+------+-----+---------+-------+
| Field | Type        | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+-------+
| id    | int(11)     | YES  |     | NULL    |       |
| name  | varchar(15) | YES  |     | NULL    |       |
| sex   | char(1)     | YES  |     | NULL    |       |
| lll   | char(1)     | NO   |     | NULL    |       |
+-------+-------------+------+-----+---------+-------+

2.show create table [tablename]; #更全面的表定义信息

MariaDB [mxh]> show create table ccy;
+-------+----------------------------------------------------------------------------------------------------------------------------------------------------------+
| Table | Create Table                                                                                                                                             |
+-------+----------------------------------------------------------------------------------------------------------------------------------------------------------+
| ccy   | CREATE TABLE `ccy` (
  `id` int(11) DEFAULT NULL,
  `name` varchar(15) DEFAULT NULL,
  `sex` char(1) DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1 |
+-------+----------------------------------------------------------------------------------------------------------------------------------------------------------+

流程控制

case

case value 或者 case when

ifnull

IFNULL(expr1, expr2)

如果 expr1 为 NULL，则 IFNULL() 的返回值为 expr2；否则其返回值为 expr1 。

nullif

NULLIF(expr1, expr2)

如果 expr1 等于 expr2 成立，那么返回值为 NULL ；否则，返回值为 expr1 。

出现的错误

一.

[root@node5 ~]# mysql 
ERROR 1045 (28000): Access denied for user 'root'@'localhost' (using password: NO)

这个错误是密码错误引起的，需要重置密码
1.跳过MYSQL的密码认证过程

[root@node5 ~]# cd /etc
[root@node5 etc]# vim my.cnf

在[mysql]后面任意一行添加“skip-grant-tables”用来跳过密码验证的过程，修改保存并退出
2.重启mysql
[root@node5 etc]# systemctl restart mariadb
3.输入mysql进入mysql

[root@node5 etc]# mysql
Welcome to the MariaDB monitor.  Commands end with ; or \g.
Your MariaDB connection id is 2
Server version: 5.5.64-MariaDB MariaDB Server

Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab and others.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

MariaDB [(none)]>

4.用sql修改root密码
进入终端，输入mysql -u root -p 命令然后回车，当需要输入命令时候，直接enter键，可以不使用密码登录到数据库中

MariaDB [(none)]> set password=password("123456") ;
ERROR 1290 (HY000): The MariaDB server is running with the --skip-grant-tables option so it cannot execute this statement
MariaDB [(none)]> flush privileges;
Query OK, 0 rows affected (0.00 sec)

MariaDB [(none)]> quit

如果在执行该步骤的时候出现ERROR 1290 (HY000): The MySQL server is running with the --skip-grant-tables option so it cannot execute this statement 错误。则执行下 flush privileges 命令，再执行该命令即可

5.编辑my.cnf,把之前加进入的内容删除，就可以了

[root@node5 etc]# mysql -u root -p
Enter password: 
Welcome to the MariaDB monitor.  Commands end with ; or \g.
Your MariaDB connection id is 7
Server version: 5.5.64-MariaDB MariaDB Server

Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab and others.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

MariaDB [(none)]> exit
Bye

二、

ERROR 1060 (42S21): Duplicate column name ‘sex’ 列名重复

存储引擎

存储引擎介绍：

MySQL的数据用不同的存储技术存储文件，不同的技术拥有不同的存储机制、索引技巧、锁定水平、通过选择不同的技术获得不同的功能，以适应不同的应用场景，而这些不同的技术和功能就是存储引擎（也称做表引擎）

1.存储引擎分类

MySQL支持的存储引擎：

InnoDB、MyISAM、MEMORY、CSV、BLACKHOLE、FEDERATED、MRG_MYISAM、 ARCHIVE、 PERFORMANCE_SCHEMA。其中NDB和InnoDB提供事务安全表，其他存储引擎都是非事务安全表。

MySQL服务采用多层设计和独立、插件式存储引擎体系结构，允许将存储引擎加载到正在运行的新MySQL服务中

InnoDB：

     - 是一个事务安全的存储引擎<br />
     - 默认的存储引擎，具备提交、回滚、崩溃恢复的功能
     - 支持行级别锁定和一致性无锁读来提升多用户的并发和性能
     - 用户数据存储子聚集索引中来减少普通查询所带来的IO开销
     - 支持外键约束
     - 应用场景：并发性高、数据一致性、更新和删除操作比较多，事务的完成和回滚

MYSAM：

     - 表级别的锁定，不支持事务，也不支持外键
     - 应用场景：读操作为主，多读少写
     - 优势：访问速度快

Memory：

     - 优点：表访问数据非常快<br />
     - 将所有数据存在内存中，并且默认使用HASH索引，服务一旦关闭数据就会丢失
     - 应用场景：对非关键数据的快速查找的场景

BLACKHOLE

     - 只接收但是不保存数据。
     - 对这种引擎的表的查询常常返回一个空集
     - 可以应用DML语句需要发送到从服务器，但主服务器并不会保留这种数据的备份的主从配置中。

CVS：

     - 它的表以逗号为分隔符的文件，
     - 允许cvs格式导入导出数据，以相同的读和写的格式和脚本和应用交互数据。
     - 没有索引，最好在普通操作中将数据放在InnoDB表里，只有在导入和导出阶段使用一下CSV表<br />

NDB

     - 集群数据引擎
     - 适合于需要最高程度的正常运行时间和可用性的应用
     - ps：在mysql的5.6版本里不被支持

Merge

     - 适用于超大规模数据场景，如数据仓库

Federated

     - 提供了从多个物理机上联机不同的mysql服务器来创建一个逻辑数据库的能力。适用于分布式或者数据市场的场景

Example

     - 用于保存阐明如何开始写新的存储引擎的MySQL源码的例子。
     - 可以使用这种存储引擎创建表，但是无法向其保存任何数据，也无法从它们中检索任何索引。

2.存储引擎相关的sql语句

MariaDB [lh]> show variables like "default_storage_engine";   #查询默认的存储引擎：
+------------------------+--------+
| Variable_name          | Value  |
+------------------------+--------+
| default_storage_engine | InnoDB |
+------------------------+--------+
1 row in set (0.00 sec)show  VARIABLEAS like "default_storage_engine"
MariaDB [lh]> show engines \G;     #  查询当前数据库支持的存储引擎：
*************************** 1. row ***************************
      Engine: MEMORY
     Support: YES
     Comment: Hash based, stored in memory, useful for temporary tables
Transactions: NO
          XA: NO
  Savepoints: NO
*************************** 2. row ***************************
      Engine: MRG_MYISAM
     Support: YES
     Comment: Collection of identical MyISAM tables
Transactions: NO
          XA: NO
  Savepoints: NO
*************************** 3. row ***************************
      Engine: CSV
     Support: YES
     Comment: CSV storage engine
Transactions: NO
          XA: NO
  Savepoints: NO
*************************** 4. row ***************************
      Engine: BLACKHOLE
     Support: YES
     Comment: /dev/null storage engine (anything you write to it disappears)
Transactions: NO
          XA: NO
  Savepoints: NO
*************************** 5. row ***************************
      Engine: MyISAM
     Support: YES
     Comment: MyISAM storage engine
Transactions: NO
          XA: NO
  Savepoints: NO
*************************** 6. row ***************************
      Engine: InnoDB
     Support: DEFAULT
     Comment: Percona-XtraDB, Supports transactions, row-level locking, and foreign keys
Transactions: YES
          XA: YES
  Savepoints: YES
*************************** 7. row ***************************
      Engine: ARCHIVE
     Support: YES
     Comment: Archive storage engine
Transactions: NO
          XA: NO
  Savepoints: NO
*************************** 8. row ***************************
      Engine: FEDERATED
     Support: YES
     Comment: FederatedX pluggable storage engine
Transactions: YES
          XA: NO
  Savepoints: YES
*************************** 9. row ***************************
      Engine: PERFORMANCE_SCHEMA
     Support: YES
     Comment: Performance Schema
Transactions: NO
          XA: NO
  Savepoints: NO
*************************** 10. row ***************************
      Engine: Aria
     Support: YES
     Comment: Crash-safe tables with MyISAM heritage
Transactions: NO
          XA: NO
  Savepoints: NO
10 rows in set (0.00 sec)

ERROR: No query specified

指定存储引擎：

1.创建表的时候指定存储引擎：
- create table t2 (id int ,name char) engine=MyISAM;
2.修改一个已经存在的表的存储引擎：
- alter table t1 engine=MYISAM;
1. 修改/etc/my.cnf 配置文件:
  - [root@localhost ~]# cat /etc/my.cnf

[mysqld]
default-storage-engine=InnoDB（全局修改) #修改后面的内容就修改了

数据备份

备份

mysqldump
语法：mysqldump -h服务器 -u 用 -p 密码数据库名 >备份文件.sql

补充：只备份库和表结构
—no-data
恢复：

日志管理
bin-log 错误日志配置
sql 语句查询日志相关信息 show variables like ‘log%‘；
sql 语句查询二进制日志相关信息 show variables like ‘%bin%’;
跟踪数据执行过程日志 show variables like ‘general%’;

binlog日志操作命令　
查看所有binlog日志列表 show master logs
查看master状态，即最后(最新)一个binlog日志的编号名称，及其最后一个操作事件pos结束点(Position)值 show master status;
刷新log日志，自此刻开始产生一个新编号的binlog日志文件 flush logs;
重置(清空)所有binlog日志 reset master;
binlog 日志存放位置 show variables like ‘%datadir%’

二进制记录格式
row（行模式）：表中行数据的变化过程，记录数据详细，但对IO要求比较高，记录数据在任何情况下都是准确的。生产中一般是这种模式，此模式在5.7以后为默认的模式
statement：语句模式，将SQL语句进行记录。记录信息简洁，记录的是sql语句本身，但是在语句中出现函数操作的话，有可能记录的数据不准确（5.6中默认的模式，在生产环境慎用）
mixed：以上两者的混合模式。经过判断，选择row+statement混合的一种记录模式。一般不用

文件复制原理
主从复制：数据可以从一个MySQL数据库服务器主节点复制到一个或多个从节点。
默认采用异步复制，从节点不用一直访问主服务器来更新自己的数据，数据的更新可以从远程连接上进行，从节点可以复制主数据库中的所有数据库或者特定的数据库，或者特定的表
Mysql 主从复制是mysql 高可用，高性能的基础
原理：
1、从库中生成两个线程，一个I/O线程，一个SQL线程
2、I/O线程会去请求主库中binlog日志，并将得到的binglog写到本地的relay-log（中继日志）文件中主库会生成一个logdump线程，用来给从库数据库传binlog日志3、SQL线程，会读取relay log 文件中的日志，并解析成sql语句逐一执行，使得其数据和主节点的保持一致，最后I/O线程和SQL线程将进入睡眠状态，等待下一次被唤醒。一主一从和一主多从是最常见的主从架构，实施起来简单并且有效，不仅可以实现集群，而且还能读写分离，进而提升集群的并发能力双主复制
双主复制，也就是互做主从复制，每个master既是master，又是另外一台服务器的slave。这样任何一方所做的变更，都会通过复制应用到另外一方的数据库中
优化方案
1.选用最适用的字段属性
2.使用连接代替子查询
3.使用联合代替手动创建的临时表
4.事务
5.锁定表
6.使用外键
7.使用索引
8.使用优化的查询语句
https://blog.csdn.net/liuyanqiangpk/article/details/79827239
https://segmentfault.com/a/1190000021885415
https://segmentfault.com/a/1190000021926738

MySQL