基础SQL语法
- 基础
- 1.建表(CREATE\TABLE...)
- 2.删除表(DORP\TABLE)
- 3.修改表插入列(ALTER\TABLE\ADD\DROP\COLUMN\CHANGE)
- 4.插入行数据(INSERT\INTO\VALUES\)：
- 5.更新(即修改某列的值UPDATE\SET\WHERE)
- 6.删除(DELETE\FROM\TRUNCATE\TABLE)
- 5.查询(SELECT\FROM\DISTINCT\LIMIT\WHERE\UNION\IN)
- 5.1组合查询
- 6.过滤(查询\AND\OR\()\IN)
- 6.1 索引
- 7.排序(ORDER\BY\ASC\DESC)
- 8.通配符(%\_\[]\^)
- 9.计算字段(AS\CONCAT()\TRIM())
- 10.常用函数(AVG\COUNT\MAX\MIN\SUM\DISTINCT)
- 10.1 文本处理(LEFT\RIGHT\LOWER\UPPER\LTRIM\RTRIM\LENGTH)
- 10.2 日天和时间处理
- 10.3 数值处理
- 11.分组(GROUP\BY)
- 12.子查询
- 13.连接(INNER JOIN\ON\NATURAL JOIN\LEFT OUTER JOIN)
- 14、视图(CREATE VIEW \AS)
- 15.存储过程
- 16.游标
- 17.触发器
- 18 .事物管理
- 19.二十二、字符集
- 20.用户权限
Ubuntu下的mysql(零基础操作)
MySQL
基础
模式定义了数据如何存储、存储什么样的数据以及数据如何分解等信息，数据库和表都有模式；
SQL 语句不区分大小写，但是数据库表名、列名和值是否区分依赖于具体的 DBMS 以及配置;
SQL定义了三种注释：
#注释
-- 注释
/*注释*/
mysql -u root -p 密码 sqldata #登录时直接进入自己建立的数据库；
1.建表(CREATE\TABLE…)
语法：create table 表名称(
字段名 字段名类型 字段描述符，
字段名 字段类型 字段描述符);
create table t1(
id int not null primary key,
name char(20) not null );
- 实例
CREATE TABLE mytable(
# int 类型 不为空 自增
id INT NOT NULL AUTO_INCREMENT,
# int 类型 不可为空 默认值为1 不为空
col1 INT NOT NULL DEFAULT 1,
#变长字符串类型，最长为45个字符，可以为空
col2 VARCHAR(45) NULL,
#日期类型 可为空
col3 DATE NULL,
#s设置主键为id;
PRIMARY KEY(`id`) #主键必须有
);
显示如下：
+-------+-------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+----------------+
| id | int(11) | NO | PRI | NULL | auto_increment |
| col1 | int(11) | NO | | 1 | |
| col2 | varchar(45) | YES | | NULL | |
| col3 | date | YES | | NULL | |
+-------+-------------+------+-----+---------+----------------+
4 rows in set (0.00 sec)
2.删除表(DORP\TABLE)
语法：drop table 表名称;
drop table test;
DROP TABLE mytable;
3.修改表插入列(ALTER\TABLE\ADD\DROP\COLUMN\CHANGE)
添加字段即增加列：
语法：alter table 表名称 add(字段名 类型 描述符);
alter table t1 add(score int not null);
ALTER TABLE mytable ADD col CHAR(20);
移除字段，移除列：
语法：alter table 表名称 drop column 字段名， drop column 字段名;
alter table t1 drop column score;
ALTER TABLE mytable DROP COLUMN col;
变更字段：
语法：alter table 表名称 旧字段名 新字段名 新字段描述符;
alter table t1 change oldname newname int not null;
ALTER TABLE table5 CHANGE col2 col3 int not null;
尽量sql语句的关键字都用大写，为了和变量区分开来；
4.插入行数据(INSERT\INTO\VALUES)：
普通插入：
INSERT INTO mytable(col1, col2)
VALUES(val1, val2); //值的类型要相对应，val1为cols设置的那样；
mysql> INSERT INTO table4(col3) VALUES('abcde!');
Query OK, 1 row affected (0.00 sec)
mysql> SELECT * FROM table4;
+----+------+------+--------+
| id | col1 | col | col3 |
+----+------+------+--------+
| 1 | 123 | 4324 | NULL |
| 2 | 1 | NULL | abcde! |
| 3 | 1 | NULL | abcde! |
+----+------+------+--------+
3 rows in set (0.00 sec)
插入检索出来的数据：
mysql> INSERT INTO table4(col1,col) SELECT col1,col FROM table4;
Query OK, 3 rows affected (0.01 sec)
Records: 3 Duplicates: 0 Warnings: 0
mysql> SELECT * FROM table4; #使用该语句来查看数据；
+----+------+------+--------+
| id | col1 | col | col3 |
+----+------+------+--------+
| 1 | 123 | 4324 | NULL |
| 2 | 1 | NULL | abcde! |
| 3 | 1 | NULL | abcde! |
| 4 | 123 | 4324 | NULL |
| 5 | 1 | NULL | NULL |
| 6 | 1 | NULL | NULL |
+----+------+------+--------+
6 rows in set (0.00 sec)
将一个表的内容插入到一个新表,即将table5完全复制到新表中，包括列和数据；
mysql> CREATE TABLE newtable AS SELECT * FROM table5;
插入数据行时可能出现问题：
mysql> INSERT INTO table5(col)
-> VALUES('aBC');
ERROR 1364 (HY000): Field 'col3' doesn't have a default value
原因：col3该列没有默认值；所以在对col列插入时也必须对col3进行插入；
mysql> INSERT INTO table5(col,col3) VALUES('aNC',123);
Query OK, 1 row affected (0.00 sec)
mysql> SELECT * FROM table5;
+----+-------+-------+------+
| id | col1 | col3 | col |
+----+-------+-------+------+
| 1 | 21 | 23 | 123 |
| 2 | 21 | 23 | NULL |
| 3 | 21 | 23 | NULL |
| 4 | 21 | 23 | NULL |
| 6 | 1 | 5 | NULL |
| 7 | 11111 | 33333 | NULL |
| 8 | 11111 | 33333 | 0 |
| 9 | 1 | 123 | aNC |
+----+-------+-------+------+
8 rows in set (0.00 sec)
5.更新(即修改某列的值UPDATE\SET\WHERE)
语法：
update 表名称
set 更改的字段名=值
where 条件;
mysql> SELECT * FROM table4;
+----+------+------+--------+
| id | col1 | col | col3 |
+----+------+------+--------+
| 1 | 123 | 4324 | NULL |
| 2 | 1 | NULL | abcde! |
| 3 | 1 | NULL | abcde! |
| 4 | 123 | 4324 | NULL |
| 5 | 1 | NULL | NULL |
| 6 | 1 | NULL | NULL |
+----+------+------+--------+
6 rows in set (0.00 sec)
mysql> UPDATE table4
-> SET col=123
-> WHERE id=1;
Query OK, 1 row affected (0.01 sec)
Rows matched: 1 Changed: 1 Warnings: 0
mysql> SELECT * FROM table4;
+----+------+------+--------+
| id | col1 | col | col3 |
+----+------+------+--------+
| 1 | 123 | 123 | NULL |
| 2 | 1 | NULL | abcde! |
| 3 | 1 | NULL | abcde! |
| 4 | 123 | 4324 | NULL |
| 5 | 1 | NULL | NULL |
| 6 | 1 | NULL | NULL |
+----+------+------+--------+
6 rows in set (0.00 sec)
6.删除(DELETE\FROM\TRUNCATE\TABLE)
语法：delete from 表名称 whrer 条件;
mysql> DELETE FROM table4
-> WHERE id=1; #id=1 表示删除行；
Query OK, 1 row affected (0.01 sec)
mysql> SELECT * FROM table4;
+----+------+------+--------+
| id | col1 | col | col3 |
+----+------+------+--------+
| 2 | 1 | NULL | abcde! |
| 3 | 1 | NULL | abcde! |
| 4 | 123 | 4324 | NULL |
| 5 | 1 | NULL | NULL |
| 6 | 1 | NULL | NULL |
+----+------+------+--------+
5 rows in set (0.00 sec)
TRUNCATE TABLE 可以清空表，也就是删除所有行，但是该表设置的列不变;
TRUNCATE TABLE table4;
使用更新和删除操作时一定要用 WHERE 子句，不然会把整张表的数据都破坏。可以先用 SELECT 语句进行测试，防止错误删除=
5.查询(SELECT\FROM\DISTINCT\LIMIT\WHERE\UNION\IN)
不要出现语法错误；
普通查询:
单表全字段查询：
语法：select * from 表名称;
SELECT * FROM table5;
单表个别字段查询：
语法：Select 字段1,字段2 from 表名称;
SELECT col1 FROM table5;
多表查询：
语法：
select 表一字段，表二字段，表三字段,… from 表一,表二,表三,…;
SELECT table2.date,table5.col1 from table2,table5;
- DISTINCT: 相同值只会出现一次。它作用于所有列，也就是说所有列的值都相同才算相同;
SELECT DISTINCT col1,col FROM table5;
- LIMIT: 限制返回的行数。可以有两个参数，第一个参数为起始行，从 0 开始；第二个参数为返回的总行数;
SELECT *
FROM mytable
LIMIT 5; # LIMIT 2,3从第二行开始的3行
mysql> SELECT * FROM table5 LIMIT 0,3;
+----+------+------+------+
| id | col1 | col3 | col |
+----+------+------+------+
| 1 | 21 | 23 | 123 |
| 2 | 21 | 23 | NULL |
| 3 | 21 | 23 | NULL |
+----+------+------+------+
3 rows in set (0.00 sec)
5.1组合查询
使用 UNION 来组合两个查询，如果第一个查询返回 M 行，第二个查询返回 N 行，那么组合查询的结果一般为 M+N 行。
每个查询必须包含相同的列、表达式和聚集函数。
默认会去除相同行，如果需要保留相同行，使用UNION ALL。
只能包含一个 ORDER BY 子句，并且必须位于语句的最后。
SELECT col
FROM mytable
WHERE col = 1
UNION
SELECT col
FROM mytable
WHERE col =2;
多表条件查询： 语法：select 表一字段,表二字段 from 表一,表二 where 条件;
mysql> SELECT * FROM table5;
+----+-------+-------+------+
| id | col1 | col3 | col |
+----+-------+-------+------+
| 1 | 21 | 23 | 123 |
| 2 | 21 | 23 | NULL |
| 3 | 21 | 23 | NULL |
| 4 | 21 | 23 | NULL |
| 6 | 1 | 5 | NULL |
| 7 | 11111 | 33333 | NULL |
| 8 | 11111 | 33333 | 0 |
+----+-------+-------+------+
7 rows in set (0.00 sec)
mysql> SELECT * FROM newtable;
Empty set (0.00 sec)
mysql> SELECT * FROM ntable;
+----+------+------+--------+
| id | col1 | col | col3 |
+----+------+------+--------+
| 1 | 123 | 4324 | NULL |
| 2 | 1 | NULL | abcde! |
| 3 | 1 | NULL | abcde! |
| 4 | 123 | 4324 | NULL |
| 5 | 1 | NULL | NULL |
| 6 | 1 | NULL | NULL |
+----+------+------+--------+
6 rows in set (0.00 sec)
#table5.col1,ntable.col1,为要显示的列，及顺序；
mysql> SELECT table5.col1,ntable.col1,table5.col FROM table5,ntable where table5.id=ntable.id;
+------+------+------+
| col1 | col1 | col |
+------+------+------+
| 21 | 123 | 123 |
| 21 | 1 | NULL |
| 21 | 1 | NULL |
| 21 | 123 | NULL |
| 1 | 1 | NULL |
+------+------+------+
5 rows in set (0.00 sec)
嵌套查询： 语法：select 字段1,字段2,… from 表名称 where 条件(查询);
mysql> SELECT col1 FROM ntable
WHERE id=(
SELECT id FROM table5 WHERE col3=5); #注意此时col3=5,如果有多行则
#ERROR 1242 (21000): Subquery returns more than 1 row
#因为WHERE id=(值应唯一)
+------+
| col1 |
+------+
| 1 |
+------+
1 row in set (0.00 sec)
并查询UNION： 作用：得到两个查询结果的并集
mysql> (SELECT * FROM ntable) UNION (SELECT * FROM table5);
+----+-------+-------+--------+
| id | col1 | col | col3 |
+----+-------+-------+--------+
| 1 | 123 | 4324 | NULL |
| 2 | 1 | NULL | abcde! |
| 3 | 1 | NULL | abcde! |
| 4 | 123 | 4324 | NULL |
| 5 | 1 | NULL | NULL |
| 6 | 1 | NULL | NULL |
| 1 | 21 | 23 | 123 |
| 2 | 21 | 23 | NULL |
| 3 | 21 | 23 | NULL |
| 4 | 21 | 23 | NULL |
| 6 | 1 | 5 | NULL |
| 7 | 11111 | 33333 | NULL |
| 8 | 11111 | 33333 | 0 |
+----+-------+-------+--------+
13 rows in set (0.00 sec)
交查询IN： 作用：得到两个查询结果的交集
mysql> SELECT id FROM ntable WHERE id IN (SELECT id FROM table5);
+----+
| id |
+----+
| 1 |
| 2 |
| 3 |
| 4 |
| 6 |
+----+
5 rows in set (0.00 sec)
6.过滤(查询\AND\OR()\IN)
不进行过滤的数据非常大，导致通过网络传输了多余的数据，从而浪费了网络带宽。
因此尽量使用 SQL 语句来过滤不必要的数据，使得少量有用的数据传送到客户端。
mysql> SELECT * FROM table5
WHERE col IS NULL;
+----+-------+-------+------+
| id | col1 | col3 | col |
+----+-------+-------+------+
| 2 | 21 | 23 | NULL |
| 3 | 21 | 23 | NULL |
| 4 | 21 | 23 | NULL |
| 6 | 1 | 5 | NULL |
| 7 | 11111 | 33333 | NULL |
+----+-------+-------+------+
5 rows in set (0.00 sec)
mysql> SELECT * FROM table5
WHERE col IS NOT NULL ;
+----+-------+-------+------+
| id | col1 | col3 | col |
+----+-------+-------+------+
| 1 | 21 | 23 | 123 |
| 8 | 11111 | 33333 | 0 |
+----+-------+-------+------+
2 rows in set (0.00 sec)
mysql> SELECT * FROM table5
WHERE col > 100 OR col = 0;
+----+-------+-------+------+
| id | col1 | col3 | col |
+----+-------+-------+------+
| 1 | 21 | 23 | 123 |
| 8 | 11111 | 33333 | 0 |
+----+-------+-------+------+
2 rows in set (0.00 sec)
可以结合＝、<、<=、BETWEEN、IS NULL等等进行过滤；
AND 和 OR 用于连接多个过滤条件。优先处理 AND，当一个过滤表达式涉及到多个 AND 和 OR 时，可以使用 () 来决定优先级，使得优先级关系更清晰。
IN 操作符用于匹配一组值，其后也可以接一个 SELECT 子句，从而匹配子查询得到的一组值。
NOT 操作符用于否定一个条件。
6.1 索引
创建普通索引：
语法：create index 索引名称 on 表名称(字段1,字段2,…);
create index wintionIndex on winton(name);
创建唯一索引：unique index 要求列中数据唯一，不能出现重复
语法：create unique index 索引名 on 表名称(字段1,字段2,…);
create unique index wintonIndex on winton(id);
移除索引：
语法：drop index 索引名 on 表名称;
drop index wintonIndex on winton;
7.排序(ORDER\BY\ASC\DESC)
ASC:升序；
DESC:降序列；
可以按多个列进行排序，并且为每个列指定不同的排序方式；
mysql> SELECT *
FROM table5
ORDER BY col1 DESC,col3 ASC,col DESC;
+----+-------+-------+------+
| id | col1 | col3 | col |
+----+-------+-------+------+
| 8 | 11111 | 33333 | 0 |
| 7 | 11111 | 33333 | NULL |
| 1 | 21 | 23 | 123 |
| 2 | 21 | 23 | NULL |
| 3 | 21 | 23 | NULL |
| 4 | 21 | 23 | NULL |
| 6 | 1 | 5 | NULL |
+----+-------+-------+------+
7 rows in set (0.00 sec)
8.通配符(%_[]^)
通配符也是用在过滤语句中，但它只能用于文本字段。通配符位于开头处匹配会非常慢(慎用)；
% 匹配 >=0个任意字符；
_ 匹配 ==1个任意字符；
[]可以匹配集合内的字符，例如 [ab] 将匹配字符 a 或者 b;
用脱字符 ^ 可以对其进行否定，也就是不匹配集合内的字符;
- 使用LIKE关键字进行匹配：
SELECT * FROM table5
WHERE col3 LIKE '[^ab]';
9.计算字段(AS\CONCAT()\TRIM())
在数据库服务器上完成数据的转换和格式化的工作往往比客户端上快得多，并且转换和格式化后的数据量更少的话可以减少网络通信量;
mysql> SELECT * FROM table5;
+----+-------+-------+------+
| id | col1 | col3 | col |
+----+-------+-------+------+
| 1 | 21 | 23 | 123 |
| 2 | 21 | 23 | NULL |
| 3 | 21 | 23 | NULL |
| 4 | 21 | 23 | NULL |
| 6 | 1 | 5 | NULL |
| 7 | 11111 | 33333 | NULL |
| 8 | 11111 | 33333 | 0 |
+----+-------+-------+------+
7 rows in set (0.00 sec)
mysql> SELECT col1 * col3 AS alias
-> FROM table5;
+-----------+
| alias |
+-----------+
| 483 |
| 483 |
| 483 |
| 483 |
| 5 |
| 370362963 |
| 370362963 |
+-----------+
7 rows in set (0.01 sec)
CONCAT() 用于连接两个字段。许多数据库会使用空格把一个值填充为列宽，因此连接的结果会出现一些不必要的空格，使用 TRIM() 可以去除首尾空格。
mysql> SELECT CONCAT(col1,col3) AS concat_col
-> FROM table5;
+------------+
| concat_col |
+------------+
| 2123 |
| 2123 |
| 2123 |
| 2123 |
| 15 |
| 1111133333 |
| 1111133333 |
+------------+
7 rows in set (0.00 sec)
mysql> SELECT CONCAT(TRIM(col1),'(',TRIM(col3),')') AS concat_col FROM table5;
+--------------+
| concat_col |
+--------------+
| 21(23) |
| 21(23) |
| 21(23) |
| 21(23) |
| 1(5) |
| 11111(33333) |
| 11111(33333) |
+--------------+
7 rows in set (0.00 sec)
10.常用函数(AVG\COUNT\MAX\MIN\SUM\DISTINCT)
各个 DBMS 的函数都是不相同的，因此不可移植，以下主要是 MySQL 的函数。
| 函数 | 说明 |
|---|---|
| SELECT AVG(col1) FROM table5; | 求取某列的平均值(会忽略空行) |
| COUNT() | 返回某列的行数(有值的行数)； |
| MAX() | 返回某列的最大值 |
| MIN() | 返回某列的最小值 |
| SUM() | 返回某列之和 |
使用DISTINCT可以汇总不同的值:相同的值只出现一次；
mysql> SELECT AVG(col3) AS avg_col FROM table5;
+-----------+
| avg_col |
+-----------+
| 9537.5714 |
+-----------+
1 row in set (0.00 sec)
10.1 文本处理(LEFT\RIGHT\LOWER\UPPER\LTRIM\RTRIM\LENGTH)
| 函数 | 说明 |
|---|---|
| LEFT(字段名，number) | 该字段左边number个字符 |
| RIGHT() | 右边字符 |
| LOWER(字段名) | 转化为小写字符 |
| UPPER() | 转换为大写字符 |
| LTRIM() | 去除左边的空格 |
| RTRIM() | 去除右边的空格 |
| LENGTH() | 长度 |
| SOUNDEX() | 转换为语音值 |
其中， SOUNDEX() 可以将一个字符串转换为描述其语音表示的字母数字模式。
mysql> SELECT * FROM table5 WHERE SOUNDEX(col)= SOUNDEX('aNC');
+----+------+------+------+
| id | col1 | col3 | col |
+----+------+------+------+
| 9 | 1 | 123 | aNC |
+----+------+------+------+
1 row in set (0.00 sec)
mysql> SELECT LEFT(col1,3) FROM table5;
+--------------+
| LEFT(col1,3) |
+--------------+
| 21 |
| 21 |
| 21 |
| 21 |
| 1 |
| 111 |
| 111 |
| 1 |
+--------------+
8 rows in set (0.00 sec)
mysql> SELECT LEFT(col1,3) FROM table5 WHERE id=7;
+--------------+
| LEFT(col1,3) |
+--------------+
| 111 |
+--------------+
10.2 日天和时间处理
处理日期的函数很多，需要自行查找；
mysql> SELECT NOW();
+---------------------+
| NOW() |
+---------------------+
| 2020-06-26 11:23:15 |
+---------------------+
1 row in set (0.00 sec)
10.3 数值处理
| 函数 | 说明 |
|---|---|
| SIN() | 正弦 |
| COS() | 余弦 |
| TAN() | 正切 |
| ABS() | 绝对值 |
| SQRT() | 平方根 |
| MOD() | 余数 |
| EXP() | 指数 |
| PI() | 圆周率 |
| RAND() | 随机数 |
11.分组(GROUP\BY)
把具有相同的数据值的行放在同一组中。
可以对同一分组数据使用汇总函数进行处理，例如求分组数据的平均值等。
指定的分组字段除了能按该字段进行分组，也会自动按该字段进行排序。
mysql> SELECT col1, COUNT(*) AS num
FROM table5
GROUP BY col1;
+-------+-----+
| col1 | num |
+-------+-----+
| 1 | 2 |
| 21 | 4 |
| 11111 | 2 |
+-------+-----+
3 rows in set (0.00 sec)
GROUP BY自动按分组字段进行排序，ORDER BY也可以按汇总字段来进行排序；
mysql> SELECT col1,
COUNT(*) AS num
FROM table5
GROUP BY col1
-> ORDER BY num;
+-------+-----+
| col1 | num |
+-------+-----+
| 1 | 2 |
| 11111 | 2 |
| 21 | 4 |
+-------+-----+
3 rows in set (0.00 sec)
WHERE 过滤行，HAVING 过滤分组，行过滤应该先与分组过滤；
mysql> SELECT col1, COUNT(*) AS num
FROM table5
WHERE col1>1
GROUP BY col1
HAVING num<4;
+-------+-----+
| col1 | num |
+-------+-----+
| 11111 | 2 |
+-------+-----+
1 row in set (0.00 sec)
分组规定：
OROUP By子句出现在WHERE子句之后，ORDER BY子句之前；
除了汇总字段外，SELECT语句中的每一个字段都必须在GROUP BY子句中给出；
NULL的行会单独分为一组；
大多数 SQL 实现不支持 GROUP BY 列具有可变长度的数据类型。
12.子查询
子查询中只能返回一个字段的数据；
mysql> SELECT * FROM table5;
+----+-------+-------+------+
| id | col1 | col3 | col |
+----+-------+-------+------+
| 1 | 21 | 23 | 123 |
| 2 | 21 | 23 | NULL |
| 3 | 21 | 23 | NULL |
| 4 | 21 | 23 | NULL |
| 6 | 1 | 5 | NULL |
| 7 | 11111 | 33333 | NULL |
| 8 | 11111 | 33333 | 0 |
| 9 | 1 | 123 | aNC |
+----+-------+-------+------+
8 rows in set (0.00 sec)
mysql> SELECT *
FROM table5
WHERE col IN (SELECT col3
FROM table5);
+----+------+------+------+
| id | col1 | col3 | col |
+----+------+------+------+
| 1 | 21 | 23 | 123 |
+----+------+------+------+
1 row in set, 8 warnings (0.00 sec)
下面的语句可以检索出客户的订单数量，子查询语句会对第一个查询检索出的每个客户执行一次：
SELECT cust_name, (SELECT COUNT(*)
FROM Orders
WHERE Orders.cust_id = Customers.cust_id)
AS orders_num
FROM Customers
ORDER BY cust_name;
13.连接(INNER JOIN\ON\NATURAL JOIN\LEFT OUTER JOIN)
连接用于连接多个表，使用 JOIN 关键字，并且条件语句使用 ON 而不是 WHERE。
连接可以替换子查询，并且比子查询的效率一般会更快。
可以用 AS 给列名、计算字段和表名取别名，给表名取别名是为了简化 SQL 语句以及连接相同表。
内连接：INNER JOIN
内连接又称等值连接，使用INNER JOIN关键字；
SELECT A.value, B.value
FROM tablea AS A INNER JOIN tableb AS B
ON A.key = B.key;
可以不明确使用 INNER JOIN，而使用普通查询并在 WHERE 中将两个表中要连接的列用等值方法连接起来。
SELECT A.value, B.value
FROM tablea AS A, tableb AS B
WHERE A.key = B.key;
== 自连接==：
自连接可以看成内连接的一种，只是连接的表是自身而已。
一张员工表，包含员工姓名和员工所属部门，要找出与 Jim 处在同一部门的所有员工姓名。
子查询版本
SELECT name
FROM employee
WHERE department = (
SELECT department
FROM employee
WHERE name = "Jim");
自连接版本
SELECT e1.name
FROM employee AS e1 INNER JOIN employee AS e2
ON e1.department = e2.department
AND e2.name = "Jim";
自然连接 ： NATURAL JOIN
自然连接是把同名列通过等值测试连接起来的，同名列可以有多个。
内连接和自然连接的区别：内连接提供连接的列，而自然连接自动连接所有同名列。
SELECT A.value, B.value
FROM tablea AS A NATURAL JOIN tableb AS B;
外连接：LEFT OUTER JOIN
外连接保留了没有关联的那些行。分为左外连接，右外连接以及全外连接，左外连接就是保留左表没有关联的行。
检索所有顾客的订单信息，包括还没有订单信息的顾客。
SELECT Customers.cust_id, Customer.cust_name, Orders.order_id
FROM Customers LEFT OUTER JOIN Orders
ON Customers.cust_id = Orders.cust_id;
customers 表：
| cust_id | cust_name |
|---|---|
| 1 | a |
| 2 | b |
| 3 | c |
orders 表：
| order_id | cust_id |
|---|---|
| 1 | 1 |
| 2 | 1 |
| 3 | 3 |
| 4 | 3 |
结果：
| cust_id | cust_name | order_id |
|---|---|---|
| 1 | a | 1 |
| 1 | a | 2 #order表cust_id有两个1 |
| 3 | c | 3 |
| 3 | c | 4 #order表cust_id有两个3 |
| 2 | b | Null #该行为中间没有满足要求的行对于customers表 |
14、视图(CREATE VIEW \AS)
视图是虚拟的表，本身不包含数据，也就不能对其进行索引操作。视图类似与创建新表；
对视图的操作和对普通表的操作一样。
视图具有如下好处：
- 简化复杂的 SQL 操作，比如复杂的连接；
- 只使用实际表的一部分数据；
- 通过只给用户访问视图的权限，保证数据的安全性；
- 更改数据格式和表示。
CREATE VIEW myview AS
SELECT Concat(col1, col2) AS concat_col, col3*col4 AS compute_col
FROM mytable
WHERE col5 = val;
15.存储过程
存储过程可以看成是对一系列 SQL 操作的批处理。
使用存储过程的好处：
- 代码封装，保证了一定的安全性；
- 代码复用；
- 由于是预先编译，因此具有很高的性能。
命令行中创建存储过程需要自定义分隔符，因为命令行是以 ; 为结束符，而存储过程中也包含了分号，因此会错误把这部分分号当成是结束符，造成语法错误。
包含 in、out 和 inout 三种参数。
给变量赋值都需要用 select into 语句。
每次只能给一个变量赋值，不支持集合的操作。
16.游标
在存储过程中使用游标可以对一个结果集进行移动遍历。
游标主要用于交互式应用，其中用户需要对数据集中的任意行进行浏览和修改。
使用游标的四个步骤：
- 声明游标，这个过程没有实际检索出数据；
- 打开游标；
- 取出数据；
- 关闭游标；
17.触发器
触发器会在某个表执行以下语句时而自动执行：DELETE、INSERT、UPDATE。
触发器必须指定在语句执行之前还是之后自动执行，之前执行使用 BEFORE 关键字，之后执行使用 AFTER 关键字。BEFORE 用于数据验证和净化，AFTER 用于审计跟踪，将修改记录到另外一张表中。
18 .事物管理
基本术语：
- 事务（transaction）指一组 SQL 语句；
- 回退（rollback）指撤销指定 SQL 语句的过程；
- 提交（commit）指将未存储的 SQL 语句结果写入数据库表；
- 保留点（savepoint）指事务处理中设置的临时占位符（placeholder），你可以对它发布回退（与回退整个事务处理不同）。
不能回退 SELECT 语句，回退 SELECT 语句也没意义；也不能回退 CREATE 和 DROP 语句。
MySQL 的事务提交默认是隐式提交，每执行一条语句就把这条语句当成一个事务然后进行提交。当出现 START TRANSACTION 语句时，会关闭隐式提交；当 COMMIT 或 ROLLBACK 语句执行后，事务会自动关闭，重新恢复隐式提交。
设置 autocommit 为 0 可以取消自动提交；autocommit 标记是针对每个连接而不是针对服务器的。
如果没有设置保留点，ROLLBACK 会回退到 START TRANSACTION 语句处；如果设置了保留点，并且在 ROLLBACK 中指定该保留点，则会回退到该保留点。
19.二十二、字符集
基本术语：
- 字符集为字母和符号的集合；
- 编码为某个字符集成员的内部表示；
- 校对字符指定如何比较，主要用于排序和分组。
20.用户权限
MySQL 的账户信息保存在 mysql 这个数据库中。
USE mysql;
SELECT user FROM user;
创建账户
新创建的账户没有任何权限。
CREATE USER myuser IDENTIFIED BY 'mypassword';
修改账户名
RENAME USER myuser TO newuser;
删除账户
DROP USER myuser;
查看权限
SHOW GRANTS FOR myuser;
授予权限
账户用 username@host 的形式定义，username@% 使用的是默认主机名。
GRANT SELECT, INSERT ON mydatabase.* TO myuser;
删除权限
GRANT 和 REVOKE 可在几个层次上控制访问权限：
- 整个服务器，使用 GRANT ALL 和 REVOKE ALL；
- 整个数据库，使用 ON database.*；
- 特定的表，使用 ON ；
- 特定的列；
- 特定的存储过程。
REVOKE SELECT, INSERT ON mydatabase.* FROM myuser;
更改密码
必须使用 Password() 函数进行加密。
SET PASSWROD FOR myuser = Password('new_password');
参考