MySQL学习笔记

MySQL连接

使用mysql二进制方式连接

可以使用MySQL二进制方式进入到mysql命令提示符下来连接MySQL数据库。

实例

以下是从命令行中连接mysql服务器的简单实例：

[root@host]# mysql -u root -p
Enter password:******

在登录成功后会出现 mysql> 命令提示窗口，你可以在上面执行任何 SQL 语句。

以上命令执行后，登录成功输出结果如下:

Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 2
Server version: 5.7.24 MySQL Community Server (GPL)
Copyright (c) 2000, 2018, Oracle and/or its affiliates. All rights reserved.
Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.
Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

在以上实例中，我们使用了root用户登录到mysql服务器，当然你也可以使用其他mysql用户登录。

如果用户权限足够，任何用户都可以在mysql的命令提示窗口中进行SQL操作。

退出 mysql> 命令提示窗口可以使用 exit 命令，如下所示：

mysql> exit
Bye

MySQL创建数据库

我们可以在登陆 MySQL 服务后，使用 create 命令创建数据库，语法如下:

CREATE DATABASE [IF NOT EXISTS] 数据库名 [create_specification] [create_specification];

create_specification:

[DEFAULT] CHARACTER SET charset_name

[DEFAULT] COLLATE collation_name

1.CHARACTER SET：指定数据库采用的字符集，如果不指定字符集，默认utf8

2.COLLATE：指定数据库字符集的校对规则（常用的utf8_bin【区分大小写】、utf8_general_ci【不区分大小写】）

以下命令简单的演示了创建数据库的过程，如果数据库不存在则创建采用utf8字符集，校对规则utf8_bin的数据库RUNOOB:

[root@host]# mysql -u root -p   
Enter password:******  # 登录后进入终端

mysql> create DATABASE IF NOT EXISTS RUNOOB CHARACTER SET utf8 COLLATE utf8_bin;

使用 mysqladmin 创建数据库

使用普通用户，你可能需要特定的权限来创建或者删除 MySQL 数据库。

所以我们这边使用root用户登录，root用户拥有最高权限，可以使用 mysql mysqladmin 命令来创建数据库。

以下命令简单的演示了创建数据库的过程，数据库名为 RUNOOB:

[root@host]# mysqladmin -u root -p create RUNOOB
Enter password:******

以上命令执行成功后会创建 MySQL 数据库 RUNOOB。

MySQL 删除数据库

使用普通用户登陆 MySQL 服务器，你可能需要特定的权限来创建或者删除 MySQL 数据库，所以我们这边使用 root 用户登录，root 用户拥有最高权限。

在删除数据库过程中，务必要十分谨慎，因为在执行删除命令后，所有数据将会消失。

drop 命令删除数据库

drop 命令格式：

drop database [IF EXISTS] <数据库名>;

例如删除如果已存在名为 RUNOOB 的数据库：

mysql> drop database [IF EXISTS] RUNOOB;

使用 mysqladmin 删除数据库

你也可以使用 mysql mysqladmin 命令在终端来执行删除命令。

以下实例删除数据库 RUNOOB：

[root@host]# mysqladmin -u root -p drop RUNOOB
Enter password:******

执行以上删除数据库命令后，会出现一个提示框，来确认是否真的删除数据库：

Dropping the database is potentially a very bad thing to do.
Any data stored in the database will be destroyed.
Do you really want to drop the 'RUNOOB' database [y/N] y
Database "RUNOOB" dropped

MySQL管理

管理MySQL的命令

USE 数据库名:

选择要操作的Mysql数据库，使用该命令后所有Mysql命令都只针对该数据库。

mysql> use RUNOOB;
Database changed

SHOW DATABASES:

列出 MySQL 数据库管理系统的数据库列表。

mysql> SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| RUNOOB             |
| mysql              |
| performance_schema |
| sys                |
+--------------------+
10 rows in set (0.02 sec)

SHOW TABLES:

显示指定数据库的所有表，使用该命令前需要使用 use 命令来选择要操作的数据库。

mysql> use RUNOOB;
Database changed
mysql> SHOW TABLES;
+------------------+
| Tables_in_runoob |
+------------------+
| employee_tbl     |
| runoob_tbl       |
| tcount_tbl       |
+------------------+
3 rows in set (0.00 sec)

MySQL备份数据

导出 SQL 格式的数据

导出 SQL 格式的数据到指定文件，如下所示：

$ mysqldump -u root -p -B 数据库1 数据库2 数据库n > 盘符:\\文件名.sql
password ******

该方法可用于实现数据库的备份策略。

source 命令导入

source 命令导入数据库需要先登录到数库终端：

mysql> source 盘符:\\文件名.sql  # 导入备份数据库

MySQL 创建数据表

创建MySQL数据表需要以下信息：

• 表名
• 表字段名
• 定义每个表字段

语法

以下为创建MySQL数据表的SQL通用语法：

CREATE TABLE table_name (column_name column_type);

以下例子中我们将在 RUNOOB 数据库中创建数据表runoob_tbl：

CREATE TABLE IF NOT EXISTS `runoob_tbl`(
   `runoob_id` INT UNSIGNED AUTO_INCREMENT,
   `runoob_title` VARCHAR(100) NOT NULL,
   `runoob_author` VARCHAR(40) NOT NULL,
   `submission_date` DATE,
   PRIMARY KEY ( `runoob_id` )
)ENGINE=InnoDB DEFAULT CHARSET=utf8;

实例解析：

• 如果你不想字段为 NULL 可以设置字段的属性为 NOT NULL， 在操作数据库时如果输入该字段的数据为NULL ，就会报错。

• AUTO_INCREMENT定义列为自增的属性，一般用于主键，数值会自动加1。

• PRIMARY KEY关键字用于定义列为主键。 您可以使用多列来定义主键，列间以逗号分隔。

• ENGINE 设置存储引擎，CHARSET 设置编码。

通过命令提示符创建表

通过 mysql> 命令窗口可以很简单的创建MySQL数据表。你可以使用 SQL 语句 CREATE TABLE 来创建数据表。

实例

以下为创建数据表 runoob_tbl 实例:

root@host# mysql -u root -p
Enter password:*******
mysql> use RUNOOB;
Database changed
mysql> CREATE TABLE runoob_tbl(
   -> runoob_id INT NOT NULL AUTO_INCREMENT,
   -> runoob_title VARCHAR(100) NOT NULL,
   -> runoob_author VARCHAR(40) NOT NULL,
   -> submission_date DATE,
   -> PRIMARY KEY ( runoob_id )
   -> )ENGINE=InnoDB DEFAULT CHARSET=utf8;
Query OK, 0 rows affected (0.16 sec)
mysql>

MySQL ALTER命令

当我们需要修改数据表名或者修改数据表字段时，就需要使用到MySQL ALTER命令。

开始本章教程前让我们先创建一张表，表名为：testalter_tbl。

root@host# mysql -u root -p password;
Enter password:*******
mysql> use RUNOOB;
Database changed
mysql> create table testalter_tbl
    -> (
    -> i INT,
    -> c CHAR(1)
    -> );
Query OK, 0 rows affected (0.05 sec)
mysql> SHOW COLUMNS FROM testalter_tbl;
+-------+---------+------+-----+---------+-------+
| Field | Type    | Null | Key | Default | Extra |
+-------+---------+------+-----+---------+-------+
| i     | int(11) | YES  |     | NULL    |       |
| c     | char(1) | YES  |     | NULL    |       |
+-------+---------+------+-----+---------+-------+
2 rows in set (0.00 sec)

删除，添加或修改表字段

添加字段类型及名称

MySQL 中使用 ADD 子句来向数据表中添加列，如下实例在表 testalter_tbl 中添加 i 字段，并定义数据类型为VARCHAR长度为32个字符且不能为NULL默认设置为’ '空字符:

mysql> ALTER TABLE testalter_tbl ADD i VARCHAR(32) NOT NULL DEFAULT ' ' AFTER c;

执行以上命令后，i 字段会自动添加到表字段c的末尾。

如果你需要查看新增操作后的表结构，可以使用MySQL提供的关键字 DESC / SHOW COLUMNS FROM，查看表中的所有列。

mysql> DESC testalter_tbl;
+-------+-------------+------+-----+---------+-------+
| Field | Type        | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+-------+
| c     | char(1)     | YES  |     |  NULL   |       |
| i     | varchar(11) | YES  |     |  NULL   |       |
+-------+-------------+------+-----+---------+-------+
2 rows in set (0.00 sec)

mysql> SHOW COLUMNS FROM testalter_tbl;
+-------+-------------+------+-----+---------+-------+
| Field | Type        | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+-------+
| c     | char(1)     | YES  |     |  NULL   |       |
| i     | varchar(11) | YES  |     |  NULL   |       |
+-------+-------------+------+-----+---------+-------+
2 rows in set (0.00 sec)

修改字段类型及名称

如果需要修改字段类型及名称, 你可以在ALTER命令中使用 MODIFY 或 CHANGE 子句 。

例如，把字段 c 的类型从 CHAR(1) 改为 CHAR(10)不为NULL且默认为’ '空字符，可以执行以下命令:

mysql> ALTER TABLE testalter_tbl MODIFY c CHAR(10) NOT NULL DEFAULT '';

使用 CHANGE 子句, 语法有很大的不同。 在 CHANGE 关键字之后，紧跟着的是你要修改的字段名，然后指定新字段名及类型。尝试如下实例：

mysql> ALTER TABLE testalter_tbl CHANGE i j VARCHAR(32) NOT NULL DEFAULT '';

删除字段类型及名称

如下命令使用了 ALTER 命令及 DROP 子句来删除以上创建表的 i 字段：

mysql> ALTER TABLE testalter_tbl DROP i;

如果数据表中只剩余一个字段则无法使用DROP来删除字段。

修改表名

如果需要修改数据表的名称，可以在 ALTER TABLE 语句中使用 RENAME 子句来实现。

尝试以下实例将数据表 testalter_tbl 重命名为 alter_tbl：

mysql> ALTER TABLE testalter_tbl RENAME TO alter_tbl;

修改表的字符集

如果需要修改数据表的字符集，可以在 ALTER TABLE 语句中使用 CHARACTER SET子句来实现。

尝试以下实例将数据表 testalter_tbl 字符集设置为 utf8：

mysql> ALTER TABLE testalter_tbl CHARACTER SET utf8;

MySQL插入数据

MySQL 表中使用 INSERT INTO SQL语句来插入数据。

你可以通过 mysql> 命令提示窗口中向数据表中插入数据，或者通过PHP脚本来插入数据。

语法

以下为向MySQL数据表插入数据通用的 INSERT INTO SQL语法：

INSERT INTO table_name ( field1, field2,...fieldN )
                       VALUES( value1, value2,...valueN ),( value1, value2,...valueN );

如果数据是字符型，必须使用单引号或者双引号，如：“value”。

实例

root@host# mysql -u root -p password;
Enter password:*******
mysql> use RUNOOB;
Database changed
mysql> INSERT INTO runoob_tbl 
    -> (runoob_title, runoob_author, submission_date)
    -> VALUES
    -> ("学习 PHP", "菜鸟教程", NOW());
Query OK, 1 rows affected, 1 warnings (0.01 sec)
mysql> INSERT INTO runoob_tbl
    -> (runoob_title, runoob_author, submission_date)
    -> VALUES
    -> ("学习 MySQL", "菜鸟教程", NOW());
Query OK, 1 rows affected, 1 warnings (0.01 sec)
mysql> INSERT INTO runoob_tbl
    -> (runoob_title, runoob_author, submission_date)
    -> VALUES
    -> ("JAVA 教程", "RUNOOB.COM", '2016-05-06');
Query OK, 1 rows affected (0.00 sec)
mysql>

MySQL UPDATE 更新

如果我们需要修改或更新 MySQL 中的数据，我们可以使用 SQL UPDATE 命令来操作。

语法

以下是 UPDATE 命令修改 MySQL 数据表数据的通用 SQL 语法：

UPDATE table_name SET field1=new-value1, field2=new-value2
[WHERE Clause]

• 你可以同时更新一个或多个字段。

• 你可以在 WHERE 子句中指定任何条件。

  UPDATE table_name
           SET field1=new-value
           WHERE field2=xxx
  

• 你可以在一个单独表中同时更新数据。

当你需要更新数据表中指定行的数据时 WHERE 子句是非常有用的。

---

通过命令提示符更新数据

以下我们将在 SQL UPDATE 命令使用 WHERE 子句来更新 runoob_tbl 表中指定的数据：

实例

以下实例将更新数据表中 runoob_id 为 3 的 runoob_title 字段值：

mysql> UPDATE runoob_tbl SET runoob_title='学习 C++' WHERE runoob_id=3;
Query OK, 1 rows affected (0.01 sec)
 
mysql> SELECT * from runoob_tbl WHERE runoob_id=3;
+-----------+--------------+---------------+-----------------+
| runoob_id | runoob_title | runoob_author | submission_date |
+-----------+--------------+---------------+-----------------+
| 3         | 学习 C++   | RUNOOB.COM    | 2016-05-06      |
+-----------+--------------+---------------+-----------------+
1 rows in set (0.01 sec)

MySQL DELETE 语句

你可以使用 SQL 的 DELETE FROM 命令来删除 MySQL 数据表中的记录。

你可以在 mysql> 命令提示符或 PHP 脚本中执行该命令。

语法

以下是 SQL DELETE 语句从 MySQL 数据表中删除数据的通用语法：

DELETE FROM table_name [WHERE Clause]

• 如果没有指定 WHERE 子句，MySQL 表中的所有记录将被删除。

  DELETE FROM table_name
  

• 你可以在 WHERE 子句中指定任何条件

  DELETE FROM table_name WHERE field=xxx
  

• 您可以在单个表中一次性删除记录。

当你想删除数据表中指定的记录时 WHERE 子句是非常有用的。

从命令行中删除数据

这里我们将在 SQL DELETE 命令中使用 WHERE 子句来删除 MySQL 数据表 runoob_tbl 所选的数据。

实例

以下实例将删除 runoob_tbl 表中 runoob_id 为3 的记录：

mysql> use RUNOOB;
Database changed
mysql> DELETE FROM runoob_tbl WHERE runoob_id=3;
Query OK, 1 row affected (0.23 sec)

MySQL 查询数据

MySQL 数据库使用SQL SELECT语句来查询数据。

可以通过 mysql> 命令提示窗口中在数据库中查询数据

语法

以下为在MySQL数据库中查询数据通用的 SELECT 语法：

SELECT column_name,column_name
FROM table_name
[WHERE Clause]
[LIMIT N][ OFFSET M]

• 查询语句中可以使用一个或者多个表，表之间使用逗号(,)分割，并使用WHERE语句来设定查询条件。

• SELECT 命令可以读取一条或者多条记录。

  SELECT column_name1,column_name2 FROM table_name
  

• 使用星号（*）来代替其他字段，SELECT语句会返回表的所有字段数据

  SELECT * FROM table_name
  

• 使用 WHERE 语句来包含任何条件。

  SELECT column_name,column_name FROM table_name [WHERE Clause]
  

• 使用 LIMIT 属性来设定返回的记录数。

• 通过OFFSET指定SELECT语句开始查询的数据偏移量。默认情况下偏移量为0。

• 统计

  SELECT column_name1, (column_name2 + column_name3...) FROM table_name
  

SELECT DISTINCT 实例

SELECT DISTINCT 语句用于返回唯一不同的值。

在表中，一个列可能会包含多个重复值，有时希望仅仅列出不同（distinct）的值。

DISTINCT 关键词用于返回唯一不同的值。

SELECT DISTINCT column1, column2, ... FROM table_name;

从table_name表中去重查询column1, column2并且满足column1, column2字段都相同

参数说明：

• column1, column2, …：要选择的字段名称，可以为多个字段。如果不指定字段名称，则会选择所有字段。
• table_name：要查询的表名称。

SQL 别名

通过使用 SQL，可以为表名称或列名称指定别名。

基本上，创建别名是为了让列名称的可读性更强。

列的 SQL 别名语法

SELECT column_name AS alias_name FROM table_name;

表的 SQL 别名语法

SELECT column_name(s) FROM table_name AS alias_name;

列的别名实例

下面的 SQL 语句指定了两个别名，一个是column_name1列的别名为a，一个是 column_name2列的别名为b。

**提示：**如果列名称包含空格，要求使用双引号或方括号：

SELECT column_name1 AS a, column_name2 AS b FROM table_name;

表的别名实例

下面的 SQL 语句选取 “field=xxx” 的所有访问记录。我们使用 “table_name1” 和 “table_name2” 表，并分别为它们指定表别名 “a” 和 “b”（通过使用别名让 SQL 更简短）：

SELECT a.name, a.url, b.count, b.date FROM table_name1 AS a, able_name2 AS b
WHERE b.site_id=a.id and a.name="xxx";

不带别名的相同的 SQL 语句：

SELECT table_name1.name, table_name1.url, table_name2.count, table_name2.date
FROM table_name1, table_name2
WHERE table_name1.id=table_name2.site_id and table_name1.name="xxx";

MYSQL SELECT WHERE 子句

我们知道从 MySQL 表中使用 SQL SELECT 语句来读取数据。

如需有条件地从表中选取数据，可将 WHERE 子句添加到 SELECT 语句中。

语法

以下是 SQL SELECT 语句使用 WHERE 子句从数据表中读取数据的通用语法：

SELECT field1, field2,...fieldN FROM table_name1, table_name2...
[WHERE condition1 [AND [OR]] condition2.....

• 查询语句中你可以使用一个或者多个表，表之间使用逗号**,** 分割，并使用WHERE语句来设定查询条件。

  SELECT field1,fieled2... FROM table_name1, table_name2... WHERE condition
  

• 你可以在 WHERE 子句中指定任何条件。

  SELECT field FROM table_name WHERE condition
  

• 你可以使用 AND 或者 OR 指定一个或多个条件。

  SELECT field FROM table_name WHERE condition1 [AND [OR]] condition2...
  

• WHERE 子句也可以运用于 SQL 的 DELETE 或者 UPDATE 命令。

• WHERE 子句类似于程序语言中的 if 条件，根据 MySQL 表中的字段值来读取指定的数据。

以下为操作符列表，可用于 WHERE 子句中。

下表中实例假定 A 为 10, B 为 20

操作符	描述	实例
=	等号，检测两个值是否相等，如果相等返回true	(A = B) 返回false。
<>, !=	不等于，检测两个值是否相等，如果不相等返回true	(A != B) 返回 true。
>	大于号，检测左边的值是否大于右边的值, 如果左边的值大于右边的值返回true	(A > B) 返回false。
<	小于号，检测左边的值是否小于右边的值, 如果左边的值小于右边的值返回true	(A < B) 返回 true。
>=	大于等于号，检测左边的值是否大于或等于右边的值, 如果左边的值大于或等于右边的值返回true	(A >= B) 返回false。
<=	小于等于号，检测左边的值是否小于或等于右边的值, 如果左边的值小于或等于右边的值返回true	(A <= B) 返回 true。

如果我们想在 MySQL 数据表中读取指定的数据，WHERE 子句是非常有用的。

使用主键来作为 WHERE 子句的条件查询是非常快速的。

如果给定的条件在表中没有任何匹配的记录，那么查询不会返回任何数据。

我们将在SQL SELECT语句使用WHERE子句来读取MySQL数据表 table_name中的数据：

实例

以下实例将读取 table_name表中column_name字段值为xxx的所有记录：

SELECT * from table_name WHERE column_name=xxx;

MySQL LIKE 子句

SQL LIKE 子句中使用百分号 **%**字符来表示任意字符，类似于UNIX或正则表达式中的星号 *****。

如果没有使用百分号 %, LIKE 子句与等号 = 的效果是一样的。

语法

以下是 SQL SELECT 语句使用 LIKE 子句从数据表中读取数据的通用语法：

SELECT field1, field2,...fieldN 
FROM table_name
WHERE field1 LIKE condition1 [AND [OR]] filed2 = 'somevalue'

• 可以在 WHERE 子句中指定任何条件。
• 可以在 WHERE 子句中使用LIKE子句。
• 可以使用LIKE子句代替等号 =。
• LIKE 通常与 % 一同使用，类似于一个元字符的搜索。
• 可以使用 AND 或者 OR 指定一个或多个条件。
• 可以在 DELETE 或 UPDATE 命令中使用 WHERE…LIKE 子句来指定条件。

在命令提示符中使用 LIKE 子句

实例

以下是我们将 table_name表中获取 field字段中以 COM 为结尾的的所有记录：

mysql> use database_name;
Database changed
mysql> SELECT * from table_name  WHERE field LIKE '%COM';
+-----------+---------------+---------------+-----------------+
| runoob_id | runoob_title  | runoob_author | submission_date |
+-----------+---------------+---------------+-----------------+
| 3         | 学习 Java   | RUNOOB.COM    | 2015-05-01      |
| 4         | 学习 Python | RUNOOB.COM    | 2016-03-06      |
+-----------+---------------+---------------+-----------------+
2 rows in set (0.01 sec)

SQL BETWEEN 操作符

BETWEEN 操作符选取介于两个值之间的数据范围内的值。这些值可以是数值、文本或者日期。

SQL BETWEEN 语法

SELECT column1, column2, ...
FROM table_name
WHERE column BETWEEN value1 AND value2;

参数说明：

• column1, column2, …：要选择的字段名称，可以为多个字段。如果不指定字段名称，则会选择所有字段。
• table_name：要查询的表名称。
• column：要查询的字段名称。
• value1：范围的起始值。
• value2：范围的结束值。

BETWEEN 操作符实例

下面的 SQL 语句选取 column 介于 1 和 20 之间的数据：

SELECT * FROM table_name
WHERE column BETWEEN 1 AND 20;

SQL ORDER BY 关键字

ORDER BY 关键字用于对结果集按照一个列或者多个列进行排序。

ORDER BY 关键字默认按照升序对记录进行排序。如果需要按照降序对记录进行排序，您可以使用 DESC 关键字。

SQL ORDER BY 语法

SELECT column1, column2, ...
FROM table_name
ORDER BY column1, column2, ... ASC|DESC;

• column1, column2, …：要排序的字段名称，可以为多个字段。
• ASC：表示按升序排序。
• DESC：表示按降序排序。

ORDER BY DESC实例

下面的 SQL 语句从 “table_name” 表中选取所有网站，并按照 “column” 列降序排序：

SELECT * FROM table_name
ORDER BY column DESC;

SQL COUNT() 函数

COUNT() 函数返回匹配指定条件的行数。

SQL COUNT(column_name) 语法

COUNT(column_name) 函数返回指定列的值的数目（NULL 不计入）：

SELECT COUNT(column_name) FROM table_name;

SQL COUNT(*) 语法

COUNT(*) 函数返回表中的记录数：

SELECT COUNT(*) FROM table_name;

SQL COUNT(DISTINCT column_name) 语法

COUNT(DISTINCT column_name) 函数返回指定列的不同值的数目：

SELECT COUNT(DISTINCT column_name) FROM table_name;

SQL SUM() 函数

SUM() 函数返回数值列的总数。

SQL SUM() 语法

SELECT SUM(column_name) FROM table_name;

SQL AVG() 函数

AVG() 函数

AVG() 函数返回数值列的平均值。

SQL AVG() 语法

SELECT AVG(column_name) FROM table_name

SQL MAX() 函数

MAX() 函数

MAX() 函数返回指定列的最大值。

SQL MAX() 语法

SELECT MAX(column_name) FROM table_name;

SQL MIN() 函数

MIN() 函数

MIN() 函数返回指定列的最小值。

SQL MIN() 语法

SELECT MIN(column_name) FROM table_name;

MySQL GROUP BY 语句

GROUP BY 语句根据一个或多个列对结果集进行分组。

在分组的列上我们可以使用 COUNT, SUM, AVG,等函数。

SELECT column_name, function(column_name)
FROM table_name
WHERE column_name operator value
GROUP BY column_name;

SQL HAVING 子句

在 SQL 中增加 HAVING 子句原因是，WHERE 关键字无法与聚合函数一起使用。

HAVING 子句可以让我们筛选分组后的各组数据。

SQL HAVING 语法

SELECT column_name, aggregate_function(column_name)
FROM table_name
WHERE column_name operator value
GROUP BY column_name
HAVING aggregate_function(column_name) operator value;

字符串函数

CHARSET()函数

返回字符串所使用的字符集

SELECT CHARSET(column_name) FROM table_name

CONCAT()函数

连接字符串，将多个列拼接在一起

SELECT CONCAT(column_name1,column_name2,'string') FROM table_name

INSTR()函数

返回substring在string中出现的起始位置，没有返回0

SELECT INSTR('string','substring') FROM DUAL

• DUAL：亚元表，没有表数据时可用于测试。

UCASE() 函数

将字段的值转换为大写。

SELECT UCASE(column_name) FROM table_name

LCASE() 函数

将字段的值转换为小写。

SELECT LCASE(column_name) FROM table_name;

LEFT()函数

从string中的左边起取length个字符

SELECT LEFT(string,length) FROM table_name;

RIGHT()函数

从string中的右边起取length个字符

SELECT RIGHT(string,length) FROM table_name;

LENGTH()

LENGTH() 函数返回文本字段中值的长度(按照字节)。

SELECT LENGTH(column_name) FROM table_name;

REPLACE()

在string中用replace_str替换search_str

SELECT REPLACE(column_name,search_str,replace_str) FROM table_name;

STRCMP()

逐字符比较两字符串的大小(根据数据所在数据库排序规则进行对比)

SELECT STRCMP('string1','string2') FROM DUAL;

SUBSTRING()

从string的position开始（从1开始计算），取length个字符

SELECT SUBSTRING(column_name,1,length) FROM table_name;

LTRIM()

去除字符串左端的所有空格

SELECT LTRIM('   string') FROM DUAL;

RTRIM()

去除字符串右端的所有空格

SELECT RTRIM('string   ') FROM DUAL;

TRIM()

去除字符串左右端的所有空格

SELECT RTRIM('   string   ') FROM DUAL;

数学函数

ABS()

取num的绝对值

SELECT ABS(num) FROM DUAL;

BIN()

将number十进制数转换成二进制数

SELECT BIN(number) FROM DUAL;

CEILING()

将number向上取整，得到比number大的最小整数

SELECT CEILING(number) FROM DUAL;

CONV()

说明number为a进制并且将number从a进制转换成b进制

SELECT CONV(number,a,b) FROM DUAL;

FLOOR()

将number向下取整，得到比number小的最大整数

SELECT FLOOR(number) FROM DUAL;

FORMAT()

保留number后n位小数（四舍五入）

SELECT FORMAT(number,n) FROM DUAL;

HEX()

将number十进制数转换成十六进制数

SELECT HEX(number) FROM DUAL;

LEAST()

求number1,number2,numberN…中的最小值

SELECT LEAST(number1,number2,numberN...) FROM DUAL;

MOD()

求number除以denominator的余数

SELECT MOD(number,denominator) FROM DUAL;

RAND()

返回随机数，其范围为 0 ≤ v ≤ 1.0

SELECT RAND() FROM DUAL;

• 如果直接使用RAND()每次返回不同的随机数，其范围为 0 ≤ v ≤ 1.0
• 如果使用RAND(seed) seed为任意整数类型，其范围为 0 ≤ v ≤ 1.0，如果seed不变，该随机数固定不变

日期函数

CURRENT_DATE()

返回当前的日期

SELECT CURRENT_DATE() FROM DUAL;

CURRENT_TIME()

返回当前的时间

SELECT CURRENT_TIME() FROM DUAL;

NOW()

返回当前的日期和时间

SELECT NOW() FROM DUAL;

CURRENT_TIMESTAMP()

返回当前时间戳

SELECT CURRENT_TIMESTAMP() FROM DUAL;

DATE()

提取日期或日期/时间表达式的日期部分 【提取（年-月-日 时-分-秒）中的年-月-日】

SELECT DATA(datetime) FROM DUAL;

DATE_ADD()

向日期添加指定的时间间隔

SELECT column_name FROM table_name WHERE DATE_ADD(date,INTERVAL expr timetype) [condition]

DATE_SUB()

从日期减去指定的时间间隔

SELECT column_name FROM table_name WHERE DATE_SUB(date,INTERVAL expr timetype) [condition]

• date 参数是合法的日期表达式。expr 参数是希望添加的时间间隔
• timetype 参数是时间单位

DATEDIFF()

返回两个日期之间相差的天数

SELECT DATEDIFF(date1,date2) FROM DUAL;

date1 和 date2 参数是合法的日期或日期/时间表达式。

**注释：**只有值的日期部分参与计算。

YEAR/MONTH/DAY()

返回datetime中的年/月/日信息

SELECT YEAR(NOW()) FROM DUAL;

UNIX_TIMESTAMP()

返回1970-1-1至今的时间（单位：秒）

SELECT UNIX_TIMESTAMP() FROM DUAL;

FROM_UNIXTIME()

将UNIX_TIMESTAMP()获取到的秒数，转换成指定格式的日期

SELECT FROM_UNIXTIME(UNIX_TIMESTAMP(), '%Y-%m-%d %H:%i:%s') FROM DUAL;

• '%Y-%m-%d %H:%i:%s’为固定格式，表示年-月-日 %时%分%秒

加密和系统函数

USER()

查询用户 返回 – 用户@IP地址

SELECT USER() FROM DUAL;

DATABASE()

查看当前正在使用的数据库

SELECT DATABASE() FROM DUAL;

MD5()

为string算出一个MD5 32位的字符串，常用于（用户密码）加密

SELECT MD5(string) FROM DUAL;

PASSWORD()

从原文密码string计算并返回密码字符串，通常用于对操作mysql数据库的mysql用户密码加密

SELECT PASSWORD(string) FROM DUAL;

• SELECT * FROM mysql.user; 可查询MySQL数据的用户表信息

流程控制函数

IF()

如果express1为true，则返回express2，否则返回express3

SELECT IF(express1,express2,express3) FROM DUAL;

IFNULL()

如果express1不为空NULL，则返回express1，否则返回express2

SELECT IFNULL(express1,express2) FROM DUAL;

CASE

如果express1为true，则返回express2，如果express3为true，则返回express4，否则返回express5

SELECT CASE
	WHEN express1 THEN express2
	WHEN express3 THEN express4
	ELSE express5 END;

分页查询

从start+1行开始取，取出rows行，start起始为0开始计算

SELECT column_name FROM table_name ORDER BY column_name LIMIT start,rows;

实例

SELECT * FROM table_name ORDER BY column_name LIMIT 0,3;

• 从table_name中从第1行取出3条记录
• 每页显示记录数 * （第几页-1），每页显示记录数

分组增强

如果select语句同时包括又group by，having，order by，limit那么他们顺序是group by，having，order by，limit

SELECT column1,column2,column3... FROM table_name
	GROUP BY column_name
		HAVING condition
			ORDER BY column_name
				LIMIT start,rows;

MySQL多表查询

多表查询是指基于两个或两个以上的表查询

SELECT column1,column2...
	FROM table_name1,table_name2
	 WHERE [Condition...]

• column可为table_name1.column或table_name2.column
• table_name1表中有X行数据，table_name2表中有Y行数据进行多表查询时会产生笛卡尔积共X*Y行数据

自连接

在同一张表的连接查询（将同一张表看作两张表）

实例：

在emp员工表中empno用于存放员工编号，ename用于存放员工姓名，mgr用于存放该员工的上司的对应empno，

SELECT worker.ename AS '职员名', boss.ename AS '上级名' 
	FROM emp AS worker , emp AS boss
		WHERE worker.mgr = boss.empno

子查询

• 子查询是指嵌入在其它sql语句中的select语句，也叫嵌套查询

  SELECT * FROM table_name
  	WHERE column_name = (
          SELECT column_name
          	FROM table_name
          		WHERE [Condition] 
      )
  

• 单行子查询是指返回一行数据的子查询语句

• 多行子查询是指返回多行数据的子查询，使用关键字in

  SELECT column_name1,column_name2...
  	FROM table_name
  		WHERE column_name IN (
          	SELECT DISTINCT column_name
              	FROM table_name
              		WHERE [Condition]
          ) AND [Condition]
  

ALL()

将单个值与子查询返回的单列值集进行比较

SELECT column_name1,column_name2...
	FROM table_name
		WHERE [Condition] ALL(
			SELECT column_name
				FROM table_name
					WHERE [Condition]
		)

ANY()

将给定值与每个子查询值进行比较，并返回满足条件的值

SELECT column_name1,column_name2...
	FROM table_name
		WHERE [Condition] ANY(
			SELECT column_name
				FROM table_name
					WHERE [Condition]
		)

多列子查询

查询返回多个列数据的子查询语句

SELECT column_name1,column_name2...
	FROM table_name
		WHERE (column_name1,column_name2) = (
         	SELECT column_name1,column_name2
            	FROM table_name
            		WHERE [Condition]
        ) AND [Condition]

MYSQL表复制

自我复制数据（蠕虫复制）

有时为了对某个sql语句进行测试，需要海量数据时，可以用此方法为表创建海量数据

从一个表复制到另一个表内

实例：将table_name2表的数据插入到table_name1内

INSERT INTO table_name1
	(column_name1,column_name2...)
		SELECT column_name1,column_name1... FROM table_name2;

单表内自我复制

INSERT INTO table_name1
	SELECT * FROM table_name;

如何删除一张表的重复记录

CREATE TABLE my_table LIKE start_table;
INSERT INTO temp_table
	SELECT DISTINCT * FROM start_table;
DELETE FROM start_table;
INSERT INTO start_table
	SELECT * FROM temp_table;
DROP TABLE temp_table;

1. 先创建一张临时表temp_table，该表的结构和将被处理的表start_table一样
2. 将要被处理的表start_table插入临时表temp_table，通过DISTINCT关键字去重
3. 清除有重复记录要被处理的表start_table
4. 把temp_table临时表的记录插入到start_table
5. 删除temp_table临时表

合并查询

UNION 操作符

用于连接两个以上的 SELECT 语句的结果组合到一个结果集合中。多个 SELECT 语句会删除重复的数据

SELECT column_name1,column_name2,column_name3 FROM table_name1 WHERE [Condition]
UNION
SELECT column_name1,column_name2,column_name3 FROM table_name2 WHERE [Condition]

ALL: 可选，返回所有结果集，包含重复数据

SELECT column_name1,column_name2,column_name3 FROM table_name1 WHERE [Condition]
UNION ALL
SELECT column_name1,column_name2,column_name3 FROM table_name2 WHERE [Condition]

MySQL表外连接

左外连接

左表（table_name1）和右表右表（table_name2）没有匹配的记录也会从左表返回所有的行。如果右表中没有匹配，则结果为 NULL。

SELECT column_name1,column_name2...
	FROM table_name1 LEFT JOIN table_name2
		ON table1.column_name=table2.column_name;

右外连接

左表（table_name1）和右表（table_name2）没有匹配的记录也会从右表返回所有的行。如果左表中没有匹配，则结果为 NULL。

SELECT column_name1,column_name2...
	FROM table_name1 RIGHT JOIN table_name2
		ON table1.column_name=table2.column_name;

PRIMARY KEY 主键约束

PRIMARY KEY 约束唯一标识数据库表中的每条记录。

主键必须包含唯一的值。

主键列不能包含 NULL 值。

每个表都应该有一个主键，并且每个表只能有一个主键。

下面的 SQL 在 “table_name” 表创建时在 “id” 列上创建 PRIMARY KEY 约束

CREATE TABLE table_name(
    id INT PRIMARY KEY,
    `name` VARCHAR(32)
);

如需命名 PRIMARY KEY 约束，并定义多个列的 PRIMARY KEY 约束，使用下面的 SQL 语法：

CREATE TABLE table_name(
    id INT PRIMARY KEY,
    `name` VARCHAR(32),
    PRIMARY KEY(id,`name`) --复合主键
);

UNIQUE 约束

UNIQUE 约束唯一标识数据库表中的每条记录。

UNIQUE 和 PRIMARY KEY 约束均为列或列集合提供了唯一性的保证。

PRIMARY KEY 约束拥有自动定义的 UNIQUE 约束。

如果一个列（字段）是UNIQUE NOT NULL使用效果类似PRIMARY KEY。

每个表可以有多个 UNIQUE 约束，但是每个表只能有一个 PRIMARY KEY 约束。

CREATE TABLE 时的 SQL UNIQUE 约束

下面的 SQL 在 “table_name” 表创建时在 “id” 列上创建 UNIQUE 约束：

CREATE TABLE table_name(
	id int NOT NULL,
    `name` VARCHAR(32),
    UNIQUE(id)
)

如需命名 UNIQUE 约束，并定义多个列的 UNIQUE 约束，使用下面的 SQL 语法：

CREATE TABLE table_name(
	id int NOT NULL,
    `name` VARCHAR(32),
    address VARCHAR(32),
    UNIQUE(id,`name`)
)

FOREIGN KEY外键约束

一个表中的 FOREIGN KEY 指向另一个表中的 UNIQUE KEY(唯一约束的键)。

通过一个实例来解释外键。请看下面两个表：

首先创建一个Master主表，班级表class

CREATE TABLE class(
	id INT PRIMARY KEY,
    `name` VARCHAR(32) NOT NULL DEFAULT ''
)

再创建一个Slave从表，学生表student，通过FOREIGN KEY(Slave.column_name) REFERENCES Master.table_name(column_name)使Slave从表中需要关联的字段关联至Master主表字段

CREATE TABLE student(
	id INT PRIMARY KEY,
    `name` VARCHAR(32) NOT NULL DEFAULT '',
    class_id INT,
    FOREIGN KEY(class_id) REFERENCES class(id)
)

• Slave从表的外键指向的Master主表的字段，要求是PRIMARY KEY或者是UNIQUE
• 表的类型是INNODB，这样的表才支持外键
• 外键字段的类型要和主键字段的类型一致（长度可以不同）
• 外键字段的值，必须在主键字段中出现过，或者为NULL【前提是外键字段允许为NULL】
• 一旦建立主外键的关系，数据就不能随意删除了

CHECK约束

CHECK 约束用于限制列中的值的范围。

如果对单个列定义 CHECK 约束，那么该列只允许特定的值。

如果对一个表定义 CHECK 约束，那么此约束会基于行中其他列的值在特定的列中对值进行限制。

下面的 SQL 在 “Persons” 表创建时在 “id” 列上创建 CHECK 约束。CHECK 约束规定 “id” 列必须只包含大于 0 的整数。

CREATE TABLE Persons(
	id int NOT NULL,
	name varchar(255) NOT NULL,
	CHECK (id>0)
)

如需命名 CHECK 约束，并定义多个列的 CHECK 约束，使用下面的 SQL 语法：

CREATE TABLE Persons(
	id int NOT NULL,
	name varchar(255) NOT NULL,
	City varchar(255),
	CONSTRAINT chk_Person CHECK (id>0 AND City='xxx')
)

• MySQL 5.7目前不支持CHECK，只做语法校验，但不会生效。

AUTO_INCREMENT自增长

在某张表中，存在一个id列（整数），我们希望在添加记录的时候，该列从1开始，自动的增长

CREATE TABLE table_name(
	id INT PRIMARY KEY AUTO_INCREMENT,
    address VARCHAR(32) NOT NULL DEFAULT '',
    `name` VARCHAR(32) NOT NULL DEFAULT ''
);

添加自增长的字段方式

INSERT INTO table_name(字段1,字段2...) VALUES(NULL,'值'...);
INSERT INTO table_name(字段2...) VALUES('值1','值2'...);
INSERT INTO table_name VALUES(NULL,'值1',...);

• 一般来说自增长是和PRIMARY KEY配合使用

• 自增长也可以单独使用【但是需要配合一个UNIQUE】

• 自增长修饰的字段为整数类型的（虽然小数也可以但是非常少这样使用）

• 自增长默认从1开始，也可以通过如下命令修改默认的自增长初始值：

  ALTER TABLE表名AUTO_INCREMENT=xxx;

• 如果添加数据时，给自增长字段（列）指定值，则以指定值为准。如果指定了自增长，一般来说，就按照自增长的规则来添加数据

MySQL 索引

MySQL索引的建立对于MySQL的高效运行是很重要的，索引可以大大提高MySQL的检索速度。

创建索引时，你需要确保该索引是应用在 SQL 查询语句的条件(一般作为 WHERE 子句的条件)。

实际上，索引也是一张表，该表保存了主键与索引字段，并指向实体表的记录。

索引的缺点：虽然索引大大提高了查询速度，同时却会降低更新表的速度，如对表进行INSERT、UPDATE和DELETE。因为更新表时，MySQL不仅要保存数据，还要保存一下索引文件。

建立索引会占用磁盘空间的索引文件。

• 索引的类型
  1. 主键索引，主键自动的主索引（类型PRIMARY KEY)
  2. 唯一索引（UNIQUE)
  3. 普通索引（INDEX）
  4. 全文索引（FULLTEXT)[适用于MyISAM] 一般开发中不使用MySQL自带的全文索引，而是使用：全文搜索Solr和EasticSearch（ES）

添加索引

添加唯一索引

CREATE UNIQUE INDEX index_name ON table_name (column_name);

添加普通索引

CREATE INDEX index_name ON table_name (column_name);

• 如果某列（字段）的值是不会重复的，则优先考虑使用UNIQUE索引，否则使用普通索引

添加普通索引2

ALTER TABLE table_name ADD INDEX index_name (column_name);

添加主键索引

ALTER TABLE table_name ADD PRIMARY KEY (column_name);

• 创建表时指定PRIMARY KEY同时也添加了主键索引

删除索引

DROP INDEX index_name ON table_name;

删除主键索引

ALTER TABLE table_name DROP PRIMARY KEY;

修改索引

先删除索引，再添加索引即可

查询索引

#方式1
SHOW INDEX FROM table_name;
#方式2
SHOW INDEXES FROM table_name;
#方式3
SHOW KEYS FROM table_name;
#方式4
DESC table_name;

MySQL事务

事务用于保证数据的一致性，它由一组相关的DML（增删改）语句组成，该组的DML语句要么全部成功，要么全部失败。如转账业务的实现就要用事务来进行处理，用以保证数据的一致性。

事务和锁：

当执行事务操作时（DML语句），MySQL会在表上加锁，防止其他用户改表的数据，这对用户来讲是非常重要的。

• ​ MySQL数据库控制台事务的几个重要操作（基本操作transacation.sql）

START TRANSACTION #开始一个事务
SAVEPOINT savepoint_name #设置保存点
ROLLBACK TO savepoint_name #回退事务至指定保存点
ROLLBACK #回退全部事务
COMMIT #提交事务，所有的操作生效，提交后不能进行回退事务操作

• 回退事务

保存点（SAVEPOINT)是事务中的点，用于取消部分事务，当提交结束事务时（COMMIT），会自动的删除该事务定义的所有保存点，当执行回退事务时，通过指定保存点可以回退到指定的点

• 使用COMMIT语句可以提交事务，当执行了COMMIT语句后，会确认事务的变化、结束事务、删除保存点、释放锁，数据生效。当使用COMMIT语句结束事务后，其它会话【其他连接】将可以查看到事务变化后的数据【所有数据就正式生效】

1. 如果不开始事务，默认情况下，DML操作是自动提交的，不能回滚。
2. 如果开始一个事务。没有创建保存点，可以执行ROLLBACK，默认回退到事务开始时的状态。
3. 可以在事务中（还没有进行COMMIT提交前），创建多个保存点：比如SAVEPOINT savepoint_name1；执行DML操作，SAVEPOINT savepoint_name2。
4. 可以在事务没有进行COMMIT提交前，选择回退到哪个指定的保存点。
5. MySQL的事务机制需要使用INNODB的存储引擎
6. 开始事务的两种方式START TRANSACTION或者SET AUTOCOMMIT=OFF;

MySQL事务隔离级别

• 脏读（dirty read）：当一个事务读取另一个事务尚未提交的改变（UPDATE，INSERT，DELETE)时，产生脏读。
• 不可重复读（nonrepeatable read）：同一查询在同一事务中多次进行，由于其他提交事务所做的修改或删除，每次返回不同的结果集，此时发生不可重复读。
• 幻读（phantom read）：同一查询在同一事务中多次进行，由于其他提交事务所作的插入操作，每次返回不同的结果集，此时发生幻读。

MySQL隔离级别（4种 isolation_level_name）	脏读	不可重复读	幻读	加锁读
读未提交(READ UNCOMMITTED)	√	√	√	不加锁
读已提交(READ COMMITTED)	×	√	√	不加锁
可重复读(REPEATABLE READ)	×	×	×	不加锁
可串行化(SERIALIZABLE)	×	×	×	加锁

• √表示可能出现，×表示不会出现。

• 查看当前会话隔离级别

  SELECT @@TX_ISOLATION;
  

• 查看系统当前隔离级别

  SELECT @@GLOBAL.TX_ISOLATION;
  

• 设置当前会话隔离级别

  SET SESSION TRANSACTION ISOLATION LEVEL isolation_level_name;
  

• 设置系统当前隔离级别

  SET GLOBAL TRANSACTION ISOLATION LEVEL isolation_level_name;
  

事务的ACID特性

1. 原子性（Atomicity）

   原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生

2. 一致性（Consistency）

   事务必须使数据库从一个一致性状态变换到另外一个一致性状态

3. 隔离性（Isolation）

   事务的隔离性是多个用户并发访问数据库时，数据库为每一个用户开启的事务，不能被其他事务的操作数据所干扰，多个并发事务之间要相互隔离

4. 持久性（Durability）

   持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来即使数据库发生故障也不应该对其有任何影响

MySQL存储引擎和表类型

• 基本介绍

1. MySQL的表类型由存储引擎（Storage Engines）决定，主要包括MyISAM、InnoDB、MEMORY等。

2. MySQL数据表主要支持六种类型，分别是：CSV、MEMORY、ARCHIVE、MRG_MYISAM、MYISAM、InnoDB。

3. 这六种又分为两类，一类是“事务安全型”（transaction-safe），比如：InnoDB；其余都属于第二类，称为“非事务安全型”（non-transaction-safe）[MYISAM和MEMORY]。

4. 显示当前数据库支持的存储引擎：

   SHOW ENGINES;
   

5. MYISAM不支持事务、也不支持外键，但其访问速度快，对事务完整性没有要求。

6. InnoDB存储引擎提供了具有提交、回滚和崩溃恢复能力的事务安全。但是比起MYISAM存储引擎，InnoDB写的处理效率差一些并且会占用更多的磁盘空间以保留数据和索引。

7. MEMORY存储引擎使用存在内存中的内容来创建表。每个MEMORY表只实际对应一个磁盘文件。MEMORY类型的表访问速度非常快，因为它的数据是存放在内存中的，并且默认使用HASH索引。但是一旦服务关闭，表中的数据就会丢失掉，表的结构还在。

• 如何选择表的存储引擎

1. 如果应用不需要事务，处理的只是基本的CRUD操作，那么MYISAM是不二的选择，速度快
2. 如果需要支持事务，选择InnoDB
3. MEMEORY存储引擎就是将数据存储在内存中，由于没有磁盘I/O的等待，速度极快。但是由于内存存储引擎，所作的任何修改在服务器重启后都将消息。（经典用法 用户的在线状态（）。）

修改存储引擎

ALTER TABLE 'table_name' ENGINE = engine_name;

视图(view)

视图是一个虚拟表，其内容由查询定义。同真实表一样，视图包含列，其数据来自对应的真实表（基表）

通过视图可以修改基表的数据

基表的内容发生改变，也会影响到视图的数据

创建视图

CREATE VIEW view_name
	AS
		SELECT column_name1,column_name2,... FROM table_name;

查看视图

DESC viem_name
SELECT column_name1,column_name2,... FROM view_name;

修改视图

ALTER VIEW view_name
	AS
		SELECT column_name1,column_name2,... FROM table_name;

查看创建视图

SHOW CREATE VIEW view_name;

删除视图

DROP VIEW view_name;

• 视图中可以再使用视图，数据仍然来自于基表

MySQL管理

• MySQL用户

  MySQL中的用户，都存储在系统数据库mysql中的user表中

其中user表的重要字段说明：

1. host：允许登录的“位置”，localhost表示该用户只允许本机登录，也可以指定ip地址，比如：192.168.1.100
2. user：用户名。
3. authentication_string：密码，是通过MySQL的password（）函数加密之后的密码。

• 创建用户

  CREATE USER 'user_name'@'host_name' IDENTIFIED BY 'password';
  #创建用户，同时指定密码
  

• 删除用户

  DROP USER 'user_name'@'host_name';
  

• 修改用户密码

  #修改当前用户的密码：
  SET PASSWORD = PASSWORD('new_password');
  #修改其他用户的密码（需要权限）：
  SET PASSWORD FOR 'user_name'@'host_name' = PASSWORD('new_password');
  

MySQL的权限

• 给用户授权

  基本语法：

  GRANT 权限列表
  	ON 库.对象名 TO '用户名'@'登录位置' [IDENTIFIED BY '密码'];
  

  说明：

  1. 权限列表，多个权限用逗号分开

     GRANT SELECT ON…

     GRANT SELECT,DELETE,CREATE ON…

     GRANT ALL [PRIVILEGES] ON… //表示赋予该用户该对象上的所有权限

  2. 特别说明

     *.* ：代表本系统中的所有数据库的所有对象（表，视图，存储过程）
     库.* ：表示某个数据库中的所有数据对象（表，视图，存储过程）
     

  3. IDENTIFIED BY可以省略，也可以写出

     如果用户存在，就是修改该用户的密码

     如果该用户不存在，就是创建用户

• 回收用户授权

  基本语法：

  REVOKE 权限列表
  	ON 库.对象名
  		FROM '用户名'@'登录位置';
  

• 权限生存指令

  如果权限没有生效，可以执行下面命令：

  基本语法：

  FLUSH PRIVILEGES;