1、mysql添加记录
--添加记录的语法(可添加单条记录或者多条记录)，INTO是可以省略的，字段名也可以省略的，但是如果省略的话，后面对应的value的值就要全部填写
INSERT [INTO] tab_name [(col_name,...)] {VALUE|VALUES} (values...);
--添加记录的语法(只可添加一条记录)
INSERT tab_name SET 字段名称=字段值,...;
--从表中查询记录进行添加
INSERT tab_name SELECT 字段名称 FROM tab1_name [WHERE 条件]
注意：通常情况下，以上语句在使用values插入单行数据的时候效率要比value来得高，但是插入多行数据的时候效率value要比values来得高，set与value|values相比效率要来得高，但是set是mysql的扩展，对于其他数据库是不存在的，所以可移值性比较低，并且set一次只能添加一条数据。
举例：
--测试用表
CREATE TABLE IF NOT EXISTS test(
id INT UNSIGNED PRIMARY KEY AUTO_INCREMENT COMMENT '用户ID',
name VARCHAR(20) NOT NULL COMMENT '用户名',
sex ENUM('','','') NOT NULL DEFAULT '' COMMENT '性别0保密，1男，2女'
)ENGINE=INNODB CHARSET=UTF8; --指定值
INSERT INTO test (name,sex) VALUES ('AA','');
--不指定值,那么所对应的所有的值要全部写出来
INSERT test VALUES (NULL,'BB','');
--插入多条记录,中间用逗号隔开,注意中英文状下的逗号
INSERT test (name,sex) VALUE ('CC',''),('DD',''),('EE',''),('FF','');
--应用set来添加数据
INSERT test SET name="GG",sex="2";
--进行批量插入
INSERT user (name,sex) SELECT name,sex FROM test WHERE sex="1"
2、修改记录
--更改记录的语法(有点类似INSERT..SET)
UPDATE tab_name SET 字段名=字段值,...[WHERE 条件];
注意：如果没有指定where那么整张表的数据都会被更改。
--在id<3的名字后面加上ok，并且把性别改成默认值（默认值可以用DEFAULT来代替）
UPDATE test SET name=CONCAT(name,'ok'),sex=DEFAULT WHERE id<=3;
--SELECT * FROM test 输出
-- +----+------+-----+
-- | id | name | sex |
-- +----+------+-----+
-- | 1 | AAok | 0 |
-- | 2 | BBok | 0 |
-- | 3 | CCok | 0 |
-- | 4 | DD | 2 |
-- | 5 | EE | 1 |
-- | 6 | FF | 0 |
-- | 7 | GG | 2 |
-- +----+------+-----+
批量更新数据表
使用MYSQL自带语句进行批量更新
-- 使用update set 进行批量更新,注意：如果是多个条件的时候，每个条件的长度应该要相等
UPDATE tab_name SET 需修改的字段=CASE 参照字段 WHEN 参数字段值 THEN 修改字段值 ... END,...END [WHERE 条件];
-- 举例，根据id修改名字和年龄
UPDATE user SET name = CASE id WHEN 1 THEN "AA" WHEN 2 THEN "BB" END,age=CASE id WHEN 1 THEN 18 WHEN 2 THEN 22 END WHERE id IN (1,2); -- 查询修改记录，当查询到目标记录的时候进行修改，如果没有查询到则进行插入
INSERT INTO tab_name (字段名,...) VALUE (值,...) ON DUPLICATE KEY UPDATE 字段名=VALUES(字段名);
-- 举例,注意：需要更改的字段放在ON DUPLICATE KEY UPDATE 后面
INSERT INTO `user` (id,name,age) VALUES (1,"小A",8),(2,"小B",18),(3,"小C",28),(4,"小D",38) ON DUPLICATE KEY UPDATE `name`=VALUES(name),age=VALUES(age); --谨慎使用 使用replace into 进行批量更新，注意该操作本质是对重复的记录先delete 后insert，如果更新的字段不全会将缺失的字段置为缺省值
REPLACE INTO tab_name (字段名,...) VALUE (值,...);
-- 举例,如果在表中的唯一值里能匹配到相关的数据,那么会进行修改操作，否则会进行添加操作
REPLACE INTO user (id,name,age) VALUE (1,"CC",12),(2,"DD",27);
3、删除记录
--删除记录的语法,如果不添加条件,那么会删除全部记录
DELETE FROM tab_name [WHERE 条件];
--删除记录，同时也可以重置AUTO_INCREMENT的值
TRUNCATE [TABLE] tab_name
注意：如果不添加条件,那么会删除全部记录，但是通过delete删除的全部记录，不会重置AUTO_INCREMENT的值，但是可以通过ALTER TABLE tab_name AUTO_INCREMENT=1 进行设置
--删除所有ID大于3的记录
DELETE FROM test WHERE id>3;
--SELECT * FROM test 输出
-- +----+------+-----+
-- | id | name | sex |
-- +----+------+-----+
-- | 1 | AAok | 0 |
-- | 2 | BBok | 0 |
-- | 3 | CCok | 0 |
-- +----+------+-----+
4、查询记录
--查询记录的基本语法
SELECT select_expr,...FROM tab_name
[WHERE 条件]
[GROUP BY {col_name | position} HAVING 二次筛选]
[ORDER BY {col_name |position|expr} [ASC | DESC]]
[LIMIT 限制结果集的显示条数]
[OFFSET 偏移量]
--可以使用库名.表名的形式查询数据(即可以不指定当前数据库的情况下进行表查询)
SELECT select_expr,...FROM db_name.tab_name --可以给字段或者表名起别名(可以通过AS或者空隔对表名或者字段名进行起别名)
SELECT col_name AS col_rename,... FROM tab_name AS tab_rename
--建议要用AS来分隔，这个比较容易区分
SELECT col_name col_rename,... FROM tab_name tab_rename
注意:建议在起别名的时候,要加上AS以免引起混乱，并且在起别名的时候，要在字段上加上别名.字段，以免在以后在多表联查时避免错误。
select distinct * from `表名`；
--以上面建的表为例
SELECT * FROM ytest.test;
-- 输出
-- +----+------+-----+
-- | id | name | sex |
-- +----+------+-----+
-- | 1 | AAok | 0 |
-- | 2 | BBok | 0 |
-- | 3 | CCok | 0 |
-- +----+------+-----+ --给字段起别名
SELECT t.name AS text,t.sex AS ss FROM ytest.test AS t;
-- 输出
-- +------+----+
-- | text | ss |
-- +------+----+
-- | AAok | 0 |
-- | BBok | 0 |
-- | CCok | 0 |
-- +------+----+
distinct与sum,count一起使用
-- 原数组
-- +----+------+-------+-----+-------+
-- | id | name | score | sex | class |
-- +----+------+-------+-----+-------+
-- | 1 | aaa | 80 | 女 | 二班 |
-- | 2 | bbb | 30 | 男 | 二班 |
-- | 3 | ccc | 40 | 女 | 二班 |
-- | 4 | ddd | 50 | 男 | 一班 |
-- | 5 | eee | 80 | 男 | 一班 |
-- | 6 | fff | 70 | 女 | 一班 |
-- | 1 | aaa | 80 | 女 | 二班 |
-- +----+------+-------+-----+-------+
SELECT SUM(DISTINCT `score`), COUNT(DISTINCT `score`) FROM `worker`;
-- 输出
-- +-----------------------+-------------------------+
-- | SUM(DISTINCT `score`) | COUNT(DISTINCT `score`) |
-- +-----------------------+-------------------------+
-- | 270 | 5 |
-- +-----------------------+-------------------------+
5、WHERE 的条件筛选(WHERE 条件会查询筛选出符合条件的记录，如果没有符合条件的记录，那么就会返回空记录)
a、where条件的比较运算符：= > >= < <= != <> <=>
--为原表添加一个字段
ALTER TABLE test ADD tDesc VARCHAR(30) COMMENT "描述";
--查询id=2的记录，其他用法也是一样的
SELECT id,name,sex FROM test WHERE id=2;
--查询是否为空值
SELECT id,name FROM test WHERE tDesc IS NULL;
SELECT id,name FROM test WHERE tDesc <=> NULL;
--查询不为空值
SELECT id,name FROM test WHERE tDesc IS NOT NULL;
注意：<=>与=的用法基本一样，但是<=>是可以检测是否为NULL值，但是=不可以检测，同时<=>是MYSQL独有的语法，在其他语言不可以使用，而=可以通用
b、逻辑运算符：AND(逻辑与) OR(逻辑或) NOT(逻辑非) BETWEEN...AND...(介于两者之间)
-- 举例
SELECT id,name FROM test WHERE id<=2 AND sex='';
-- 注意这个BETWEEN...AND...是包含1和2的
SELECT id,name FROM test WHERE id BETWEEN 1 AND 2;
-- NOT 举例
SELECT id,name FROM test WHERE NOT (id = 1);
c、模糊查询like和 not like的使用
通配符%表示匹配0个1个或者多个字符，通配符_表示匹配一个字符
-- 匹配A前后有任意个字符的情况
SELECT id,name FROM test WHERE name LIKE "%A%";
-- 匹配A前有一个字付，后面任意个字符的情况
SELECT id,name FROM test WHERE name LIKE "_A%";
-- 匹配A前有一个字付，后面至少一个字符的情况
SELECT id,name FROM test WHERE name LIKE "_A_%";
6、GROUP BY 分组
group by 把值相同的放到一个组中，最终查询出的结果只会显示组中的一条记录
--举例
--的按照性别分组，group by 的值段可以没有在SELECT 里面
SELECT id,name,sex FROM test GROUP BY sex;
--展示效果
-- +----+------+-----+
-- | id | name | sex |
-- +----+------+-----+
-- | 10 | CC | 0 |
-- | 8 | AA | 1 |
-- | 9 | BB | 2 |
-- +----+------+-----+
注意，如果 需要看组中的成员，那么可以用到函数GROUP_CONCAT
--查看组中的成员
SELECT id,GROUP_CONCAT(name),GROUP_CONCAT(sex) FROM test Group BY sex;
--输出
-- +----+--------------------+-------------------+
-- | id | GROUP_CONCAT(name) | GROUP_CONCAT(sex) |
-- +----+--------------------+-------------------+
-- | 10 | CC,EE | 0,0 |
-- | 8 | AA,DD,GG | 1,1,1 |
-- | 9 | BB,FF | 2,2 |
-- +----+--------------------+-------------------+
GROUP BY 配合聚合函数使用
COUNT() 计数 SUM()求和 MAX() 最大值 MIN()最小值 AVG() 平均值
COUNT(col_name)与COUNT(*)的最大区别是，前者如果遇到值为null的时候，则不会计入范围，而后者会。所以后者可以作为统计总数用。
GROUP BY 与COUNT(*)结合的例子
--查看组中的成员，同时统计数量
SELECT sex,GROUP_CONCAT(name),COUNT(*) FROM test GROUP BY(sex);
--输出
-- +-----+--------------------+----------+
-- | sex | GROUP_CONCAT(name) | COUNT(*) |
-- +-----+--------------------+----------+
-- | 0 | CC,EE | 2 |
-- | 1 | AA,DD,GG | 3 |
-- | 2 | BB,FF | 2 |
-- +-----+--------------------+----------+
GROUP BY 与SUM() , MAX() , MIN() , AVG() ,COUNT() 配合使用
--按性别分组，查看组中成员，个数，年龄总和，平均年龄，最小年龄，最大年龄
SELECT GROUP_CONCAT(name),COUNT(*),SUM(age),AVG(age),MAX(age),MIN(age) FROM test GROUP BY sex;
--输出
-- +--------------------+----------+----------+----------+----------+----------+
-- | GROUP_CONCAT(name) | COUNT(*) | SUM(age) | AVG(age) | MAX(age) | MIN(age) |
-- +--------------------+----------+----------+----------+----------+----------+
-- | CC,EE | 2 | 85 | 42.5000 | 47 | 38 |
-- | AA,DD,GG | 3 | 103 | 34.3333 | 78 | 7 |
-- | BB,FF | 2 | 48 | 24.0000 | 26 | 22 |
-- +--------------------+----------+----------+----------+----------+----------+
SELECT COUNT(IF(`score`>,,NULL)) FROM `worker`;
-- 输出
-- +------------------------------+
-- | COUNT(IF(`score`>50,1,NULL)) |
-- +------------------------------+
-- | 2 |
-- +------------------------------+
sum 函数在对单列进行求和时如果有Null值，是不影响值，当对多列进行sum统计时，就会有错误。
注意：如果GROUP BY 在和WHERE 使用的时候，WHERE 应该要放在GROUP BY 前面，不然会报错的。
--先查询年龄大小20岁的并按性别分组，查看组中成员，个数，年龄总和，平均年龄，最小年龄，最大年龄
SELECT GROUP_CONCAT(name),COUNT(*),SUM(age),AVG(age),MAX(age),MIN(age) FROM test WHERE age>20 GROUP BY sex;
--输出
-- +--------------------+----------+----------+----------+----------+----------+
-- | GROUP_CONCAT(name) | COUNT(*) | SUM(age) | AVG(age) | MAX(age) | MIN(age) |
-- +--------------------+----------+----------+----------+----------+----------+
-- | CC,EE | 2 | 85 | 42.5000 | 47 | 38 |
-- | GG | 1 | 78 | 78.0000 | 78 | 78 |
-- | BB,FF | 2 | 48 | 24.0000 | 26 | 22 |
-- +--------------------+----------+----------+----------+----------+----------+
注意：如果对分组后的数据进行二次筛选，那么可以使用HAVING，并且HAVING要放在GROUP BY 后面，不然会报错的，HAVING与WHERE的不同之处在于后者不能对AS后的字段不能选择，而前者不能对未SELECT的字段进行选择。
--按性别分组，查看组中成员，个数，年龄总和，平均年龄，最小年龄，最大年龄,并且筛选年龄总和大于50的组
SELECT GROUP_CONCAT(name),COUNT(*),SUM(age) AS total,AVG(age),MAX(age),MIN(age) FROM test GROUP BY sex HAVING total>50;
--输出
-- +--------------------+----------+-------+----------+----------+----------+
-- | GROUP_CONCAT(name) | COUNT(*) | total | AVG(age) | MAX(age) | MIN(age) |
-- +--------------------+----------+-------+----------+----------+----------+
-- | CC,EE | 2 | 85 | 42.5000 | 47 | 38 |
-- | AA,DD,GG | 3 | 103 | 34.3333 | 78 | 7 |
-- +--------------------+----------+-------+----------+----------+----------+
在GROUP BY 后面 WITH ROLLUP 进行数据汇总,相当于把上面的值按一组情况进行统计
--按性别分组，查看组中成员，个数，年龄总和，平均年龄，最小年龄，最大年龄,并且进行全部数据的汇总
SELECT GROUP_CONCAT(name),COUNT(*),SUM(age),AVG(age),MAX(age),MIN(age) FROM test GROUP BY sex WITH ROLLUP;
--输出
-- +----------------------+----------+----------+----------+----------+----------+
-- | GROUP_CONCAT(name) | COUNT(*) | SUM(age) | AVG(age) | MAX(age) | MIN(age) |
-- +----------------------+----------+----------+----------+----------+----------+
-- | CC,EE | 2 | 85 | 42.5000 | 47 | 38 |
-- | AA,DD,GG | 3 | 103 | 34.3333 | 78 | id 7 |
-- | BB,FF | 2 | 48 | 24.0000 | 26 | 22 |
-- | CC,EE,AA,DD,GG,BB,FF | 7 | 236 | 33.7143 | 78 | 7 |
-- +----------------------+----------+----------+----------+----------+----------+
GROUP BY 也是可以进行多个分组统计的（中间用逗号隔开）
-- 数据源
+----+------+-------+-----+-------+
| id | name | score | sex | class |
+----+------+-------+-----+-------+
| 1 | aaa | 80 | 女 | 二班 |
| 2 | bbb | 30 | 男 | 二班 |
| 3 | ccc | 40 | 女 | 二班 |
| 4 | ddd | 50 | 男 | 一班 |
| 5 | eee | 80 | 男 | 一班 |
+----+------+-------+-----+-------+
SELECT `sex`, `class`, AVG(`score`) FROM `worker` GROUP BY `sex`, `class`;
-- 输出
-- +-----+-------+------------+
-- | sex | class | avg(score) |
-- +-----+-------+------------+
-- | 男 | 一班 | 65.0000 |
-- | 男 | 二班 | 30.0000 |
-- | 女 | 二班 | 60.0000 |
-- +-----+-------+------------+
SELECT GROUP_CONCAT(`name`) AS "name",GROUP_CONCAT(`score`) AS "score",GROUP_CONCAT(`sex`) AS "sex",GROUP_CONCAT(`class`) AS "class",MAX(`score`),AVG(`score`) FROM `worker` GROUP BY `sex`,`class`;
-- 输出
-- +---------+-------+-------+-----------+--------------+--------------+
-- | name | score | sex | class | MAX(`score`) | AVG(`score`) |
-- +---------+-------+-------+-----------+--------------+--------------+
-- | ddd,eee | 50,80 | 男,男 | 一班,一班 | 80 | 65.0000 |
-- | bbb | 30 | 男 | 二班 | 30 | 30.0000 |
-- | aaa,ccc | 80,40 | 女,女 | 二班,二班 | 80 | 60.0000 |
-- +---------+-------+-------+-----------+--------------+--------------+
7、ORDER BY 进行排序
ORDER BY 对数据进行排序 语法:ORDER BY 字段名 ASC|DESC 默认是ASC 升序，DESC 降序,同时也可以按照多个字段排序（如果两个字段相等的情况下）两个排序有逗号隔开,如果按照随机排序，那么用ORDER BY RAND() 即可
--按照年龄降序排序，如果有相同的情况下按照ID升序排序
SELECT * FROM test ORDER BY age DESC,id ASC;
-- 输出
-- +----+------+-----+-----+
-- | id | name | sex | age |
-- +----+------+-----+-----+
-- | 14 | GG | 1 | 78 |
-- | 12 | EE | 0 | 47 |
-- | 10 | CC | 0 | 38 |
-- | 13 | FF | 2 | 26 |
-- | 9 | BB | 2 | 22 |
-- | 8 | AA | 1 | 18 |
-- | 11 | DD | 1 | 7 |
-- +----+------+-----+-----+ -- 按照年龄随机排序
SELECT * FROM test ORDER BY RAND();
-- 输出
-- +----+------+-----+-----+
-- | id | name | sex | age |
-- +----+------+-----+-----+
-- | 8 | AA | 1 | 18 |
-- | 14 | GG | 1 | 78 |
-- | 10 | CC | 0 | 38 |
-- | 11 | DD | 1 | 7 |
-- | 9 | BB | 2 | 22 |
-- | 12 | EE | 0 | 47 |
-- | 13 | FF | 2 | 26 |
-- +----+------+-----+-----+
8、LIMIT , OFFSET 限制结果集显示条数
LIMIT+一个值 => 显示结果集的前几条数据；
LIMIT+offset+row_count=> 从offset开始，显示row_count条数据
LIMIT +row_count OFFSET +offset => 意思同上(注意:offset要放在limit的后面,否则会报错)
--数据正常显示
-- +----+------+-----+-----+
-- | id | name | sex | age |
-- +----+------+-----+-----+
-- | 8 | AA | 1 | 18 |
-- | 9 | BB | 2 | 22 |
-- | 10 | CC | 0 | 38 |
-- | 11 | DD | 1 | 7 |
-- | 12 | EE | 0 | 47 |
-- | 13 | FF | 2 | 26 |
-- | 14 | GG | 1 | 78 |
-- +----+------+-----+-----+
--用LIMIT+数值
SELECT * FROM test ORDER BY id DESC LIMIT 3;
-- 输出
-- +----+------+-----+-----+
-- | id | name | sex | age |
-- +----+------+-----+-----+
-- | 14 | GG | 1 | 78 |
-- | 13 | FF | 2 | 26 |
-- | 12 | EE | 0 | 47 |
-- +----+------+-----+-----+ --用LIMIT+offset+row_count
SELECT * FROM test ORDER BY id LIMIT 3,2;
-- 输出
-- +----+------+-----+-----+
-- | id | name | sex | age |
-- +----+------+-----+-----+
-- | 11 | DD | 1 | 7 |
-- | 12 | EE | 0 | 47 |
-- +----+------+-----+-----+ --利用LIMIT+row_count OFFSET+offset
SELECT * FROM test ORDER BY id ASC LIMIT 2 OFFSET 3;
-- 输出
-- +----+------+-----+-----+
-- | id | name | sex | age |
-- +----+------+-----+-----+
-- | 11 | DD | 1 | 7 |
-- | 12 | EE | 0 | 47 |
-- +----+------+-----+-----+
利用limit与update ,delete进行配合使用
limit 与 update,delete 进行配合使用的时候只能用LIMIT+数值的模式,表示更新或者删除前几条数据
--limit 与 update 配合使用
UPDATE test SET age=22 LIMIT 3;
-- 输出
-- +----+------+-----+-----+
-- | id | name | sex | age |
-- +----+------+-----+-----+
-- | 8 | AA | 1 | 22 |
-- | 9 | BB | 2 | 22 |
-- | 10 | CC | 0 | 22 |
-- | 11 | DD | 1 | 7 |
-- | 12 | EE | 0 | 47 |
-- | 13 | FF | 2 | 26 |
-- | 14 | GG | 1 | 78 |
-- +----+------+-----+-----+
-- limit 与 delete 配合使用
DELETE FROM test LIMIT 1;
-- 输出
-- +----+------+-----+-----+
-- | id | name | sex | age |
-- +----+------+-----+-----+
-- | 9 | BB | 2 | 22 |
-- | 10 | CC | 0 | 22 |
-- | 11 | DD | 1 | 7 |
-- | 12 | EE | 0 | 47 |
-- | 13 | FF | 2 | 26 |
-- | 14 | GG | 1 | 78 |
-- +----+------+-----+-----+
9、多表查询
多表连接查询主要分成三部份，笛卡尔积的形式，内连接，外连接三种形式。
新建测试表
--员工表
CREATE TABLE IF NOT EXISTS user(
id INT UNSIGNED NOT NULL PRIMARY KEY AUTO_INCREMENT COMMENT "用户ID",
pid TINYINT UNSIGNED NOT NULL,
name VARCHAR(20) NOT NULL,
sex ENUM('','','') DEFAULT "0" NOT NULL,
age TINYINT UNSIGNED NOT NULL DEFAULT 0
)ENGINE=INNODB CHARSET=UTF8; --创建部门表
CREATE TABLE IF NOT EXISTS part(
id TINYINT UNSIGNED NOT NULL PRIMARY KEY AUTO_INCREMENT COMMENT '部门id',
name VARCHAR(20) NOT NULL
)ENGINE='INNODB' CHARSET=UTF8; --插入数据
INSERT part (name) VALUE ('html'),('css'),('javascript'),('php'),('java');
INSERT user (pid,name,sex,age) VALUE ('','AA','',22),('','BB','',21),('','CC','',24),('','DD','',24),('','EE','',28),('','FF','',25),('','GG','',23),('','EE','',18),('','FF','',27);
笛卡尔积的形式（进行多表查询是筛选语句不能少于n-1个）
-- 笛卡尔积连接
SELECT * FROM `emp`, `dept` WHERE emp.deptno = dept.deptno;
-- 输出
-- +-------+--------+-----------+------+------------+---------+---------+--------+--------+------------+----------+
-- | empno | ename | job | mgr | hiredate | sal | comm | deptno | deptno | dname | loc |
-- +-------+--------+-----------+------+------------+---------+---------+--------+--------+------------+----------+
-- | 7369 | SMITH | CLERK | 7902 | 1980-12-17 | 800.00 | NULL | 20 | 20 | RESEARCH | DALLAS |
-- | 7499 | ALLEN | SALESMAN | 7698 | 1981-02-20 | 1600.00 | 300.00 | 30 | 30 | SALES | CHICAGO |
-- | 7521 | WARD | SALESMAN | 7698 | 1981-02-22 | 1250.00 | 500.00 | 30 | 30 | SALES | CHICAGO |
-- | 7566 | JONES | MANAGER | 7839 | 1981-04-02 | 2975.00 | NULL | 20 | 20 | RESEARCH | DALLAS |
-- | 7654 | MARTIN | SALESMAN | 7698 | 1981-09-28 | 1250.00 | 1400.00 | 30 | 30 | SALES | CHICAGO |
-- | 7698 | BLAKE | MANAGER | 7839 | 1981-05-01 | 2850.00 | NULL | 30 | 30 | SALES | CHICAGO |
-- | 7782 | CLARK | MANAGER | 7839 | 1981-06-09 | 2450.00 | NULL | 10 | 10 | ACCOUNTING | NEW YORK |
-- | 7788 | SCOTT | ANALYST | 7566 | 1987-04-19 | 3000.00 | NULL | 20 | 20 | RESEARCH | DALLAS |
-- | 7839 | KING | PRESIDENT | NULL | 1981-11-17 | 5000.00 | NULL | 10 | 10 | ACCOUNTING | NEW YORK |
-- | 7844 | TURNER | SALESMAN | 7698 | 1981-09-08 | 1500.00 | NULL | 30 | 30 | SALES | CHICAGO |
-- | 7900 | JAMES | CLERK | 7698 | 1981-12-03 | 950.00 | NULL | 30 | 30 | SALES | CHICAGO |
-- | 7902 | FORD | ANALYST | 7566 | 1981-12-03 | 3000.00 | NULL | 20 | 20 | RESEARCH | DALLAS |
-- | 7934 | MILLER | CLERK | 7782 | 1982-01-23 | 1300.00 | NULL | 10 | 10 | ACCOUNTING | NEW YORK |
-- +-------+--------+-----------+------+------------+---------+---------+--------+--------+------------+----------+
SELECT emp.*, dept.dname FROM `emp`, `dept` WHERE emp.deptno = dept.deptno;
自连接 ：在同一张表的连接查询（就是给本表取个别名进行连接）
SELECT worker.ename, boss.ename FROM emp AS worker,emp AS boss WHERE worker.mgr=boss.empno;
-- 输出
-- +--------+-------+
-- | ename | ename |
-- +--------+-------+
-- | SCOTT | JONES |
-- | FORD | JONES |
-- | ALLEN | BLAKE |
-- | WARD | BLAKE |
-- | MARTIN | BLAKE |
-- | TURNER | BLAKE |
-- | JAMES | BLAKE |
-- | MILLER | CLARK |
-- | JONES | KING |
-- | BLAKE | KING |
-- | CLARK | KING |
-- | SMITH | FORD |
-- +--------+-------+ -- 查询和SMITH同一部门的员工
SELECT * FROM `emp` WHERE `deptno` = (SELECT `deptno` FROM `emp` WHERE `ename`="SMITH");
-- 输出
-- +-------+-------+---------+------+------------+---------+------+--------+
-- | empno | ename | job | mgr | hiredate | sal | comm | deptno |
-- +-------+-------+---------+------+------------+---------+------+--------+
-- | 7369 | SMITH | CLERK | 7902 | 1980-12-17 | 800.00 | NULL | 20 |
-- | 7566 | JONES | MANAGER | 7839 | 1981-04-02 | 2975.00 | NULL | 20 |
-- | 7788 | SCOTT | ANALYST | 7566 | 1987-04-19 | 3000.00 | NULL | 20 |
-- | 7902 | FORD | ANALYST | 7566 | 1981-12-03 | 3000.00 | NULL | 20 |
-- +-------+-------+---------+------+------------+---------+------+--------+ -- 查询10号部门都有哪些岗位，并且都有哪些员工在从事相关工作
SELECT * FROM `emp` WHERE `job` in (SELECT DISTINCT `job` FROM `emp` WHERE `deptno`=10);
-- 输出
-- +-------+--------+-----------+------+------------+---------+------+--------+
-- | empno | ename | job | mgr | hiredate | sal | comm | deptno |
-- +-------+--------+-----------+------+------------+---------+------+--------+
-- | 7369 | SMITH | CLERK | 7902 | 1980-12-17 | 800.00 | NULL | 20 |
-- | 7566 | JONES | MANAGER | 7839 | 1981-04-02 | 2975.00 | NULL | 20 |
-- | 7698 | BLAKE | MANAGER | 7839 | 1981-05-01 | 2850.00 | NULL | 30 |
-- | 7782 | CLARK | MANAGER | 7839 | 1981-06-09 | 2450.00 | NULL | 10 |
-- | 7839 | KING | PRESIDENT | NULL | 1981-11-17 | 5000.00 | NULL | 10 |
-- | 7900 | JAMES | CLERK | 7698 | 1981-12-03 | 950.00 | NULL | 30 |
-- | 7934 | MILLER | CLERK | 7782 | 1982-01-23 | 1300.00 | NULL | 10 |
-- +-------+--------+-----------+------+------------+---------+------+--------+ -- 查询和小明数学，语文，英语成绩一样的学生
SELECT * FROM `student` WHERE (`chinese`,`english`,`math`) = (SELECT `chinese`,`english`,`math` FROM `student` WHERE `name`='小明'); -- 表emp
-- +-------+--------+-----------+------+------------+---------+---------+--------+
-- | empno | ename | job | mgr | hiredate | sal | comm | deptno |
-- +-------+--------+-----------+------+------------+---------+---------+--------+
-- | 7369 | SMITH | CLERK | 7902 | 1980-12-17 | 800.00 | NULL | 20 |
-- | 7499 | ALLEN | SALESMAN | 7698 | 1981-02-20 | 1600.00 | 300.00 | 30 |
-- | 7521 | WARD | SALESMAN | 7698 | 1981-02-22 | 1250.00 | 500.00 | 30 |
-- | 7566 | JONES | MANAGER | 7839 | 1981-04-02 | 2975.00 | NULL | 20 |
-- | 7654 | MARTIN | SALESMAN | 7698 | 1981-09-28 | 1250.00 | 1400.00 | 30 |
-- | 7698 | BLAKE | MANAGER | 7839 | 1981-05-01 | 2850.00 | NULL | 30 |
-- | 7782 | CLARK | MANAGER | 7839 | 1981-06-09 | 2450.00 | NULL | 10 |
-- | 7788 | SCOTT | ANALYST | 7566 | 1987-04-19 | 3000.00 | NULL | 20 |
-- | 7839 | KING | PRESIDENT | NULL | 1981-11-17 | 5000.00 | NULL | 10 |
-- | 7844 | TURNER | SALESMAN | 7698 | 1981-09-08 | 1500.00 | NULL | 30 |
-- | 7900 | JAMES | CLERK | 7698 | 1981-12-03 | 950.00 | NULL | 30 |
-- | 7902 | FORD | ANALYST | 7566 | 1981-12-03 | 3000.00 | NULL | 20 |
-- | 7934 | MILLER | CLERK | 7782 | 1982-01-23 | 1300.00 | NULL | 10 |
-- +-------+--------+-----------+------+------------+---------+---------+--------+ -- 需求：显示高于自己部门平均工次的员工（名字，工资，部门平均工资）
SELECT
emp.ename,emp.sal,temp.avgSal
FROM `emp`, (SELECT AVG(`sal`) AS 'avgSal', `deptno` FROM `emp` GROUP BY `deptno`) AS `temp`
WHERE emp.deptno=temp.deptno AND emp.sal>temp.avgSal;
-- 以上语句等价于下以语句
SELECT
emp.ename,emp.sal,temp.avgSal
FROM `emp`
INNER JOIN (SELECT AVG(`sal`) AS avgSal, `deptno` FROM `emp` GROUP BY `deptno`) AS temp
on emp.deptno=temp.deptno
WHERE emp.deptno=temp.deptno AND emp.sal>temp.avgSal;
-- 输出
-- +-------+---------+-------------+
-- | ename | sal | avgSal |
-- +-------+---------+-------------+
-- | ALLEN | 1600.00 | 1566.666667 |
-- | JONES | 2975.00 | 2443.750000 |
-- | BLAKE | 2850.00 | 1566.666667 |
-- | SCOTT | 3000.00 | 2443.750000 |
-- | KING | 5000.00 | 2916.666667 |
-- | FORD | 3000.00 | 2443.750000 |
-- +-------+---------+-------------+
内连接：表示查询两个表中符合连接条件的记录(实际上就是利用where子句对两张（多表）形成的笛卡尔积进行筛选)
-- 语法，表示只显示两个表之间的公共部分
SELECT 字段名称,...FROM tab_name INNER JOIN tab_name2 ON 连接条件 -- 举例
SELECT u.id,u.name,u.sex,u.age,p.name FROM user AS u INNER JOIN part AS p ON u.pid=p.id;
-- 输出
-- +----+------+-----+-----+------------+
-- | id | name | sex | age | name |
-- +----+------+-----+-----+------------+
-- | 1 | AA | 2 | 22 | html |
-- | 2 | BB | 2 | 21 | html |
-- | 3 | CC | 1 | 24 | css |
-- | 8 | EE | 1 | 18 | css |
-- | 6 | FF | 2 | 25 | javascript |
-- | 9 | FF | 2 | 27 | javascript |
-- | 4 | DD | 1 | 24 | php |
-- | 7 | GG | 0 | 23 | php |
-- | 5 | EE | 1 | 28 | java |
-- +----+------+-----+-----+------------+
外连接：外连接主要分为两种连接方式，左外连接与右外连接
左外连接：先显示左表中的全部记录，再去右表中查询复合条件的记录，不符合的以NULL值代替；
右外连接：先显示右表中的全部记录，再去左表中查询复合条件的记录，不符合的以NULL 值代替；
-- 语法
SELECT 字段名称,...FROM tab_name LEFT|RIGHT JOIN tab_name2 ON 连接条件
-- 左外边接
SELECT u.id,u.name,u.age,p.name FROM user AS u LEFT JOIN part AS p on u.pid=p.id;
-- 右外边接
SELECT u.id,u.name,u.age,p.name FROM user AS u RIGHT JOIN part AS p on u.pid=p.id;
10、外键约束(保证表的一致性，完整性)
目录只有innodb的存储引擎支持外键，并且指向的主表的值是primary key 或者是 unique
表示当添加从表数据或者修改从表数据时，所关联的主表的外键指向的值是已经存在的
创建外键约束的方法有两个，一个是在建表的时候指定外键约束，一个是动态创建外键约束
-- 建表时创建外键约束语法(注意：子表的外键字段和主表的字段的类型要一致)，如果外键字段没有创建索引，mysql会自动创建索引,后面表示是否设置级联操作
[CONSTRAINT 外键名称] FOREIGN KEY (字段名称) REFERENCES 主表(字段名称) [ON DELETE CASCADE ON UPDATE CASCADE];
注意：当外键子表下有数据的情况下，主表所对应的字段是不允许更改的，除非把子表所对应的数据删除。
CREATE TABLE IF NOT EXISTS job(
id TINYINT UNSIGNED NOT NULL PRIMARY KEY AUTO_INCREMENT COMMENT 'JOB ID',
name VARCHAR(20) NOT NULL
)ENGINE=INNODB CHARSET=UTF8; CREATE TABLE IF NOT EXISTS user(
id INT UNSIGNED NOT NULL PRIMARY KEY AUTO_INCREMENT COMMENT '用户ID',
name VARCHAR(20) NOT NULL,
age TINYINT UNSIGNED NOT NULL DEFAULT 0,
jid TINYINT UNSIGNED NOT NULL,
CONSTRAINT user_fk_job FOREIGN KEY (jid) REFERENCES job(id)
)ENGINE=INNODB CHARSET=UTF8; --如果有问题输入SET NAMES gbk;
INSERT job (name) VALUE ("行政"),("人事"),("设计"),("编程"),("销售");
INSERT user (name,age,jid) VALUE ("小明",20,1),('小红',23,2),('小陈',34,3),('小刚',27,4),('小列',18,5),('小小',26,4);
-- 提示删除失败，因为有外键约束
DELETE FROM job WHERE id=2;
动态添加和删除外键限制
-- 动态删除外键
ALTER TABLE tab_name DROP FOREIGN KEY foreign_name;
-- 举例
ALTER TABLE user DROP FOREIGN KEY user_fk_job;
-- 动态添加外键限制不指定外键名称
ALTER TABLE tab_name ADD FOREIGN KEY (字段名) REFERENCES 主表(字段名称) [ON DELETE CASCADE ON UPDATE CASCADE];
-- 动态添加外键限制并且指定外键名称
ALTER TABLE tab_name ADD CONSTRAINT 外键名称 FOREIGN KEY (字段名) REFERENCES 主表(字段名称) [ON DELETE CASCADE ON UPDATE CASCADE];
-- 举例
ALTER TABLE user ADD FOREIGN KEY (jid) REFERENCES job (id);
注意：设置级联操作，即主表进行删除或者更新之后，所对应的子表也会相对应的更新或者删除操作（CASCADE）
11、子查询（是指嵌入在其他sql查询语句的select语名，也叫嵌套查询）
单行子查询=》表示只返回一行数据的子查询语句
-- 查询和SMITH同一部门的员工
SELECT * FROM `emp` WHERE `deptno` = (SELECT `deptno` FROM `emp` WHERE `ename`="SMITH");
-- 输出
-- +-------+-------+---------+------+------------+---------+------+--------+
-- | empno | ename | job | mgr | hiredate | sal | comm | deptno |
-- +-------+-------+---------+------+------------+---------+------+--------+
-- | 7369 | SMITH | CLERK | 7902 | 1980-12-17 | 800.00 | NULL | 20 |
-- | 7566 | JONES | MANAGER | 7839 | 1981-04-02 | 2975.00 | NULL | 20 |
-- | 7788 | SCOTT | ANALYST | 7566 | 1987-04-19 | 3000.00 | NULL | 20 |
-- | 7902 | FORD | ANALYST | 7566 | 1981-12-03 | 3000.00 | NULL | 20 |
-- +-------+-------+---------+------+------------+---------+------+--------+
多行子查询=》表示返回多行数据的子查询语句（使用关键字In）
-- 查询10号部门都有哪些岗位，并且都有哪些员工在从事相关工作
SELECT * FROM `emp` WHERE `job` in (SELECT DISTINCT `job` FROM `emp` WHERE `deptno`=10);
-- 输出
-- +-------+--------+-----------+------+------------+---------+------+--------+
-- | empno | ename | job | mgr | hiredate | sal | comm | deptno |
-- +-------+--------+-----------+------+------------+---------+------+--------+
-- | 7369 | SMITH | CLERK | 7902 | 1980-12-17 | 800.00 | NULL | 20 |
-- | 7566 | JONES | MANAGER | 7839 | 1981-04-02 | 2975.00 | NULL | 20 |
-- | 7698 | BLAKE | MANAGER | 7839 | 1981-05-01 | 2850.00 | NULL | 30 |
-- | 7782 | CLARK | MANAGER | 7839 | 1981-06-09 | 2450.00 | NULL | 10 |
-- | 7839 | KING | PRESIDENT | NULL | 1981-11-17 | 5000.00 | NULL | 10 |
-- | 7900 | JAMES | CLERK | 7698 | 1981-12-03 | 950.00 | NULL | 30 |
-- | 7934 | MILLER | CLERK | 7782 | 1982-01-23 | 1300.00 | NULL | 10 |
-- +-------+--------+-----------+------+------------+---------+------+--------+
内层语句的查询结果可以作为外层语句的查询结果，这种情况就称作为子查询。(注意子子查询要放在括号里面)
由IN,NOT IN,运算符，EXISTS等引发的子查询，以及由运算符引发的子查询
-- 由 IN 与 NOT IN 引发的子查询
SELECT id,name,age FROM user WHERE jid IN (SELECT id FROM job);
SELECT id,name,age FROM user WHERE jid NOT IN (SELECT id FROM job);
-- 由运算符引发的子查询
SELECT id,name,age FROM user WHERE jid=(SELECT id FROM job WHERE name ="编程");
-- 由EXISTS引发的子查询,表示当子查询的记录存在的情况下，才执行主查询的语句
SELECT id,name,age FROM user WHERE EXISTS (SELECT id FROM job WHERE id=20);
由 ANY SOME ALL 引发的子查询(下图表示的是右侧所对应的值在全组中的状态)
-- 数据展示
-- +----+------+-----+-----+
-- | id | name | age | jid |
-- +----+------+-----+-----+
-- | 1 | 小明 | 20 | 1 |
-- | 2 | 小红 | 23 | 2 |
-- | 3 | 小陈 | 34 | 3 |
-- | 4 | 小刚 | 27 | 4 |
-- | 5 | 小列 | 18 | 5 |
-- | 6 | 小小 | 26 | 4 |
-- +----+------+-----+-----+
SELECT name,age FROM user WHERE age>ANY(SELECT age FROM user);
-- 输出所有的结果
SELECT name,age FROM user WHERE age>=ALL(SELECT age FROM user);
-- 输出小陈 34
SELECT name,age FROM user WHERE age = ANY(SELECT age FROM user);
-- 输出全部记录,因为全部都能找到匹配的
SELECT id, name,age FROM user WHERE id<3 AND age !=ALL(SELECT age FROM user WHERE id>2);
-- 输出id为1和2的记录
多列子查询 =》 如果我们的一个子查询，返回的结果是多列的，那我们就把这个子查询叫做多列子查询
-- 查询和小明数学，语文，英语成绩一样的学生
SELECT * FROM `student` WHERE (`chinese`,`english`,`math`) = (SELECT `chinese`,`english`,`math` FROM `student` WHERE `name`='小明');
括号里的字段和值是一一对应的关系
在from子句中使用的子查询
在from子句中出现在子查询，我们通常在会把在from中构建的临时表当作正常表来使用
-- 表emp
-- +-------+--------+-----------+------+------------+---------+---------+--------+
-- | empno | ename | job | mgr | hiredate | sal | comm | deptno |
-- +-------+--------+-----------+------+------------+---------+---------+--------+
-- | 7369 | SMITH | CLERK | 7902 | 1980-12-17 | 800.00 | NULL | 20 |
-- | 7499 | ALLEN | SALESMAN | 7698 | 1981-02-20 | 1600.00 | 300.00 | 30 |
-- | 7521 | WARD | SALESMAN | 7698 | 1981-02-22 | 1250.00 | 500.00 | 30 |
-- | 7566 | JONES | MANAGER | 7839 | 1981-04-02 | 2975.00 | NULL | 20 |
-- | 7654 | MARTIN | SALESMAN | 7698 | 1981-09-28 | 1250.00 | 1400.00 | 30 |
-- | 7698 | BLAKE | MANAGER | 7839 | 1981-05-01 | 2850.00 | NULL | 30 |
-- | 7782 | CLARK | MANAGER | 7839 | 1981-06-09 | 2450.00 | NULL | 10 |
-- | 7788 | SCOTT | ANALYST | 7566 | 1987-04-19 | 3000.00 | NULL | 20 |
-- | 7839 | KING | PRESIDENT | NULL | 1981-11-17 | 5000.00 | NULL | 10 |
-- | 7844 | TURNER | SALESMAN | 7698 | 1981-09-08 | 1500.00 | NULL | 30 |
-- | 7900 | JAMES | CLERK | 7698 | 1981-12-03 | 950.00 | NULL | 30 |
-- | 7902 | FORD | ANALYST | 7566 | 1981-12-03 | 3000.00 | NULL | 20 |
-- | 7934 | MILLER | CLERK | 7782 | 1982-01-23 | 1300.00 | NULL | 10 |
-- +-------+--------+-----------+------+------------+---------+---------+--------+ -- 需求：显示高于自己部门平均工次的员工（名字，工资，部门平均工资）
SELECT
emp.ename,emp.sal,temp.avgSal
FROM `emp`, (SELECT AVG(`sal`) AS 'avgSal', `deptno` FROM `emp` GROUP BY `deptno`) AS `temp`
WHERE emp.deptno=temp.deptno AND emp.sal>temp.avgSal;
-- 输出
-- +-------+---------+-------------+
-- | ename | sal | avgSal |
-- +-------+---------+-------------+
-- | ALLEN | 1600.00 | 1566.666667 |
-- | JONES | 2975.00 | 2443.750000 |
-- | BLAKE | 2850.00 | 1566.666667 |
-- | SCOTT | 3000.00 | 2443.750000 |
-- | KING | 5000.00 | 2916.666667 |
-- | FORD | 3000.00 | 2443.750000 |
-- +-------+---------+-------------+
12、联合查询
UNION 语法：SELECT col_name,... FROM tab_name1 UNION SELECT col_name,...FROM tab_name2
UNION ALL 语法：SELECT col_name,... FROM tab_name1 UNION ALL SELECT col_name,...FROM tab_name2
注意:UNION 会去掉两个表中重复的值，而UNION ALL 只是简单的两个表的合并，并且UNION 或者 UNION ALL 前后的col_name的列数要一致，而且列名会以第一个SELECT 的列作为字段名称。
-- 举例，下面的名称就是第一个SELECT的AS后面的名称
SELECT name AS count FROM user UNION SELECT id FROM job
-- 输出
-- +-------+
-- | count |
-- +-------+
-- | 小明 |
-- | 小红 |
-- | 小陈 |
-- | 小刚 |
-- | 小列 |
-- | 小小 |
-- | 编程 |
-- | 1 |
-- | 2 |
-- | 3 |
-- | 4 |
-- | 5 |
-- | 7 |
-- +-------+
13、正则表达式查询
使用方式，用 REGEXP "匹配方式" 就可以了，相当于JS里面的test 的功能。正则的写法同JS或者PHP一样。
语法: SELECT 字段名称，...FROM tab_name WHERE 字段名称 REGEXP "匹配模式"
-- 以小开始的数据
SELECT id,name FROM user WHERE name REGEXP '^小';
-- 以程结尾的数据
SELECT id,name FROM user WHERE name REGEXP '程$';
-- 包含明，红，刚的数据
SELECT id,name FROM user WHERE name REGEXP '明|红|刚';
14、mysql的三元运算符与IFNULL语句
CASE WHEN 条件 THEN 结果1 ELSE 结果2 END 语句
-- 与SUM合用
SELECT SUM(CASE WHEN c.checkresult= '合格' THEN 1 ELSE 0 END) AS qualified,
SUM(CASE WHEN c.checkresult = '不合格' THEN 1 ELSE 0 END) AS disqualification,
COUNT(*) AS count FROM tab_name WHERE [条件];
-- sql中ifnull用法:
SELECT IFNULL(x,0,1) from tab_name;
-- 解释：如果表a中x字段是null，输出为0,否则输出1
-- 扩展用法：select ifnull(SUM(x),0) from a;
ifnull(express1,express2) 当express1为空时返回express2函数，当express1不为空时返回express1函数，eg sum(ifnull(x,0));
15、mysql 常用函数表（部份函数解析祥见函数那篇博客）
16、mysql 事务性操作
事务用于保证数据的一致性，它由一组相关的dml(增删改)语句组成，该组的dml语句要么全部成功，要么全部失败。
（注意：要引用支持事务的引擎如innodb）
mysql 事务的关键词
start transaction => 开始一个事务
savepoint => 保存点
rollback to => 回滚到某个保存点
rollback => 回滚
commit => 提交
在mysql 控制台实现事务控制
-- 插入案例表
CREATE TABLE IF NOT EXISTS `account` (
id INT UNSIGNED NOT NULL PRIMARY KEY,
name VARCHAR(30) NOT NULL DEFAULT '',
money DECIMAL(10,2) UNSIGNED NOT NULL DEFAULT 0.0
)CHARSET=utf8 COLLATE=utf8_general_ci ENGINE=innodb; INSERT INTO `account` (id, name, money) VALUES (111111, 'jim', 20000),(222222, 'jack', 32000);
实现事务的步骤
-- 开始一个事务
START TRANSACTION
-- 声明一个保存点
SAVEPOINT first
-- 执行增删改操作
-- 进行回退的操作
ROLLBACK TO first
-- 如果操作完，没有问题，那么就可以正式提交
COMMIT
注意：当开启事务的时候系统自动设置了一个匿名的保存点，当需要回退的时候只需要用rollback就可以了，如果设置了多个保存点，进行回退的时候，当退到前面的保存点时，那么这个保存点后面的保存点就消失了
17、mysql 视图的增删查改
(1) 创建视图
create view 视图名 as select 语句;
(2) 视图的显示
show create view 视图名;
(3) 视图的修改
alter view 视图名 as 新的select 语句 ；
(4) 视图的删除
drop view 视图名1, 视图名2;
视图案例说明
l 以emp表为例
只让人查询emp的名称，job, 其它的信息不能查询? 这时我们就可以创建视图来解决这个问题 。
(1) 创建视图
create view myview as select ename, job from emp;
(2) 使用视图和使用一个普通表示一样样的.
(3) 对视图或者表的dml操作,会相互的影响
在视图中所有的操作可以和正常的表一样进行操作，如果要查看是否是视图表可以用show create table `视图表`
查看数据库中都有哪些视图用语句：show table status where comment='view'
例子=》 创建一个test的视图
CREATE VIEW `test` AS SELECT `account`.`name`, `account`.`money`
FROM `account`
WHERE `account`.`money`= (SELECT MAX(`money`) FROM `account`);
使用视图的好处
1.安全性
一些数据表有着重要的信息。有些字段是保密的，不能让用户直接看到。这时就可以创建一个视图，在这张视图中只保留一部分字段。这样，用户就可以查询自己需要的字段，不能查看保密的字段。
2.性能提升
关系数据库的数据常常会分表存储，使用外键建立这些表的之间关系。这时，数据库查询通常会用到连接（JOIN）。这样做不但麻烦，效率相对也比较低。如果建立一个视图，将相关的表和字段组合在一起，就可以避免使用JOIN查询数据。
3.灵活性提升
如果系统中有一张旧的表，这张表由于设计的问题，即将被废弃。然而，很多应用都是基于这张表，不易修改。这时就可以建立一张视图，视图中的数据直接映射到新建的表。这样，就可以少做很多改动，也达到了升级数据表的目的.