mysql 数据库的所有操作的基本命令汇总：
"""
菜鸟教程 mysql介绍
"""
# 技术博客网站：
# https://blog.csdn.net/sinat_35861727/article/details/78866904
# https://www.cnblogs.com/cxxjohnson/p/5914583.html MySQL 常用语句大全
# https://www.2cto.com/database/201712/702968.html mysql orm 网址
# 备注：一个数据表只可以有一个主键，所以不存在删除某一列的主键
"""
一、MySQL的管理
1、管理MySQL的命令
SHOW DATABASES 列出 MySQL 数据库管理系统的数据库列表
eg: show DATABASES;
USE 数据库名 选择要操作的Mysql数据库，使用该命令后所有Mysql命令都只针对该数据库
eg： use mydb;
SHOW TABLES 显示指定数据库的所有表，使用该命令前需要使用 use 命令来选择要操作的数据库
eg: use mydb; show tables;
SHOW COLUMNS FROM 数据表 显示数据表的属性，属性类型，主键信息 ，是否为 NULL，默认值等其他信息
eg: use mydb; show columns from mydb.mytable;
SHOW INDEX FROM 数据表 显示数据表的详细索引信息，包括PRIMARY KEY（主键）
eg: use mydb; show index from mydb.mytable;
SHOW TABLE STATUS LIKE [FROM db_name] [LIKE 'pattern'] \G; 该命令将输出Mysql数据库管理系统的性能及统计信息。
eg:
SHOW TABLE STATUS FROM RUNOOB; # 显示数据库 RUNOOB 中所有表的信息
SHOW TABLE STATUS from RUNOOB LIKE 'runoob%'; # 表名以runoob开头的表的信息
SHOW TABLE STATUS from RUNOOB LIKE 'runoob%'\G; # 加上 \G，查询结果按列打印
"""
"""
二、 mysql连接
1、pymysql 连接数据库的两种方式
第一种写法：
import pymysql.cursors
# Connect to the database
connection = pymysql.connect(
host='127.0.0.1',
port=3306,
user='root',
password='root',
db='haha',
charset='utf8',
cursorclass=pymysql.cursors.DictCursor
# 如果不加这个，打印出来的result为元组， 加上这个 打印的result 结果为列表里面包含字典。
)
第二种方法： 用字典进行连接参数的管理，这样子更优雅，推荐使用
import pymysql.cursors
#连接配置信息
config = {
'host':'127.0.0.1',
'port':3306,
'user':'root',
'password':'root',
'db':'haha',
'charset':'utf8',
'cursorclass':pymysql.cursors.DictCursor,
}
# 创建连接
connection = pymysql.connect(**config)
# 创建游标方法1
cursor = connection.cursor()
# 创建游标方法2 取别名为 cursor
with connection.cursor() as cursor:
# 执行sql语句，插入记录
sql = 'INSERT INTO employees (first_name, last_name, hire_date, gender, birth_date) VALUES (%s, %s, %s, %s, %s)'
cursor.execute(sql, ('Robin', 'Zhyea', tomorrow, 'M', date(1989, 6, 14)))
# 没有设置默认自动提交，需要主动提交，以保存所执行的语句
connection.commit() # 连接提交事务
cursor.close() # 关闭游标连接
connection.close(); # 关闭连接，释放内存
"""
"""
三、MySQL创建数据库
CREATE DATABASE 数据库名; 创建一个数据库
eg： create database mydb charset='utf8';
四、MySQL删除数据库
drop database <数据库名>; drop 命令删除数据库
eg：drop database mydb; 删除名字为 mydb的数据库
五、MySQL选择数据库
USE 数据库名 选择要操作的Mysql数据库，使用该命令后所有Mysql命令都只针对该数据库
eg： use mydb;
"""
"""
六、MySQL 创建数据表
创建MySQL数据表需要以下信息： 表名、表字段名、定义每个表字段类型
语法： CREATE TABLE table_name (column_name1 column_type1,column_name2 column_type2....);
eg: mydb 数据库中创建表名为 haha 的表
USE mydb;
CREATE TABLE 表名(字段1,字段2,字段3...) CHARSET=utf8
eg：
CREATE TABLE IF NOT EXISTS `haha` (
`id` int(11) unsigned NOT NULL AUTO_INCREMENT,
`goods_name` varchar(255) NOT NULL,
`sku_id` int(11) NOT NULL,
`price` decimal(10,2) NOT NULL DEFAULT '0.00' COMMENT '价格',
`quantity` decimal(15,6) NOT NULL COMMENT '采购吨数',
`quote_date` date NOT NULL COMMENT '日期',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1966 DEFAULT CHARSET=utf8 COMMENT = '这是haha表';
注： COMMENT 后面是加的注释 可以给每行数据加上注释，也可以给表加上注释说明。 ENGINE=InnoDB 默认引擎都选这个。
七、MySQL 删除数据表
MySQL中删除数据表是非常容易操作的， 但是你再进行删除表操作时要非常小心，因为执行删除命令后所有数据都会消失。
语法： DROP TABLE table_name ;
1、 delete 格式为：delete from 表名 where 删除条件; 删除表全部数据，表结构不变，
对于 MyISAM 会立刻释放磁盘空间，InnoDB 不会释放磁盘空间;
eg：删除学生表内姓名为张三的记录 delete from student where T_name = "张三";
2、用truncate 格式为：truncate table 表名; 删除表全部数据，保留表结构，立刻释放磁盘空间 ，不管是 Innodb 和 MyISAM;
eg：清除学生表内的所有数据 truncate table student;
3、删除表用 drop， 格式为：drop table 表名; 删除表全部数据和表结构，立刻释放磁盘空间，不管是 Innodb 和 MyISAM;
eg：删除学生表 drop table student; 执行后就是啥都没了
小结：
1、当你不再需要该表时， 用 drop; 执行后 -----> 表已经不存在了
2、当你仍要保留该表，但要删除所有记录时， 用 truncate; 执行后 -----> 清除表内数据，保存表结构。 id 从当前的开始
3、当你要删除部分记录时， 用 delete。 执行后 -----> 删除表内数据, id 会继续增长，不会因为删除而改变
"""
"""
八、MySQL 插入数据 （增）
1、MySQL 表中使用 INSERT INTO SQL语句来插入数据。
语法: INSERT INTO table_name ( field1, field2,...fieldN ) VALUES ( value1, value2,...valueN );
eg: INSERT INTO runoob_tbl (runoob_title, runoob_author, submission_date) VALUES ("学习 PHP", "菜鸟教程", NOW());
2、INSERT 插入多条数据
INSERT INTO table_name (field1, field2,...fieldN) VALUES (valueA1,valueA2,...valueAN),(valueB1,valueB2,...valueBN),(valueC1,valueC2,...valueCN)......;
注： 插入一条数据的时候 values 和 value 都可以 ，插入多条用values，多条必须用 values(...),(...),(...)
3、插入检索出来的数据：
>INSERT INTO tb_name(name,score) SELECT name,score FROM tb_name2;
4、 有字段设置默认值时，插入字段的时候如果不插入值，使用默认值，但是 insert into table_name (field1,field2...)
这个默认值字段不能写，写了就要给值，既不写都不写，写了都要写。
九、MySQL 查询数据 （查）
MySQL 数据库使用SQL SELECT语句来查询数据。
语法:
SELECT
column_name1,column_name2
FROM
table_name
WHERE
条件1,条件2, ...
LIMIT N
OFFSET M
查询语句中你可以使用一个或者多个表，表之间使用逗号(,)分割，并使用WHERE语句来设定查询条件。
注：
SELECT 命令可以读取一条或者多条记录。
你可以使用星号（*）来代替其他字段，SELECT语句会返回表的所有字段数据
你可以使用 WHERE 语句来包含任何条件。
你可以使用 LIMIT 属性来设定返回的记录数。
你可以通过OFFSET指定SELECT语句开始查询的数据偏移量。默认情况下偏移量为0
limit (m,n) 也相当于 偏移m个 ,和 limit n，offset 是一致的。
注意：
limit是mysql的语法
select * from table limit m,n
其中m是指记录开始的index，从0开始，表示第一条记录
n是指从第m+1条开始，取n条。
select * from tablename limit 2,4
即取出第3条至第6条，4条记录
十、MySQL DELETE 删除语句 （删）
使用SQL的 DELETE FROM 命令来删除 MySQL 数据表中的记录。
语法: DELETE FROM table_name [WHERE 条件1,条件2...]
eg: DELETE FROM runoob_tbl WHERE runoob_id=3;
注：
如果 不写WHERE 子句，MySQL 表中的所有记录将被删除。
你可以在 WHERE 子句中指定任何条件
示例：
delete 语句用于删除表中的数据, 基本用法为:
delete from 表名称 where 删除条件;
以下是在表 students 中的实例:
删除 id 为 3 的行: delete from students where id=3;
删除所有年龄小于 21 岁的数据: delete from students where age<20;
删除表中的所有数据: delete from students;
十一、MySQL UPDATE 查询 （改）
1、使用 SQL UPDATE 命令来操作。
语法:UPDATE table_name SET field1=new-value1, field2=new-value2 [WHERE Clause]
eg: UPDATE mytable SET title='学习 C++' WHERE t_id=3;
注意：
你可以同时更新一个或多个字段。
你可以在 WHERE 子句中指定任何条件。
你可以在一个单独表中同时更新数据。
示例：
update 表名称 set 列名称=新值 where 更新条件;
以下是在表 students 中的实例:
将 id 为 5 的手机号改为默认的 - : update students settel=default where id=5;
将所有人的年龄增加 1: update students set age=age+1;
将手机号为 13288097888 的姓名改为 "小明", 年龄改为 19:
update students set name="小明", age=19 where tel="13288097888";
2、UPDATE替换某个字段中的某个字符
当我们需要将字段中的特定字符串批量修改为其他字符串时，使用以下操作：
UPDATE table_name SET field=REPLACE(field, 'old-string', 'new-string') [WHERE Clause]
eg：
以下实例将更新 t_id 为 3 title 字段值的 "C++" 替换为 "Python"：
UPDATE mytable SET title = REPLACE(title, 'C++', 'Python') where t_id = 3;
"""
"""
十二、MySQL WHERE 子句
语法：WHERE 子句从数据表中读取数据的通用语法：
SELECT field1, field2,...fieldN FROM table_name1, table_name2...[WHERE condition1 [AND [OR]] condition2...
注：
查询语句中你可以使用一个或者多个表，表之间使用逗号, 分割，并使用WHERE语句来设定查询条件。
你可以在 WHERE 子句中指定任何条件。
你可以使用 AND 或者 OR 指定一个或多个条件。
WHERE 子句也可以运用于 SQL 的 DELETE 或者 UPDATE 命令。
WHERE 子句类似于程序语言中的 if 条件
操作符 描述 实例
= 等号 检测两个值是否相等，如果相等返回true (A = B) 返回false。
<>, != 不等于 检测两个值是否相等，如果不相等返回true (A != B) 返回 true。
> 大于号 检测左边的值是否大于右边的值, 如果左边的值大于右边的值返回true (A > B) 返回false。
< 小于号 检测左边的值是否小于右边的值, 如果左边的值小于右边的值返回true (A < B) 返回 true。
>= 大于等于号 检测左边的值是否大于或等于右边的值, 如果左边的值大于或等于右边的值返回true (A >= B) 返回false。
<= 小于等于号 检测左边的值是否小于于或等于右边的值, 如果左边的值小于或等于右边的值返回true (A <= B）
关键字 BINARY ： 区分 WHERE 子句的字符串大小写
因为MySQL 的 WHERE 子句的字符串比较是不区分大小写的。
所以可以使用 BINARY 关键字来设定 WHERE 子句的字符串比较是区分大小写的。
eg:
1、
mysql> SELECT * from runoob_tbl WHERE BINARY runoob_author='runoob.com';
Empty set (0.01 sec)
2、
mysql> SELECT * from runoob_tbl WHERE BINARY runoob_author='RUNOOB.COM';
+-----------+---------------+---------------+-----------------+
| runoob_id | runoob_title | runoob_author | submission_date |
+-----------+---------------+---------------+-----------------+
| 3 | JAVA 教程 | RUNOOB.COM | 2016-05-06 |
| 4 | 学习 Python | RUNOOB.COM | 2016-03-06 |
+-----------+---------------+---------------+-----------------+
2 rows in set (0.01 sec)
3、
mysql> SELECT * from runoob_tbl WHERE runoob_author='runoob.com';
+-----------+---------------+---------------+-----------------+
| runoob_id | runoob_title | runoob_author | submission_date |
+-----------+---------------+---------------+-----------------+
| 3 | JAVA 教程 | RUNOOB.COM | 2016-05-06 |
| 4 | 学习 Python | RUNOOB.COM | 2016-03-06 |
+-----------+---------------+---------------+-----------------+
2 rows in set (0.01 sec)
"""
"""
十三、MySQL LIKE 子句
SQL LIKE 子句中使用百分号 %字符来表示任意字符，类似于UNIX或正则表达式中的星号 *。
语法：SELECT field1, field2,...fieldN FROM table_name WHERE field1 LIKE condition1 [AND [OR]] filed2 = 'somevalue'
eg: runoob_tbl 表中获取 runoob_author 字段中以 COM 为结尾的的所有记录
mysql> use RUNOOB;
Database changed
mysql> SELECT * from runoob_tbl WHERE runoob_author 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)
注：
WHERE 子句中指定任何条件。
WHERE 子句中使用LIKE子句。
你可以使用LIKE子句代替等号 =。
LIKE 通常与 % 一同使用，类似于一个元字符的搜索。
使用 AND 或者 OR 指定一个或多个条件。
DELETE 或 UPDATE 命令中使用 WHERE...LIKE 子句来指定条件。
示例：
like 匹配/模糊匹配，会与 % 和 _ 结合使用。
语法说明：
'%a' //以a结尾的数据
'a%' //以a开头的数据
'%a%' //含有a的数据
'_a_' //三位且中间字母是a的
'_a' //两位且结尾字母是a的
'a_' //两位且开头字母是a的
查询以 java 字段开头的信息。
SELECT * FROM position WHERE name LIKE 'java%';
查询包含 java 字段的信息。
SELECT * FROM position WHERE name LIKE '%java%';
查询以 java 字段结尾的信息。
SELECT * FROM position WHERE name LIKE '%java';
"""
"""
十四、MySQL UNION 操作符
一、UNION和UNION ALL的作用和语法
UNION 用于合并两个或多个 SELECT 语句的结果集，并消去表中任何重复行。
UNION 内部的 SELECT 语句必须拥有相同数量的列，列也必须拥有相似的数据类型。
同时，每条 SELECT 语句中的列的顺序必须相同.
二、union的用法及注意事项
union:联合的意思，即把两次或多次查询结果合并起来。
要求：两次查询的列数必须一致
推荐：列的类型可以不一样，但推荐查询的每一列，想对应的类型一样
可以来自多张表的数据：多次sql语句取出的列名可以不一致，此时以第一个sql语句的列名为准。
如果不同的语句中取出的行，有完全相同(这里表示的是每个列的值都相同)，那么union会将相同的行合并，最终只保留一行。也可以这样理解，union会去掉重复的行。
如果不想去掉重复的行，可以使用union all。
如果子句中有order by,limit，需用括号()包起来。推荐放到所有子句之后，即对最终合并的结果来排序或筛选
egg: (select * from a order by id) union (select * from b order id);
描述：
MySQL UNION 操作符用于连接两个以上的 SELECT 语句的结果组合到一个结果集合中。
多个 SELECT 语句会删除重复的数据。
语法：
SELECT expression1, expression2, ... expression_n
FROM tables [WHERE conditions]
UNION [ALL | DISTINCT]
SELECT expression1, expression2, ... expression_n
FROM tables [WHERE conditions];
注:
参数: expression1, expression2, ... expression_n: 要检索的列
tables: 要检索的数据表
WHERE conditions: 可选,检索条件
DISTINCT: 可选,删除结果集中重复的数据。
默认情况下 UNION 操作符已经删除了重复数据，所以 DISTINCT 修饰符对结果没啥影响。
ALL: 可选，返回所有结果集，包含重复数据。
注释：
UNION 只会选取不同的值。
UNION ALL 返回结果集包含重复数据
示例：
select student_name stuName from student union select teacher_name teacherName from teacher;
select student_name stuName from student union all select teacher_name teacherName from teacher;
备注:第一条是union 查询,会去重。别名会使用第一条select语句中出现别名
第二条是union all查询，全部查询不会去重
如果表1比表2字段要多，但是你又非要查询出表1的所有字段还要使用union all来查询的话，可以使用空字符串来代替表2缺少的字段。
举例:select person_id,person_name, person_age from person union all
select teacher_id,teacher_name, 'null' from teacher;
联合查询使用场景:常用于数据类似的两张或多张表查询，如不同的数据分类表，或者是数据历史表等.
"""
"""
十五、MySQL 排序
描述：
对读取的数据进行排序，使用ORDER BY 子句 按哪个字段哪种方式来进行排序
语法：
SELECT field1, field2,...fieldN table_name1, table_name2...
ORDER BY field1, [field2...] [ASC [DESC]]
eg: # 默认按照升序排列，desc降序， asc 升序
mysql> SELECT * from runoob_tbl ORDER BY submission_date ASC;
+-----------+---------------+---------------+-----------------+
| runoob_id | runoob_title | runoob_author | submission_date |
+-----------+---------------+---------------+-----------------+
| 3 | 学习 Java | RUNOOB.COM | 2015-05-01 |
| 4 | 学习 Python | RUNOOB.COM | 2016-03-06 |
| 1 | 学习 PHP | 菜鸟教程 | 2017-04-12 |
| 2 | 学习 MySQL | 菜鸟教程 | 2017-04-12 |
+-----------+---------------+---------------+-----------------+
4 rows in set (0.01 sec)
注 ：
你可以使用任何字段来作为排序的条件，从而返回排序后的查询结果。
你可以设定多个字段来排序。
你可以使用 ASC 或 DESC 关键字来设置查询结果是按升序或降序排列。
默认情况下，它是按升序排列。
你可以添加 WHERE...LIKE 子句来设置条件
示例：
如果字符集采用的是 gbk(汉字编码字符集)，直接在查询语句后边添加 ORDER BY：
SELECT *
FROM runoob_tbl
ORDER BY runoob_title;
如果字符集采用的是 utf8(万国码)，需要先对字段进行转码然后排序：
SELECT *
FROM runoob_tbl
ORDER BY CONVERT(runoob_title using gbk);
十六、MySQL GROUP BY 分组
GROUP BY 语句根据一个或多个列对结果集进行分组，分组列上可以使用 COUNT, SUM, AVG,等函数。
GROUP BY 语法：
SELECT column_name, function(column_name)
FROM table_name
WHERE column_name operator value
GROUP BY column_name;
表中的数据：
mysql> SELECT * FROM employee_tbl;
+----+--------+---------------------+--------+
| id | name | date | singin |
+----+--------+---------------------+--------+
| 1 | 小明 | 2016-04-22 15:25:33 | 1 |
| 2 | 小王 | 2016-04-20 15:25:47 | 3 |
| 3 | 小丽 | 2016-04-19 15:26:02 | 2 |
| 4 | 小王 | 2016-04-07 15:26:14 | 4 |
| 5 | 小明 | 2016-04-11 15:26:40 | 4 |
| 6 | 小明 | 2016-04-04 15:26:54 | 2 |
+----+--------+---------------------+--------+
6 rows in set (0.00 sec)
示例1：
我们使用 GROUP BY 语句 将数据表按名字进行分组，并统计每个人有多少条记录：
mysql> SELECT name, COUNT(*) FROM employee_tbl GROUP BY name;
+--------+----------+
| name | COUNT(*) |
+--------+----------+
| 小丽 | 1 |
| 小明 | 3 |
| 小王 | 2 |
+--------+----------+
3 rows in set (0.01 sec)
示例2:
WITH ROLLUP 可以实现在分组统计数据基础上再进行相同的统计（SUM,AVG,COUNT…）。
例如我们将以上的数据表按名字进行分组，再统计每个人登录的次数：
mysql> SELECT name, SUM(singin) as singin_count FROM employee_tbl GROUP BY name WITH ROLLUP;
+--------+--------------+
| name | singin_count |
+--------+--------------+
| 小丽 | 2 |
| 小明 | 7 |
| 小王 | 7 |
| NULL | 16 |
+--------+--------------+
4 rows in set (0.00 sec)
"""
"""
十七、Mysql 连接的使用
如何使用 MySQL 的 JOIN 在两个或多个表中查询数据。
可以在 SELECT, UPDATE 和 DELETE 语句中使用 Mysql 的 JOIN 来联合多表查询。
JOIN 按照功能大致分为如下三类：
INNER JOIN（内连接,或等值连接）：获取两个表中字段匹配关系的记录。
LEFT JOIN（左连接）：获取左表所有记录，即使右表没有对应匹配的记录。
RIGHT JOIN（右连接）： 与 LEFT JOIN 相反，用于获取右表所有记录，即使左表没有对应匹配的记录
INNER JOIN
SELECT a.runoob_id, b.runoob_count FROM runoob_tbl a INNER JOIN tcount_tbl b ON a.runoob_author = b.runoob_author;
LEFT JOIN
SELECT a.runoob_id, b.runoob_count FROM runoob_tbl a LEFT JOIN tcount_tbl b ON a.runoob_author = b.runoob_author;
RIGHT JOIN
SELECT a.runoob_id, b.runoob_count FROM runoob_tbl a RIGHT JOIN tcount_tbl b ON a.runoob_author = b.runoob_author;
"""
"""
十八、MySQL NULL 值处理
IS NULL: 当列的值是 NULL,此运算符返回 true。
IS NOT NULL: 当列的值不为 NULL, 运算符返回 true。
<=>: 比较操作符（不同于=运算符），当比较的的两个值为 NULL 时返回 true
注：
NULL 的条件比较运算是比较特殊的,不能使用 = NULL 或 != NULL 在列中查找 NULL 值,这样是没有作用的。
eg：这个实例可以看到 = 和 != 运算符是不起作用的：
mysql> SELECT * FROM runoob_test_tbl WHERE runoob_count = NULL; 没作用
NULL 值与任何其它值的比较（即使是 NULL）永远返回 false，即 NULL = NULL 返回false 。
正确的处理方式： NULL 使用 IS NULL 和 IS NOT NULL 运算符。
eg: 查找数据表中 runoob_test_tbl 列是否为 NULL，必须使用 IS NULL 和 IS NOT NULL
正确操作：
mysql> SELECT * FROM runoob_test_tbl WHERE runoob_count IS NULL;
mysql> SELECT * from runoob_test_tbl WHERE runoob_count IS NOT NULL;
"""
"""
十九、 MySQL 正则表达式
mysql的正则表达式 匹配的原则都一样，对里面某一个字段的值用 正则匹配（REGEXP）
eg:
查找name字段中以'st'为开头的所有数据：
mysql> SELECT name FROM person_tbl WHERE name REGEXP '^st';
查找name字段中以'ok'为结尾的所有数据：
mysql> SELECT name FROM person_tbl WHERE name REGEXP 'ok$';
查找name字段中包含'mar'字符串的所有数据：
mysql> SELECT name FROM person_tbl WHERE name REGEXP 'mar';
查找name字段中以元音字符开头或以'ok'字符串结尾的所有数据：
mysql> SELECT name FROM person_tbl WHERE name REGEXP '^[aeiou]|ok$';
为了匹配特殊字符，必须用\\为前导。 \\-表示查找-， \\.表示查找.
MySQL要求两个反斜杠（MySQL 自己解释一个，正则表达式库解释另一个）
匹配\ 为了匹配反斜杠（\）字符本身，需要使用\\\
简单的正则表达式测试 可以在不使用数据库表的情况下:
用SELECT来测试正则表达式。REGEXP检查总是返回0（没有匹配）或1（匹配）。
可以用带文字串的REGEXP来测试表达式，并试验它们。相应的语法如下：
select 'hello' regexp '[0-9]'
这个例子显然将返回0（因为文本hello中没有数字）
"""
"""
二十、 MySQL 事务
描述：
MySQL 只有使用了 Innodb 数据库引擎的数据库或表才支持事务。
事务用来管理 insert,update,delete 语句
事务是必须满足4个条件（ACID）：
原子性（Atomicity，或称不可分割性）
一致性（Consistency）
隔离性（Isolation，又称独立性）
持久性（Durability）
注意： (命令行的默认下事务都是自动提交,所以命令行操作会马上显示出数据)
MySQL 命令行的默认下事务都是自动提交的，即执行 SQL 语句后就会马上执行 COMMIT 操作。
因此要显式地开启一个事务务须使用命令 BEGIN 或 START TRANSACTION，
或者执行命令 SET AUTOCOMMIT=0，用来禁止使用当前会话的自动提交。
事务控制语句：
BEGIN或START TRANSACTION；显式地开启一个事务；
COMMIT；也可以使用COMMIT WORK，不过二者是等价的。COMMIT会提交事务，并使已对数据库进行的所有修改成为永久性的；
ROLLBACK；有可以使用ROLLBACK WORK，不过二者是等价的。回滚会结束用户的事务，并撤销正在进行的所有未提交的修改；
SAVEPOINT identifier；SAVEPOINT允许在事务中创建一个保存点，一个事务中可以有多个SAVEPOINT；
RELEASE SAVEPOINT identifier；删除一个事务的保存点，当没有指定的保存点时，执行该语句会抛出一个异常；
ROLLBACK TO identifier；把事务回滚到标记点；
SET TRANSACTION；用来设置事务的隔离级别。InnoDB存储引擎提供事务的隔离级别有READ UNCOMMITTED、READ COMMITTED、REPEATABLE READ和SERIALIZABLE。
MYSQL 事务处理主要有两种方法：
1、用 BEGIN, ROLLBACK, COMMIT 来实现
CK 事务回滚
COMMIT 事务确认
2、直接用 SET 来改变 MySQL 的自动提交模式:
SET AUTOCOMMIT=0 禁止自动提交
SET AUTOCOMMIT=1 开启自动提交
事务测试：
mysql> use RUNOOB;
Database changed
mysql> CREATE TABLE runoob_transaction_test( id int(5)) engine=innodb; # 创建数据表
Query OK, 0 rows affected (0.04 sec)
mysql> select * from runoob_transaction_test;
Empty set (0.01 sec)
mysql> begin; # 开始事务
Query OK, 0 rows affected (0.00 sec)
mysql> insert into runoob_transaction_test value(5);
Query OK, 1 rows affected (0.01 sec)
mysql> insert into runoob_transaction_test value(6);
Query OK, 1 rows affected (0.00 sec)
mysql> commit; # 提交事务
Query OK, 0 rows affected (0.01 sec)
mysql> select * from runoob_transaction_test;
+------+
| id |
+------+
| 5 |
| 6 |
+------+
2 rows in set (0.01 sec)
mysql> begin; # 开始事务
Query OK, 0 rows affected (0.00 sec)
mysql> insert into runoob_transaction_test values(7);
Query OK, 1 rows affected (0.00 sec)
mysql> rollback; # 回滚
Query OK, 0 rows affected (0.00 sec)
mysql> select * from runoob_transaction_test; # 因为回滚所以数据没有插入
+------+
| id |
+------+
| 5 |
| 6 |
+------+
2 rows in set (0.01 sec)
"""
"""
二十一、MySQL ALTER命令
修改数据表名或者修改数据表字段时，使用 ALTER
1、删除，添加或修改表字段
ALTER 命令及 DROP 子句来删除以上创建表的 i 字段，但是当只剩余一个字段则无法使用DROP来删除字段
mysql> ALTER TABLE testalter_tbl DROP i;
2、增加字段 ：默认添加到末尾
使用 ADD 子句来向数据表中添加列，执行命令后，i 字段会自动添加到数据表字段的末尾。
如下实例在表 testalter_tbl 中添加 i 字段，并定义数据类型
mysql> ALTER TABLE testalter_tbl ADD i INT;
3、指定增加的字段插入的位置
指定新增字段的位置，可以使用MySQL提供的关键字 FIRST (设定位第一列)
eg：ALTER TABLE testalter_tbl ADD i INT FIRST; 设定为第一列
AFTER TABLE 字段名（设定位于某个字段之后）
eg：ALTER TABLE testalter_tbl ADD i INT AFTER c;
注：
SHOW COLUMNS 查看表结构的变化
FIRST 和 AFTER 关键字只占用于 ADD 子句。
所以如果你想重置数据表字段的位置就需要先使用 DROP 删除字段，
然后使用 ADD 来添加字段并设置位置。
4、修改字段类型及名称
修改字段类型及名称, ALTER命令使用 MODIFY 或 CHANGE 子句
eg：把字段 c 的类型从 CHAR(1) 改为 CHAR(10)，可以执行以下命令:
mysql> ALTER TABLE testalter_tbl MODIFY c CHAR(10);
语法：
在 CHANGE 关键字之后，紧跟着的是你要修改的字段名，然后指定新字段名及类型。
尝试如下实例： CHANGE 字段名称，新的字段名称，新的类型
mysql> ALTER TABLE testalter_tbl CHANGE i j BIGINT;
mysql> ALTER TABLE testalter_tbl CHANGE j j INT;
5、ALTER TABLE 对 Null 值和默认值的影响
当你修改字段时，你可以指定是否包含值或者是否设置默认值。
以下实例，指定字段 j 为 NOT NULL 且默认值为100 。
mysql> ALTER TABLE testalter_tbl
-> MODIFY j BIGINT NOT NULL DEFAULT 1000;
如果你不设置默认值，MySQL会自动设置该字段默认为 NULL
6、修改字段默认值
ALTER TABLE testalter_tbl ALTER i SET DEFAULT 1000;
eg：
mysql> SHOW COLUMNS FROM testalter_tbl;
+-------+---------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-------+---------+------+-----+---------+-------+
| c | char(1) | YES | | NULL | |
| i | int(11) | YES | | 1000 | |
+-------+---------+------+-----+---------+-------+
2 rows in set (0.00 sec)
使用 ALTER 命令及 DROP子句来删除字段的默认值，如下实例：
eg：
mysql> ALTER TABLE testalter_tbl ALTER i DROP DEFAULT;
mysql> SHOW COLUMNS FROM testalter_tbl;
+-------+---------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-------+---------+------+-----+---------+-------+
| c | char(1) | YES | | NULL | |
| i | int(11) | YES | | NULL | |
+-------+---------+------+-----+---------+-------+
2 rows in set (0.00 sec)
7、修改表名
如果需要修改数据表的名称，可以在 ALTER TABLE 语句中使用 RENAME TO 子句
尝试以下实例将数据表 testalter_tbl 重命名为 alter_tbl：
mysql> ALTER TABLE testalter_tbl RENAME TO alter_tbl;
添加外键：
alter table 从表 add constraint 外键名称（形如：FK_从表_主表） foreign key 从表(外键字段) references 主表(主键字段);
删除外键：
alter table 表名 drop foreign key 外键名称
修改默认值：
ALTER TABLE testalter_tbl ALTER i SET DEFAULT 1000;
删除默认值：
ALTER TABLE testalter_tbl ALTER i DROP DEFAULT;
"""
"""
二十一、MySQL 索引
描述：
MySQL索引的建立对于MySQL的高效运行是很重要的，索引可以大大提高MySQL的检索速度。
创建索引时，你需要确保该索引是应用在SQL 查询语句的条件(一般作为 WHERE 子句的条件)。
缺点：
建立索引会占用磁盘空间的索引文件。
普通索引
创建索引
这是最基本的索引，它没有任何限制。它有以下几种创建方式：
CREATE INDEX indexName ON mytable(username(length));
如果是CHAR，VARCHAR类型，length可以小于字段实际长度；如果是BLOB和TEXT类型，必须指定 length。
修改表结构(添加索引)
ALTER table tableName ADD INDEX indexName(columnName)
创建表的时候直接指定
CREATE TABLE mytable(
ID INT NOT NULL,
username VARCHAR(16) NOT NULL,
INDEX [indexName] (username(length))
);
删除索引的语法
DROP INDEX [indexName] ON mytable;
唯一索引
它与前面的普通索引类似，不同的就是：索引列的值必须唯一，但允许有空值。
如果是组合索引，则列值的组合必须唯一。
它有以下几种创建方式：
创建索引
CREATE UNIQUE INDEX indexName ON mytable(username(length))
修改表结构
ALTER table mytable ADD UNIQUE [indexName] (username(length))
创建表的时候直接指定
CREATE TABLE mytable(
ID INT NOT NULL,
username VARCHAR(16) NOT NULL,
UNIQUE [indexName] (username(length))
);
使用ALTER 命令添加和删除索引
有四种方式来添加数据表的索引：
ALTER TABLE tbl_name ADD PRIMARY KEY (column_list): 该语句添加一个主键，这意味着索引值必须是唯一的，且不能为NULL。
ALTER TABLE tbl_name ADD UNIQUE index_name (column_list): 这条语句创建索引的值必须是唯一的（除了NULL外，NULL可能会出现多次）。
ALTER TABLE tbl_name ADD INDEX index_name (column_list): 添加普通索引，索引值可出现多次。
ALTER TABLE tbl_name ADD FULLTEXT index_name (column_list):该语句指定了索引为 FULLTEXT ，用于全文索引。
以下实例为在表中添加索引
mysql> ALTER TABLE testalter_tbl ADD INDEX (c);
ALTER 命令中使用 DROP 子句来删除索引
mysql> ALTER TABLE testalter_tbl DROP INDEX c;
ALTER 命令添加 和 删除主键
主键只能作用于一个列上，添加主键索引时，你需要确保该主键默认不为空（NOT NULL)
mysql> ALTER TABLE testalter_tbl MODIFY i INT NOT NULL;
mysql> ALTER TABLE testalter_tbl ADD PRIMARY KEY (i);
你也可以使用 ALTER 命令删除主键：
mysql> ALTER TABLE testalter_tbl DROP PRIMARY KEY;
删除主键时只需指定PRIMARY KEY，但在删除索引时，你必须知道索引名。
显示索引信息
你可以使用 SHOW INDEX 命令来列出表中的相关的索引信息。可以通过添加 \G 来格式化输出信息。
尝试以下实例:
mysql> SHOW INDEX FROM table_name; \G
"""
"""
二十二、MySQL 临时表 SalesSummary
描述：
MySQL临时表只在当前连接可见，如果当前连接退出，该临时表也会自动销毁。
如果你使用了其他MySQL客户端程序连接MySQL数据库服务器来创建临时表，
那么只有在关闭客户端程序时才会销毁临时表，也可以手动销毁（drop）
eg：
创建表：
mysql> CREATE TEMPORARY TABLE SalesSummary (
-> product_name VARCHAR(50) NOT NULL
-> , total_sales DECIMAL(12,2) NOT NULL DEFAULT 0.00
-> , avg_unit_price DECIMAL(7,2) NOT NULL DEFAULT 0.00
-> , total_units_sold INT UNSIGNED NOT NULL DEFAULT 0
);
Query OK, 0 rows affected (0.00 sec)
插入数据：
mysql> INSERT INTO SalesSummary
-> (product_name, total_sales, avg_unit_price, total_units_sold)
-> VALUES
-> ('cucumber', 100.25, 90, 2);
查询数据：
mysql> SELECT * FROM SalesSummary;
+--------------+-------------+----------------+------------------+
| product_name | total_sales | avg_unit_price | total_units_sold |
+--------------+-------------+----------------+------------------+
| cucumber | 100.25 | 90.00 | 2 |
+--------------+-------------+----------------+------------------+
1 row in set (0.00 sec)
如果：
exit()
mysql> SELECT * FROM SalesSummary;
ERROR 1146: Table 'RUNOOB.SalesSummary' doesn't exist
报错： 这个表已经被销毁，不存在了。
注意：
1、当你使用 SHOW TABLES命令显示数据表列表时，你将无法看到 SalesSummary表，因为它是一个临时表
2、如果你退出当前MySQL会话，即exit(),再使用 SELECT命令来读取原先创建的临时表数据，
那你会发现数据库中没有该表的存在，因为在你退出时该临时表已经被销毁了。
"""
"""
二十三、MySQL 复制表
如果我们需要完全的复制MySQL的数据表，包括表的结构，索引，默认值等。
如果仅仅使用CREATE TABLE ... SELECT 命令，是无法实现的。
完整的复制MySQL数据表，步骤如下：
1、使用 SHOW CREATE TABLE 命令获取创建数据表(CREATE TABLE) 语句，该语句包含了原数据表的结构，索引等。
2、复制以下命令显示的SQL语句，修改数据表名，并执行SQL语句，通过以上命令 将完全的复制数据表结构。
3、如果你想复制表的内容，你就可以使用 INSERT INTO ... SELECT 语句来实现。
示例：
尝试以下实例来复制表 runoob_tbl
步骤一：
获取数据表的完整结构。
mysql> SHOW CREATE TABLE runoob_tbl \G;
*************************** 1. row ***************************
Table: runoob_tbl
Create Table: CREATE TABLE `runoob_tbl` (
`runoob_id` int(11) NOT NULL auto_increment,
`runoob_title` varchar(100) NOT NULL default '',
`runoob_author` varchar(40) NOT NULL default '',
`submission_date` date default NULL,
PRIMARY KEY (`runoob_id`),
UNIQUE KEY `AUTHOR_INDEX` (`runoob_author`)
) ENGINE=InnoDB
1 row in set (0.00 sec)
ERROR:
No query specified
步骤二：
修改SQL语句的数据表名，并执行SQL语句。
mysql> CREATE TABLE `clone_tbl` (
-> `runoob_id` int(11) NOT NULL auto_increment,
-> `runoob_title` varchar(100) NOT NULL default '',
-> `runoob_author` varchar(40) NOT NULL default '',
-> `submission_date` date default NULL,
-> PRIMARY KEY (`runoob_id`),
-> UNIQUE KEY `AUTHOR_INDEX` (`runoob_author`)
-> ) ENGINE=InnoDB;
Query OK, 0 rows affected (1.80 sec)
步骤三：
执行完第二步骤后，你将在数据库中创建新的克隆表 clone_tbl。 如果你想拷贝数据表的数据你
可以使用 INSERT INTO... SELECT 语句来实现。
mysql> INSERT INTO clone_tbl (runoob_id,
-> runoob_title,
-> runoob_author,
-> submission_date)
-> SELECT runoob_id,runoob_title,
-> runoob_author,submission_date
-> FROM runoob_tbl;
Query OK, 3 rows affected (0.07 sec)
Records: 3 Duplicates: 0 Warnings: 0
执行以上步骤后，你将完整的复制表，包括表结构及表数据。
注：
1、另一种完整复制表的方法:
CREATE TABLE targetTable LIKE sourceTable;
INSERT INTO targetTable SELECT * FROM sourceTable;
其他:
1、可以拷贝一个表中其中的一些字段:
CREATE TABLE newadmin AS
(
SELECT username, password FROM admin
)
2、可以将新建的表的字段改名:
CREATE TABLE 新表 AS
(
SELECT id, username AS uname, password AS pass FROM 旧表
)
3、可以拷贝一部分数据:
CREATE TABLE 新表 AS
(
SELECT * FROM 旧表 WHERE LEFT(username,1) = 's'
)
4、可以在创建表的同时定义表中的字段信息， （这个是自我定义字段的---自己测试一下，不太确定）
CREATE TABLE 新表
(
id INTEGER NOT NULL AUTO_INCREMENT PRIMARY KEY
)
AS
(
SELECT * FROM 旧表
)
重点：
区分下mysql复制表的两种方式：
第一、只复制表结构到新表
create table 新表 select * from 旧表 where 1=2
或者
create table 新表 like 旧表
第二、复制表结构及数据到新表
create table 新表 select * from 旧表
第三、另一种完整复制表的方法:
先创建和原表的表结构一致的表
CREATE TABLE targetTable LIKE sourceTable;
然后插入数据
INSERT INTO targetTable SELECT * FROM sourceTable;
第四、
# 插入部分数据：
insert into b(a, b, c) select d,e,f from b;
"""
"""
二十四、MySQL 序列使用
描述：
MySQL序列是一组整数：1, 2, 3, ...，由于一张数据表只能有一个字段自增主键
如果你想实现其他字段也实现自动增加，就可以使用MySQL序列来实现
1、AUTO_INCREMENT:
MySQL中最简单使用序列的方法就是使用 MySQL AUTO_INCREMENT 来定义列。
以下实例中创建了数据表 insert， insect 中 id 无需指定值可实现自动增长。
eg:
mysql> CREATE TABLE insect
-> (
-> id INT UNSIGNED NOT NULL AUTO_INCREMENT,
-> PRIMARY KEY (id),
-> name VARCHAR(30) NOT NULL, # type of insect
-> date DATE NOT NULL, # date collected
-> origin VARCHAR(30) NOT NULL # where collected
);
Query OK, 0 rows affected (0.02 sec)
mysql> INSERT INTO insect (id,name,date,origin) VALUES
-> (NULL,'housefly','2001-09-10','kitchen'),
-> (NULL,'millipede','2001-09-10','driveway'),
-> (NULL,'grasshopper','2001-09-10','front yard');
Query OK, 3 rows affected (0.02 sec)
Records: 3 Duplicates: 0 Warnings: 0
mysql> SELECT * FROM insect ORDER BY id;
+----+-------------+------------+------------+
| id | name | date | origin |
+----+-------------+------------+------------+
| 1 | housefly | 2001-09-10 | kitchen |
| 2 | millipede | 2001-09-10 | driveway |
| 3 | grasshopper | 2001-09-10 | front yard |
+----+-------------+------------+------------+
3 rows in set (0.00 sec)
2、设置序列的开始值:
一般情况下序列的开始值默认为1，但如果你需要指定一个开始值100，那我们可以通过以下语句来实现：
eg:
mysql> CREATE TABLE insect
-> (
-> id INT UNSIGNED NOT NULL AUTO_INCREMENT,
-> PRIMARY KEY (id),
-> name VARCHAR(30) NOT NULL,
-> date DATE NOT NULL,
-> origin VARCHAR(30) NOT NULL
)engine=innodb auto_increment=100 charset=utf8;
或者你也可以在表创建成功后，通过以下语句来实现：
mysql> ALTER TABLE insect AUTO_INCREMENT = 100;
3、重置序列的值
如果你删除了数据表中的多条记录,并希望对剩下数据的AUTO_INCREMENT列进行重新排列,那么你可以通过删除自增的列，
然后重新添加来实现,不过该操作要非常小心,如果在删除的同时又有新记录添加,有可能会出现数据混乱.
操作步骤如下所示： # 特别注意：在删除字段的时候，不要插入新的数据，否则数据就乱了
mysql> ALTER TABLE insect DROP id; # 首先删除原来的序列字段，修改表的结构
mysql> ALTER TABLE insect # 然后再次修改表的结构,把删除的字段给加上去,
-> ADD id INT UNSIGNED NOT NULL AUTO_INCREMENT FIRST,
-> ADD PRIMARY KEY (id);
"""
"""
二十五、MySQL 处理重复数据
描述：
有些 MySQL 数据表中可能存在重复的记录,有些情况我们允许重复数据的存在,但有时候我们也需要删除这些重复的数据。
如何防止数据表出现重复数据及如何删除数据表中的重复数据？
防止表中出现重复数据:
你可以在MySQL数据表中设置指定的字段为 PRIMARY KEY（主键） 或者 UNIQUE（唯一） 索引来保证数据的唯一性
1、让我们尝试一个实例: 下表中无索引及主键,所以该表允许出现多条重复记录
eg:
CREATE TABLE person_tbl
(
first_name CHAR(20),
last_name CHAR(20),
sex CHAR(10)
);
2、如果你想设置表中字段 first_name，last_name 数据不能重复，你可以设置双主键模式来设置数据的唯一性
如果你设置了双主键，那么那个键的默认值不能为NULL，可设置为NOT NULL。如下所示：
CREATE TABLE person_tbl
(
first_name CHAR(20) NOT NULL,
last_name CHAR(20) NOT NULL,
sex CHAR(10),
PRIMARY KEY (last_name, first_name)
);
3、如果我们设置了唯一索引，那么在插入重复数据时，SQL语句将无法执行成功,并抛出错。
INSERT IGNORE INTO与INSERT INTO的区别就是INSERT IGNORE会忽略数据库中已经存在的数据,如果数据库没有数据,
就插入新的数据,如果有数据的话就跳过这条数据.这样就可以保留数据库中已经存在数据,达到在间隙中插入数据的目的。
insert ignore into tablename field values () ,(),()...
4、以下实例使用了INSERT IGNORE INTO，执行后不会出错，也不会向数据表中插入重复数据：
eg：
mysql> INSERT IGNORE INTO person_tbl (last_name, first_name)
-> VALUES( 'Jay', 'Thomas');
Query OK, 1 row affected (0.00 sec)
mysql> INSERT IGNORE INTO person_tbl (last_name, first_name)
-> VALUES( 'Jay', 'Thomas');
Query OK, 0 rows affected (0.00 sec)
5、insert into 、 insert ignore into 、 replace into 、插入数据的区别：
INSERT INTO当插入数据时，在设置了记录的唯一性后，SQL语句将无法执行成功,并抛出错
INSERT IGNORE INTO当插入数据时，在设置了记录的唯一性后，如果插入重复数据，将不返回错误，只以警告形式返回
REPLACE INTO into如果存在primary 或 unique相同的记录，则先删除掉。再插入新记录
6、另一种设置数据的唯一性方法是添加一个UNIQUE索引，如下所示：
CREATE TABLE person_tbl
(
first_name CHAR(20) NOT NULL,
last_name CHAR(20) NOT NULL,
sex CHAR(10)
UNIQUE (last_name, first_name)
);
7、统计重复数据
以下我们将统计表中 first_name 和 last_name的重复记录数：
eg：
mysql> SELECT COUNT(*) as repetitions, last_name, first_name
-> FROM person_tbl
-> GROUP BY last_name, first_name
-> HAVING repetitions > 1;
注释：以上查询语句将返回 person_tbl 表中重复的记录数。
一般情况下，查询重复的值，请执行以下操作：
确定哪一列包含的值可能会重复。
在列选择列表使用COUNT(*)列出的那些列。 计算数量
在GROUP BY子句中列出的列。 聚合
HAVING子句设置重复数大于1。 筛选数据
8、过滤重复数据
方法一：
如果你需要读取不重复的数据可以在 SELECT 语句中使用 DISTINCT 关键字来过滤重复数据。
eg：
mysql> SELECT DISTINCT last_name, first_name
-> FROM person_tbl;
方法二:
你也可以使用 GROUP BY 来读取数据表中不重复的数据：
mysql> SELECT last_name, first_name
-> FROM person_tbl
-> GROUP BY (last_name, first_name)
8、删除重复数据
如果你想删除数据表中的重复数据，你可以使用以下的SQL语句：
三步：
eg：
mysql> CREATE TABLE tmp SELECT last_name,first_name,sex FROM person_tbl GROUP BY (last_name,first_name,sex);
# 首先复制表的结构和数据到另外一个表中
mysql> DROP TABLE person_tbl;
# 删除原来的表(旧表)
mysql> ALTER TABLE tmp RENAME TO person_tbl;
# 对生成的 新表 修改表的名称为 旧表
9、可以在数据表中添加 INDEX（索引） 和 PRIMAY KEY（主键）这种简单的方法来删除表中的重复记录.
方法如下：
mysql> ALTER IGNORE TABLE person_tbl
-> ADD PRIMARY KEY (last_name, first_name);
"""
"""
二十六、MySQL 及SQL注入
如果您通过网页获取用户输入的数据并将其插入一个MySQL数据库,那么就有可能发生SQL注入安全的问题。
防止SQL注入，我们需要注意以下几个要点：
1.永远不要信任用户的输入。对用户的输入进行校验，可以通过正则表达式，或限制长度；对单引号和 双"-"进行转换等。
2.永远不要使用动态拼装sql，可以使用参数化的sql或者直接使用存储过程进行数据查询存取。
3.永远不要使用管理员权限的数据库连接，为每个应用使用单独的权限有限的数据库连接。
4.不要把机密信息直接存放，加密或者hash掉密码和敏感的信息。
5.应用的异常信息应该给出尽可能少的提示，最好使用自定义的错误信息对原始错误信息进行包装
6.sql注入的检测方法一般采取辅助软件或网站平台来检测，软件一般采用sql注入检测工具jsky，网站平台就有亿思网站安全平台检测工具。
MDCSOFT SCAN等。采用MDCSOFT-IPS可以有效的防御SQL注入，XSS攻击等。
"""
"""
这两个用的不是很多，自我感觉。详细的还是去看教程吧。
二十七、 MySQL 导出数据
MySQL中你可以使用SELECT...INTO OUTFILE语句来简单的导出数据到文本文件上。
使用 SELECT ... INTO OUTFILE 语句导出数据
以下实例中我们将数据表 runoob_tbl 数据导出到 /tmp/runoob.txt 文件中:
eg：
mysql-> SELECT * FROM runoob_tbl
-> INTO OUTFILE '/tmp/runoob.txt';
你可以通过命令选项来设置数据输出的指定格式，以下实例为导出 CSV 格式：
eg:
mysql> SELECT * FROM passwd INTO OUTFILE '/tmp/runoob.txt'
-> FIELDS TERMINATED BY ',' ENCLOSED BY '"'
-> LINES TERMINATED BY '\r\n';
在下面的例子中,生成一个文件,各值用逗号隔开。这种格式可以被许多程序使用。
eg:
SELECT a,b,a+b INTO OUTFILE '/tmp/result.text'
FIELDS TERMINATED BY ',' OPTIONALLY ENCLOSED BY '"'
LINES TERMINATED BY '\n'
FROM test_table;
SELECT ... INTO OUTFILE 语句有以下属性:
LOAD DATA INFILE是SELECT ... INTO OUTFILE的逆操作，SELECT句法。为了将一个数据库的数据写入一个文件，使用SELECT ... INTO OUTFILE，为了将文件读回数据库，使用LOAD DATA INFILE。
SELECT...INTO OUTFILE 'file_name'形式的SELECT可以把被选择的行写入一个文件中。该文件被创建到服务器主机上，因此您必须拥有FILE权限，才能使用此语法。
输出不能是一个已存在的文件。防止文件数据被篡改。
你需要有一个登陆服务器的账号来检索文件。否则 SELECT ... INTO OUTFILE 不会起任何作用。
在UNIX中，该文件被创建后是可读的，权限由MySQL服务器所拥有。这意味着，虽然你就可以读取该文件，但可能无法将其删除。
"""
"""
二十八、 MySQL 导入数据
1、mysql 命令导入
使用 mysql 命令导入语法格式为： mysql -u用户名 -p密码 < 要导入的数据库数据(runoob.sql)
eg：
# mysql -uroot -p123456 < runoob.sql
以上命令将将备份的整个数据库 runoob.sql 导入。
2、source 命令导入
source 命令导入数据库需要先登录到数库终端
eg：
mysql> create database abc; # 创建数据库
mysql> use abc; # 使用已创建的数据库
mysql> set names utf8; # 设置编码
mysql> source /home/abc/abc.sql # 导入备份数据库
3、使用 LOAD DATA 导入数据
MySQL 中提供了LOAD DATA INFILE语句来插入数据. 以下实例中将从当前目录中读取文件 dump.txt
将该文件中的数据插入到当前数据库的 mytbl 表中.
mysql> LOAD DATA LOCAL INFILE 'dump.txt' INTO TABLE mytbl;
如果指定LOCAL关键词，则表明从客户主机上按路径读取文件。如果没有指定,
则文件在服务器上按路径读取文件.
你能明确地在LOAD DATA语句中指出列值的分隔符和行尾标记，但是默认标记是定位符和换行符。
两个命令的 FIELDS 和 LINES 子句的语法是一样的。两个子句都是可选的，但是如果两个同时被指定，FIELDS 子句必须出现在 LINES 子句之前。
如果用户指定一个 FIELDS 子句，它的子句 （TERMINATED BY、[OPTIONALLY] ENCLOSED BY 和 ESCAPED BY) 也是可选的，不过，用户必须至少指定它们中的一个。
mysql> LOAD DATA LOCAL INFILE 'dump.txt' INTO TABLE mytbl
-> FIELDS TERMINATED BY ':'
-> LINES TERMINATED BY '\r\n';
LOAD DATA 默认情况下是按照数据文件中列的顺序插入数据的，如果数据文件中的列与插入表中的列不一致，则需要指定列的顺序。
在数据文件中的列顺序是 a,b,c，但在插入表的列顺序为b,c,a，则数据导入语法如下：
mysql> LOAD DATA LOCAL INFILE 'dump.txt'
-> INTO TABLE mytbl (b, c, a);
"""
# https://blog.csdn.net/qq_17011423/article/details/69220231
# SELECT * FROM timeline WHERE username = ‘Allen’ AND logTime BETWEEN ‘2017-04-01’ AND DATE_ADD(‘2017-04-04’,INTERVAL 1 DAY);
# MySQL 日期加减：
# DATE_ADD(date,INTERVAL expr type) –加法
# DATE_SUB(date,INTERVAL expr type) –减法
# between a and b 包含左右边界 not between and 不包含左右边界
# select * from user where userId between 5 and 7;
# 查询userId为5、6，7的user，userId范围是包含边界值的，也等同如下查询：
# select * from user where userId >= 5 and userId <= 7;
# 另外 not between的范围是不包含边界值。
"""
通过删除数据右侧多余的空格来整理数据，这可以使用MySQL的 RTrim()函数来完成
select num,RTrim(name) from table_name
"""
"""
子 句 说 明 是否必须使用
SELECT 要返回的列或表达式 是
FROM 从中检索数据的表 仅在从表选择数据时使用
WHERE 行级过滤 否
GROUP BY 分组说明 仅在按组计算聚集时使用
HAVING 组级过滤 否
ORDER BY 输出排序顺序 否
LIMIT 要检索的行数 否
"""
"""
mysql中的where和having子句的区别:
mysql中的where和having子句都可以实现过滤记录的功能,但他们的用法还是有一些区别的,看一例子:
用group by和having子句联合来查出不重复的记录,sql如下:
select uid,email,count(*) as ct from `edm_user081217` GROUP BY email
然后看这个，就容易理解了
select uid,email,count(*) as ct from `edm_user081217` GROUP BY email HAVING ct > 1
先用group by 对email进行分组,在用having来过滤大于1的,这样查找出来的就是重复的记录了.
以下是having和where的区别：
Select city FROM weather WHERE temp_lo = (SELECT max(temp_lo) FROM weather);
作用的对象不同。WHERE 子句作用于表和视图，HAVING 子句作用于组。
WHERE 在分组和聚集计算之前选取输入行（因此，它控制哪些行进入聚集计算）， 而 HAVING 在分组和聚集之后选取分组的行。因此，WHERE 子句不能包含聚集函数； 因为试图用聚集函数判断那些行输入给聚集运算是没有意义的。 相反，HAVING 子句总是包含聚集函数。（严格说来，你可以写不使用聚集的 HAVING 子句， 但这样做只是白费劲。同样的条件可以更有效地用于 WHERE 阶段。）
在前面的例子里，我们可以在 WHERE 里应用城市名称限制，因为它不需要聚集。 这样比在 HAVING 里增加限制更加高效，因为我们避免了为那些未通过 WHERE 检查的行进行分组和聚集计算
综上所述：
having一般跟在group by之后，执行记录组选择的一部分来工作的。
where则是执行所有数据来工作的。
再者having可以用聚合函数，如having sum(qty)>1000
"""
"""
InnoDB是一个可靠的事务处理引擎（参见第26章），它不支持全文本搜索；
MEMORY在功能等同于MyISAM，但由于数据存储在内存（不是磁盘） 中，速度很快（特别适合于临时表）；
MyISAM是一个性能极高的引擎，它支持全文本搜索（参见第18章），但不支持事务处理。
本书中的样例表都使用InnoDB。原因是作者希望支持事务处理（因此，使用InnoDB），
但也需要在productnotes中支持全文本搜索（因此，使用MyISAM）。
# 将多个表给重命名 rename old_name to new_name, table_a to table_b;
rename table table_a to tabel_b,
table_c to table_d;
7、表重命名：
>RENAME TABLE name_old TO name_new;
还可以使用：
>ALTER TABLE name_old RENAME name_new;
视图用CREATE VIEW语句来创建。
使用SHOW CREATE VIEW viewname；来查看创建视图的语句。
用DROP删除视图，其语法为DROP VIEW viewname;。
创建视图：
-- CREATE VIEW hhh AS
-- SELECT
-- *
-- FROM
-- cc;
删除视图：drop view viewname
# 此时的数据 都在视图里面了
select * from view
--version
十二、全文检索——MATCH和AGAINST
1、SELECT MATCH(note_text)AGAINST('PICASO') FROM tb_name;
2、InnoDB引擎不支持全文检索，MyISAM可以；
"""
"""
选择：select * from table1 where 范围
插入：insert into table1(field1,field2) values(value1,value2)
删除：delete from table1 where 范围
更新：update table1 set field1=value1 where 范围
查找：select * from table1 where field1 like ’%value1%’ ---like的语法很精妙，查资料!
排序：select * from table1 order by field1,field2 [desc]
总数：select count as totalcount from table1
求和：select sum(field1) as sumvalue from table1
平均：select avg(field1) as avgvalue from table1
最大：select max(field1) as maxvalue from table1
最小：select min(field1) as minvalue from table1
"""
"""
12、说明：使用外连接
A、left （outer） join：
左外连接（左连接）：结果集几包括连接表的匹配行，也包括左连接表的所有行。
SQL: select a.a, a.b, a.c, b.c, b.d, b.f from a LEFT OUT JOIN b ON a.a = b.c
B：right （outer） join:
右外连接(右连接)：结果集既包括连接表的匹配连接行，也包括右连接表的所有行。
C：full/cross （outer） join：
全外连接：不仅包括符号连接表的匹配行，还包括两个连接表中的所有记录
1=1，1=2的使用，在SQL语句组合时用的较多
“where 1=1” 是表示选择全部 “where 1=2”全部不选，
"""
"""
mysql 的5种连接方式：
1、内连接 inner join
2、外连接 left join , right join, full join
3、全连接 union
4、自连接
5、交叉连接
"""
"""
sql 语句实现 5 种连接方式 ： 本地数据库 ccc，表的名字 a, b, c
SELECT * FROM a LEFT OUTER JOIN b ON a.id = b.id1; # 左连接
SELECT * FROM a RIGHT OUTER JOIN b ON a.id = b.id1; # 右连接
# 注意: LEFT JOIN 和 LEFT OUTER JOIN 一致的，没有区别
SELECT * FROM a INNER JOIN b ON a.id = b.id1; # 内连接
SELECT * FROM a CROSS JOIN b; # 交叉连接
-- SELECT * FROM a FULL JOIN b ON a.id = b.id1; 这个mysql 不支持
-- MySQL支持左连接，右连接，但是并不支持全连接. 一般都是通过联合查询实现全连接
SELECT * FROM a LEFT JOIN b ON a.id = b.id1
UNION
SELECT * FROM a RIGHT JOIN b ON a.id = b.id1; # 通过联合查询实现全连接
SELECT * FROM a UNION SELECT * FROM b; # 联合查询
SELECT * FROM a as A LEFT JOIN a as AA ON A.id = AA.id; # 自连接
# 左连接 和 内连接 同时使用。 执行顺序 ： 先左连接，后内连接
SELECT * FROM a LEFT OUTER JOIN b ON a.id = b.id1 INNER JOIN c ON a.id = c.num;
# 嵌套子查询 1
SELECT * FROM
(
SELECT * FROM a
) as a;
# 嵌套子查询 SELECT 里面 包含 SELECT
SELECT * FROM (SELECT age,a.id as id FROM a LEFT OUTER JOIN b ON a.id = b.id1) as d INNER JOIN c ON d.id = c.num;
"""
"""
# https://blog.csdn.net/qq_27905183/article/details/77840493 msyql 的连接方式
# left (outer) join on 条件 、 right (outer) join on 条件 、 full join on
inner join on :
a INNER JOIN b ON a.id=b.parent_id 内连接 显示两表中共有的数据部分，其他数据两表都不显示
left (outer) join on 条件 左(外)连接 左表数据全部显示，右表显示部分数据，右表没有的数据为 Null
a left join b on a.id = b.parent_id
right (outer) join on 条件 右(外)连接 右表数据全部显示，右表显示部分数据，左表没有的数据为 Null
a right join b on a.id = b.parent_id
full join on 全连接 返回两个表中的全部数据
a FULL JOIN b ON a.id=b.parent_id
cross join 交叉连接 返回的是笛卡尔积 m * n
SELECT * FROM 表1 CROSS JOIN 表2；
eg： SELECT * FROM `food` CROSS JOIN `order`;
自连接查询 :
可以将一个表起两个别名，这样就相当于两个表了，按照两个表的操作即可
说白了 就是把一张表 看作 两张表 ，根据其中的逻辑关系来做判断
eg :
select s.id, s.cate_name, p.cate_name from tdb_cates s left join tdb_cates p on p.parent_id=s.id;
# https://blog.csdn.net/nangeali/article/details/75042458
交叉连接
交叉连接返回的结果，是被连接的两个表中所有数据行的笛卡尔积，也就是返回第一个表中符合查询条件的数据行数，乘以第二个表中符合查询条件的数据行数
比如，Department表中有4个部门，employee表中有4个员工，那么，交叉连接的结果就有16条数据
SELECT * FROM 表1 CROSS JOIN 表2；
"""
"""
自连接 例子 ：
mysql> select * from emp;
+-----+--------+-----+--------+--------+----------+---------------------+---------------------+
| eid | ename | sex | salary | deptid | leaderid | birdate | income |
+-----+--------+-----+--------+--------+----------+---------------------+---------------------+
| 1 | 马云 | 男 | 1 | 1000 | 0 | 1985-03-05 00:00:00 | 2008-05-06 00:00:00 |
| 2 | 李小龙 | 男 | 20000 | 1001 | 1 | 1983-06-07 00:00:00 | 2012-05-05 00:00:00 |
| 3 | 成龙 | 男 | 23000 | 1002 | 2 | 1973-06-07 00:00:00 | 2013-05-05 00:00:00 |
| 4 | 杨明 | 男 | 22000 | 1003 | 2 | 1993-06-09 00:00:00 | 2013-05-06 00:00:00 |
| 5 | 黎明 | 男 | 28000 | 1004 | 3 | 1992-08-09 00:00:00 | 2013-07-06 00:00:00 |
| 6 | 范冰冰 | 女 | 12000 | 1005 | 4 | 1994-08-09 00:00:00 | 2014-07-06 00:00:00 |
| 7 | 刘亦菲 | 女 | 19000 | 1006 | 5 | 1997-08-09 00:00:00 | 2011-07-03 00:00:00 |
| 8 | 唐嫣 | 女 | 39000 | 1007 | 6 | 1991-08-09 00:00:00 | 2015-07-03 00:00:00 |
+-----+--------+-----+--------+--------+----------+---------------------+---------------------+
复制代码
把一张表看成两张表，一张员工表，一张领导表，都是emp表
复制代码
mysql> select e.ename '无领导ename',le.ename '领导ename'
-> from emp e left join emp le
-> on e.leaderid = le.eid;
+-------------+-----------+
| 无领导ename | 领导ename |
+-------------+-----------+
| 李小龙 | 马云 |
| 成龙 | 李小龙 |
| 杨明 | 李小龙 |
| 黎明 | 成龙 |
| 范冰冰 | 杨明 |
| 刘亦菲 | 黎明 |
| 唐嫣 | 范冰冰 |
| 马云 | NULL |
+-------------+-----------+
"""
# https://www.2cto.com/database/201712/702968.html mysql orm 网址
"""
【方式一】在创建表的时候进行添加
[CONSTRAINT symbol] FOREIGN KEY [id] (从表的字段1) REFERENCES tbl_name (主表的字段2)
constraint 外键别名 FOREIGN KEY (从表字段) REFERENCES (主表) （主表字段）;
【方式二】 修改表结构添加外键
主外键 ： 从表 从表字段(外键) 主表 主表字段,(主键)
ALTER TABLE employee ADD FOREIGN KEY(dept_id) REFERENCES department (id);
代码解释:
ALTER TABLE employee：在从表employee中进行操作；
ADD FOREIGN KEY(dept_id)：将从表的字段dept_id添加为外键；
REFERENCES department(id)：映射到主表department当中为id的字段。
运行上方代码后，我们通过navicat来看一下外键有没有添加成功：
(2)、删除外键：
alter table emp drop foreign key 外键名;
constraint 外键别名 foreign key(属性1.1, 属性1.2， ..., 属性1.n) references 表名(属性2.1, 属性2.2， ..., 属性2.n)
"""
# http://www.meiling123.com/meiling/site/mzsm cdn 服务器