数据类型介绍

  • 整型
  1. tinyint, # 占1字节,有符号：-128~127,无符号位:0~255
  2. smallint, # 占2字节,有符号：-32768~32767,无符号位:0~65535
  3. mediumint,# 占3字节,有符号：-8388608~8388607,无符位:0~16777215
  4. int, # 占4字节,有符号：-2147483648~2147483647,无符号位:0~4284967295
  5. bigint,# 占8字节
  6. bool 等价于tinyint(1) 布尔型
  • 浮点型
  1. float([m[,d]]) # 占4字节,1.17E-38~3.4E+38
  2. double([m[,d]]) # 占8字节
  3. decimal([m[,d]]) # 以字符串形式表示的浮点数
  • 字符型
  1. char([m]): # 固定长度的字符,占用m字节
  2. varchar[(m)]: # 可变长度的字符,占用m+1字节，大于255个字符：占用m+2
  3. tinytext, # 255个字符(2的8次方)
  4. text, # 65535个字符(2的16次方)
  5. mediumtext, # 16777215字符(2的24次方)
  6. longtext, # (2的32次方)
  7. enum(value,value,...) # 占1/2个字节 最多可以有65535个成员
  8. set(value,value,...) # 占1/2/3/4/8个字节，最多可以有64个成员

常用select命令

  1. # 使用select命令查看mysql数据库系统信息：
  2.  
  3. #-- 打印当前的日期和时间
  4. select now();  
  5.  
  6. #-- 打印当前的日期
  7. select curdate();  
  8.  
  9. # -- 打印当前的时间
  10. select curtime();  
  11.  
  12. # -- 打印当前数据库
  13. select database();  
  14.  
  15. # -- 打印MySQL版本
  16. select version();  
  17.  
  18. #-- 打印当前用户
  19. select user();  
  20.  
  21. # --查看系统信息
  22. show variables;
  23. show global variables;
  24. show global variables like '%version%';
  25. show variables like '%storage_engine%'; #  默认的存储引擎  
  26.  
  27. # like模糊搜索还可用户where字句，例如
  28. select * from students where stname like '%l%1%2%3%';
  29. # 除了like 还有not like
  30. show engines; # 查看支持哪些存储引擎
  31.  
  32. # --查看系统运行状态信息
  33. show status;
  34. show global status like 'Thread%';

MySQL 排序

  • 我们知道从 MySQL 表中使用 SQL SELECT 语句来读取数据。
  • 如果我们需要对读取的数据进行排序，我们就可以使用 MySQL 的 ORDER BY 子句来设定你想按哪个字段哪种方式来进行排序，再返回搜索结果。

语法

  • 以下是 SQL SELECT 语句使用 ORDER BY 子句将查询数据排序后再返回数据：
  1. # SELECT field1, field2,...fieldN FROM table_name1, table_name2...
  2. # ORDER BY field1 [ASC [DESC][默认 ASC]], [field2...] [ASC [DESC][默认 ASC]]
  • 你可以使用任何字段来作为排序的条件，从而返回排序后的查询结果。
  • 你可以设定多个字段来排序。
  • 你可以使用 ASC 或 DESC 关键字来设置查询结果是按升序或降序排列。 默认情况下，它是按升序排列。
  • 你可以添加 WHERE...LIKE 子句来设置条件。

案例

  • asc从小到大排列，即升序
  • desc从大到小排序，即降序
  1. # 查询年龄在18到34岁之间的男性，按照年龄从小到大到排序
  2. # select * from students where (age between 18 and 34) and gender = 1 order by age asc;
  3.  
  4. # 查询年龄在18到34岁之间的女性，身高从高到矮排序
  5. # select * from students where (age between 18 and 34) and gender = 2 order by height desc;
  • order by 多个字段
  1. # 查询年龄在18到34岁之间的女性，身高从高到矮排序, 如果身高相同的情况下按照年龄从小到大排序
  2. # select * from students where (age between 18 and 34) and gender = 2 order by height desc,age asc;
  3.  
  4. # 查询年龄在18到34岁之间的女性，身高从高到矮排序, 如果身高相同的情况下按照年龄从小到大排序,如果年龄也相同那么按照id从大到小排序
  5. # select * from students where (age between 18 and 34) and gender = 2 order by height desc,age asc,id desc;
  1. # mysql> select bName,price from books where price  in (50,60,70) order by price asc;
  2. +--------------------------------------+-------+
  3. | bName                          | price |
  4. +--------------------------------------+-------+
  5. | Illustrator 10完全手册      |    50 |
  6. | FreeHand 10基础教程      |    50 |
  7. | 网站设计全程教程             |    50 |
  8. | ASP数据库系统开发实例导航  |    60 |
  9. | Delphi 5程序设计与控件参考  |    60 |
  10. | ASP数据库系统开发实例导航   |    60 |

升序：order by “排序的字段” asc 默认

  1. # mysql> select bName,price from books where price  in (50,60,70) order by price desc;
  2. +--------------------------------+-----------------+
  3. | bName                                | price |
  4. +--------------------------------+-----------------+
  5. | ASP数据库系统开发实例导航     |    60 |
  6. | Delphi 5程序设计与控件参考    |    60 |
  7. | ASP数据库系统开发实例导航    |    60 |
  8. | Illustrator 10完全手册           |    50 |
  9. | FreeHand 10基础教程           |    50 |
  10. | 网站设计全程教程                  |    50 |

降序：oredr by “排序的字段” desc

  1. select bName,price from books where price  in (50,60,70) order by price desc,bName desc;

多个字段排序

MySQL 分组

MySQL GROUP BY 语句

  • GROUP BY 语句根据一个或多个列对结果集进行分组。
  • 在分组的列上我们可以使用 COUNT, SUM, AVG,等函数。

GROUP BY 语法

  1. # SELECT column_name, function(column_name)
  2. # FROM table_name
  3. # WHERE column_name operator value
  4. # GROUP BY column_name;

实例演示

  • 本章节实例使用到了以下表结构及数据，使用前我们可以先将以下数据导入数据库中。
  1. SET NAMES utf8;
  2. SET FOREIGN_KEY_CHECKS =0;
  3. -- ----------------------------
  4. -- Table structure for`employee_tbl`
  5. -- ----------------------------
  6. DROP TABLE IF EXISTS `employee_tbl`;
  7. CREATE TABLE `employee_tbl`(
  8. 　　`id`int(11) NOT NULL,
  9. 　　`name`char(10) NOT NULL DEFAULT '',
  10. 　　`date` datetime NOT NULL,
  11. 　　`singin` tinyint(4) NOT NULL DEFAULT '' COMMENT '登录次数',
  12.   　　PRIMARY KEY (`id`)
  13. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
  14. -- ----------------------------
  15. -- Records of `employee_tbl`
  16. -- ----------------------------BEGIN;
  17. INSERT INTO `employee_tbl` VALUES ('','小明','2016-04-22 15:25:33',''),
  18. ('','小王','2016-04-20 15:25:47',''),('','小丽','2016-04-19 15:26:02',''),
  19. ('','小王','2016-04-07 15:26:14',''),('','小明','2016-04-11 15:26:40',''),
  20. ('','小明','2016-04-04 15:26:54','');
  21. COMMIT;
  22. SET FOREIGN_KEY_CHECKS =1;
  • 导入成功后，执行以下 SQL 语句：
  1. # mysql>set names utf8;
  2. # mysql> SELECT * FROM employee_tbl;
  3. +----+--------+------------------+--------+
  4. | id | name | date              | singin |
  5. +----+--------+------------------+--------+
  6. |1   |小明   |2016-04-2215:25:33 |1|
  7. |2   |小王   |2016-04-2015:25:47 |3|
  8. |3   |小丽   |2016-04-1915:26:02 |2|
  9. |4   |小王   |2016-04-0715:26:14 |4|
  10. |5   |小明   |2016-04-1115:26:40 |4|
  11. |6   |小明   |2016-04-0415:26:54 |2|
  12. +----+--------+------------------+--------+
  13. 6 rows inset(0.00 sec)
  • 接下来我们使用 GROUP BY 语句 将数据表按名字进行分组，并统计每个人有多少条记录：
  1. # mysql> SELECT name, COUNT(*) FROM   employee_tbl GROUP BY name;
  2. +--------+----------+
  3. | name  | COUNT(*)|
  4. +--------+----------+
  5. |小丽　　|　　1|
  6. |小明　　|　　3|
  7. |小王　　|　　2|
  8. +--------+----------+
  9. 3 rows inset(0.01 sec)

使用 WITH ROLLUP

  • WITH ROLLUP 可以实现在分组统计数据基础上再进行相同的统计（SUM,AVG,COUNT…）。
  • 例如我们将以上的数据表按名字进行分组，再统计每个人登录的次数：
  1. # mysql> SELECT name, SUM(singin)as singin_count FROM  employee_tbl GROUP BY name WITH ROLLUP;
  2. +--------+--------------+
  3. | name | singin_count |
  4. +--------+--------------+
  5. |小丽　　|　　2|
  6. |小明　　|　　7|
  7. |小王　　|　　7|
  8. | NULL  |　　16|
  9. +--------+--------------+
  10. 4 rows inset(0.00 sec)
  • 其中记录 NULL 表示所有人的登录次数。
  • 我们可以使用 coalesce 来设置一个可以取代 NUll 的名称，coalesce 语法：
  1. # select coalesce(a,b,c);
  • 参数说明：如果a==null,则选择b；如果b==null,则选择c；如果a!=null,则选择a；如果a b c 都为null ，则返回为null（没意义）。
  • 以下实例中如果名字为空我们使用总数代替：
  1. # mysql> SELECT coalesce(name,'总数'), SUM(singin)as singin_count FROM  employee_tbl GROUP BY name WITH ROLLUP;
  2. +--------------------------+--------------+
  3. | coalesce(name,'总数')| singin_count |
  4. +--------------------------+--------------+
  5. |小丽　　　　　　　　　　　　|　　2|
  6. |小明　　　　　　　　　　　　|　　7|
  7. |小王　　　　　　　　　　　　|　　7|
  8. |总数　　　　　　　　　　　　|　　16|
  9. +--------------------------+--------------+
  10. 4 rows inset(0.01 sec)

MySQL 连接查询

  • 在前几章节中，我们已经学会了如何在一张表中读取数据，这是相对简单的，但是在真正的应用中经常需要从多个数据表中读取数据。
  • 本章节我们将向大家介绍如何使用 MySQL 的 JOIN 在两个或多个表中查询数据。
  • 你可以在 SELECT, UPDATE 和 DELETE 语句中使用 Mysql 的 JOIN 来联合多表查询。

JOIN 按照功能大致分为如下三类：

  • INNER JOIN（内连接,或等值连接）：获取两个表中字段匹配关系的记录。
  • LEFT JOIN（左连接）：获取左表所有记录，即使右表没有对应匹配的记录。
  • RIGHT JOIN（右连接）： 与 LEFT JOIN 相反，用于获取右表所有记录，即使左表没有对应匹配的记录。

示例：

  • 以一个共同的字段，求两张表当中符合条件的并集。 通过共同字段把这两张表连接起来。

常用的连接：

  • 内连接：根据表中的共同字段进行匹配
  • 外连接分两种：左外连接、右外链接。

内连接：

  • 语法：

  1. # select 字段  from 表1 inner join 表2  on 表1.字段=表2.字段
  • 内连接：根据表中的共同字段进行匹配
  1. # 测试
  2. select a.bname,a.price,b.btypename from books a inner join category b on a.btypeid=b.btypeid;
  3. # 实际使用中inner可省略掉
  4. # 跟WHERE 子句结果一样
  5. select a.bname,a.price,b.btypename from books a, category b where a.btypeid=b.btypeid;
  • 外连接 (分为左外连接；右外连接)

            

  1. # 左连接： select 字段 from a表 left join b表 on 连接条件
  2. # a表是主表，都显示。
  3. # b表从表
  4. # 主表内容全都有，从表内没有的显示null。
  5. Select a.bname,a.price,b.btypename from books a left join category b on a.btypeid=b.btypeid; 
  1. # 右连接：select 字段 from a表 right join b表 on 条件
  2. # a表是从表，
  3. # b表主表，都显示。
  4. Select a.bname,b.* from books a right join category b on a.btypeid=b.btypeid;
  5. # 右连接，可以多表连接  
  1. inner join ... on
  2. select ... from 表A inner join 表B;
  3. select * from students inner join classes;
  4.  
  5. # 查询 有能够对应班级的学生以及班级信息
  6. select * from students inner join classes on students.cls_id = classes.id;
  7.  
  8. # 按照要求显示姓名、班级
  9. select students.name,classes.name from students inner join classes on students.cls_id = classes.id;
  10.  
  11. # 给数据表起名字
  12. select s.name,c.name from students as s inner join classes as c on s.cls_id = c.id;
  13.  
  14. # 查询 有能够对应班级的学生以及班级信息，显示学生的所有信息 students.*，只显示班级名称 classes.name.
  15. select s.*,c.name from students as s inner join classes as c on s.cls_id = c.id;
  16.  
  17. # 在以上的查询中，将班级姓名显示在第1列
  18. select c.name,s.* from students as s inner join classes as c on s.cls_id = c.id;
  19.  
  20. # 查询 有能够对应班级的学生以及班级信息, 按照班级进行排序
  21. select c.xxx s.xxx from students as s inner join clssses as c on .... order by ....;
  22. select c.name,s.* from students as s inner join classes as c on s.cls_id = c.id order by c.name;
  23.  
  24. # 当时同一个班级的时候，按照学生的id进行从小到大排序
  25. select c.name,s.* from students as s inner join classes as c on s.cls_id = c.id order by c.name,id asc;
  26.  
  27. # left join
  28. # 查询每位学生对应的班级信息
  29. select * from students left join classes on students.cls_id = classes.id;
  30.  
  31. # right join
  32. select * from students right join classes on students.cls_id = classes.id;
  33.  
  34. # 查询没有对应班级信息的学生
  35. # 语句
  36. select ... from xxx as s left join xxx as c on..... where .....
  37. select ... from xxx as s left join xxx as c on..... having .....
  38.  
  39. # 列
  40. select * from students left join classes on students.cls_id = classes.id where classes.name is null;
  41. #(注意)不建议使用 select * from students left join classes on students.cls_id=classes.id having classes.id is null;
  42. # right join   on
  43. # 将数据表名字互换位置，用left join完成
  44.  
  45. 应用示例

应用示例

MySQL NULL 值处理

  • 我们已经知道 MySQL 使用 SQL SELECT 命令及 WHERE 子句来读取数据表中的数据,但是当提供的查询条件字段为 NULL 时，该命令可能就无法正常工作。

为了处理这种情况，MySQL提供了三大运算符:

  • IS NULL: 当列的值是 NULL,此运算符返回 true。
  • IS NOT NULL: 当列的值不为 NULL, 运算符返回 true。
  • <=>: 比较操作符（不同于 = 运算符），当比较的的两个值相等或者都为 NULL 时返回 true。
  1. 关于 NULL 的条件比较运算是比较特殊的。你不能使用 = NULL 或 != NULL 在列中查找 NULL 值 。
  2. 在 MySQL 中，NULL 值与任何其它值的比较（即使是 NULL）永远返回 NULL，即 NULL = NULL 返回 NULL 。
  3. MySQL 中处理 NULL 使用 IS NULL 和 IS NOT NULL 运算符。
  1. # 注意：
  2. select * , columnName1+ifnull(columnName2,0) from tableName;
  3. # columnName1，columnName2 为 int 型，当 columnName2 中，有值为 null 时，columnName1+columnName2=null，
  4. ifnull(columnName2,0) 把 columnName2 中 null 值转为 0

案例

  • 判空is null
  1. # 查询身高为空的信息
  2. select * from students where height is null;
  3.  
  4. # 判非空is not null
  5. select * from students where height is not null;

MySQL 正则表达式

  • 在前面的章节我们已经了解到MySQL可以通过 LIKE ...% 来进行模糊匹配。
  • MySQL 同样也支持其他正则表达式的匹配， MySQL中使用 REGEXP 操作符来进行正则表达式匹配。
  • 如果您了解PHP或Perl，那么操作起来就非常简单，因为MySQL的正则表达式匹配与这些脚本的类似。
  • 下表中的正则模式可应用于 REGEXP 操作符中。
模式 描述
^ 匹配输入字符串的开始位置。如果设置了 RegExp 对象的 Multiline 属性，^ 也匹配 '\n' 或 '\r' 之后的位置。
$ 匹配输入字符串的结束位置。如果设置了RegExp 对象的 Multiline 属性，$ 也匹配 '\n' 或 '\r' 之前的位置。
. 匹配除 "\n" 之外的任何单个字符。要匹配包括 '\n' 在内的任何字符，请使用象 '[.\n]' 的模式。
[...] 字符集合。匹配所包含的任意一个字符。例如， '[abc]' 可以匹配 "plain" 中的 'a'。
[^...] 负值字符集合。匹配未包含的任意字符。例如， '[^abc]' 可以匹配 "plain" 中的'p'。
p1|p2|p3 匹配 p1 或 p2 或 p3。例如，'z|food' 能匹配 "z" 或 "food"。'(z|f)ood' 则匹配 "zood" 或 "food"。
* 匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。* 等价于{0,}。
+ 匹配前面的子表达式一次或多次。例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。
{n} n 是一个非负整数。匹配确定的 n 次。例如，'o{2}' 不能匹配 "Bob" 中的 'o'，但是能匹配 "food" 中的两个 o。
{n,m} m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。

示例

  • 了解以上的正则需求后，我们就可以根据自己的需求来编写带有正则表达式的SQL语句。以下我们将列出几个小实例(表名：person_tbl )来加深我们的理解：
  1. # 查找name字段中以'st'为开头的所有数据：
  2. mysql> SELECT name FROM person_tbl WHERE name REGEXP '^st';
  3.  
  4. # 查找name字段中以'ok'为结尾的所有数据：
  5. mysql> SELECT name FROM person_tbl WHERE name REGEXP 'ok$';
  6.  
  7. # 查找name字段中包含'mar'字符串的所有数据：
  8. mysql> SELECT name FROM person_tbl WHERE name REGEXP 'mar';
  9.  
  10. # 查找name字段中以元音字符开头或以'ok'字符串结尾的所有数据：
  11. mysql> SELECT name FROM person_tbl WHERE name REGEXP '^[aeiou]|ok$';

MySQL 事务

MySQL 事务主要用于处理操作量大，复杂度高的数据。比如说，在人员管理系统中，你删除一个人员，你既需要删除人员的基本资料，也要删除和该人员相关的信息，如信箱，文章等等，这样，这些数据库操作语句就构成一个事务，详细了解可以看一下这篇【常识与进阶】！

  • 在 MySQL 中只有使用了 Innodb 数据库引擎的数据库或表才支持事务。
  • 事务处理可以用来维护数据库的完整性，保证成批的 SQL 语句要么全部执行，要么全部不执行。
  • 事务用来管理 insert,update,delete 语句

一般来说，事务是必须满足4个条件（ACID）：：原子性（Atomicity，或称不可分割性）、一致性（Consistency）、隔离性（Isolation，又称独立性）、持久性（Durability）。

  • 原子性：一个事务（transaction）中的所有操作，要么全部完成，要么全部不完成，不会结束在中间某个环节。事务在执行过程中发生错误，会被回滚（Rollback）到事务开始前的状态，就像这个事务从来没有执行过一样。
  • 一致性：在事务开始之前和事务结束以后，数据库的完整性没有被破坏。这表示写入的资料必须完全符合所有的预设规则，这包含资料的精确度、串联性以及后续数据库可以自发性地完成预定的工作。
  • 隔离性：数据库允许多个并发事务同时对其数据进行读写和修改的能力，隔离性可以防止多个事务并发执行时由于交叉执行而导致数据的不一致。事务隔离分为不同级别，包括读未提交（Read uncommitted）、读提交（read committed）、可重复读（repeatable read）和串行化（Serializable）。
  • 持久性：事务处理结束后，对数据的修改就是永久的，即便系统故障也不会丢失。
  1. # 在 MySQL 命令行的默认设置下，事务都是自动提交的，即执行 SQL 语句后就会马上执行 COMMIT 操作。
    　因此要显式地开启一个事务务须使用命令 BEGIN 或 START TRANSACTION，或者执行命令 SETAUTOCOMMIT=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 事务处理主要有两种方法：

  • 用 BEGIN, ROLLBACK, COMMIT来实现

    • BEGIN 开始一个事务
    • ROLLBACK事务回滚
    • COMMIT事务确认
  • 直接用 SET 来改变 MySQL 的自动提交模式:
    • SET AUTOCOMMIT=0 禁止自动提交
    • SET AUTOCOMMIT=1开启自动提交
  1. # mysql> use RUNOOB;
  2. Database changed
  3. # mysql> CREATE TABLE runoob_transaction_test( id int(5)) engine=innodb;  # 创建数据表
  4. Query OK, 0 rows affected (0.04 sec)
  5.  
  6. # mysql> select * from runoob_transaction_test;
  7. Empty set (0.01 sec)
  8.  
  9. # mysql> begin;  # 开始事务
  10. Query OK, 0 rows affected (0.00 sec)
  11.  
  12. # mysql> insert into runoob_transaction_test value(5);
  13. Query OK, 1 rows affected (0.01 sec)
  14.  
  15. # mysql> insert into runoob_transaction_test value(6);
  16. Query OK, 1 rows affected (0.00 sec)
  17.  
  18. # mysql> commit; # 提交事务
  19. Query OK, 0 rows affected (0.01 sec)
  20.  
  21. # mysql>  select * from runoob_transaction_test;
  22. +------+
  23. | id   |
  24. +------+
  25. | 5    |
  26. | 6    |
  27. +------+
  28. rows in set (0.01 sec)
  29.  
  30. # mysql> begin;    # 开始事务
  31. Query OK, 0 rows affected (0.00 sec)
  32.  
  33. # mysql>  insert into runoob_transaction_test values(7);
  34. Query OK, 1 rows affected (0.00 sec)
  35.  
  36. # mysql> rollback;   # 回滚
  37. Query OK, 0 rows affected (0.00 sec)
  38.  
  39. # mysql>   select * from runoob_transaction_test;   # 因为回滚所以数据没有插入
  40. +------+
  41. | id   |
  42. +------+
  43. | 5    |
  44. | 6    |
  45. +------+
  46. rows in set (0.01 sec)
  47.  
  48. # mysql>
  49.  
  50. 事物测试

事物测试

  1. <?php
  2. $dbhost = 'localhost:3306';  // mysql服务器主机地址
  3. $dbuser = 'root';            // mysql用户名
  4. $dbpass = '';          // mysql用户名密码
  5. $conn = mysqli_connect($dbhost, $dbuser, $dbpass);
  6. if(! $conn )
  7. {
  8.     die('连接失败: ' . mysqli_error($conn));
  9. }
  10. // 设置编码，防止中文乱码
  11. mysqli_query($conn, "set names utf8");
  12. mysqli_select_db( $conn, 'RUNOOB' );
  13. mysqli_query($conn, "SET AUTOCOMMIT=0"); // 设置为不自动提交，因为MYSQL默认立即执行
  14. mysqli_begin_transaction($conn);            // 开始事务定义
  15.  
  16. if(!mysqli_query($conn, "insert into runoob_transaction_test (id) values(8)"))
  17. {
  18.     mysqli_query($conn, "ROLLBACK");     // 判断当执行失败时回滚
  19. }
  20.  
  21. if(!mysqli_query($conn, "insert into runoob_transaction_test (id) values(9)"))
  22. {
  23.     mysqli_query($conn, "ROLLBACK");      // 判断执行失败时回滚
  24. }
  25. mysqli_commit($conn);            //执行事务
  26. mysqli_close($conn);
  27. ?>
  28.  
  29. PHP中使用事物示例

PHP中使用事务实例

MySQL ALTER命令

  • 当我们需要修改数据表名或者修改数据表字段时，就需要使用到MySQL ALTER命令。
  1. # root@host# mysql -u root -p password;
  2. Enter password:*******
  3. # mysql> use RUNOOB;
  4. Database changed
  5. # mysql> create table testalter_tbl
  6.     -> (
  7.     -> i INT,
  8.     -> c CHAR(1)
  9.     -> );
  10. Query OK, 0 rows affected (0.05 sec)
  11. # mysql> SHOW COLUMNS FROM testalter_tbl;
  12. +-------+---------+------+-----+---------+-------+
  13. | Field | Type    | Null | Key | Default | Extra |
  14. +-------+---------+------+-----+---------+-------+
  15. | i     | int(11) | YES  |     | NULL    |       |
  16. | c     | char(1) | YES  |     | NULL    |       |
  17. +-------+---------+------+-----+---------+-------+
  18. 2 rows in set (0.00 sec)

删除，添加或修改表字段

  1. # 如下命令使用了 ALTER 命令及 DROP 子句来删除以上创建表的 i 字段：
  2. mysql> ALTER TABLE testalter_tbl  DROP i;
  3.  
  4. # 如果数据表中只剩余一个字段则无法使用DROP来删除字段。
  5. # MySQL 中使用 ADD 子句来向数据表中添加列，如下实例在表 testalter_tbl
  6. # 中添加 i 字段，并定义数据类型:
  7. mysql> ALTER TABLE testalter_tbl ADD i INT;
  • 执行以上命令后，i 字段会自动添加到数据表字段的末尾。
  1. # mysql> SHOW COLUMNS FROM testalter_tbl;
  2. +-------+---------+------+-----+---------+-------+
  3. | Field | Type    | Null | Key | Default | Extra |
  4. +-------+---------+------+-----+---------+-------+
  5. | c     | char(1) | YES  |     | NULL    |       |
  6. | i     | int(11) | YES  |     | NULL    |       |
  7. +-------+---------+------+-----+---------+-------+
  8. 2 rows in set (0.00 sec)
  9. # 如果你需要指定新增字段的位置，可以使用MySQL提供的关键字 FIRST (设定位第一列)， AFTER 字段名（设定位于某个字段之后）。
  • 尝试以下 ALTER TABLE 语句, 在执行成功后，使用 SHOW COLUMNS 查看表结构的变化：
  1. ALTER TABLE testalter_tbl DROP i;
  2. ALTER TABLE testalter_tbl ADD i INT FIRST;
  3. ALTER TABLE testalter_tbl DROP i;
  4. ALTER TABLE testalter_tbl ADD i INT AFTER c;
  5. # FIRST 和 AFTER 关键字可用于 ADD 与 MODIFY 子句，所以如果你想重置数据表字段的位置就需要先使用 DROP 删除字段然后使用
  6.   ADD 来添加字段并设置位置。

修改字段类型及名称

  • 如果需要修改字段类型及名称, 你可以在ALTER命令中使用 MODIFY 或 CHANGE 子句 。
  1. # 例如，把字段 c 的类型从 CHAR(1) 改为 CHAR(10)，可以执行以下命令:
  2. mysql> ALTER TABLE testalter_tbl MODIFY c CHAR(10);
  3.  
  4. # 使用 CHANGE 子句, 语法有很大的不同。 在 CHANGE 关键字之后，紧跟着的是你要修改的字段名，然后指定新字段名及类型。尝试如下实例：
  5. mysql> ALTER TABLE testalter_tbl CHANGE i j BIGINT;
  6. mysql> ALTER TABLE testalter_tbl CHANGE j j INT;

ALTER TABLE 对 Null 值和默认值的影响

  • 当你修改字段时，你可以指定是否包含值或者是否设置默认值。
  1. # 以下实例，指定字段 j 为 NOT NULL 且默认值为100 。
  2. mysql> ALTER TABLE testalter_tbl
  3.     -> MODIFY j BIGINT NOT NULL DEFAULT 100;
  4. # 如果你不设置默认值，MySQL会自动设置该字段默认为 NULL

修改字段默认值

  1. # mysql> ALTER TABLE testalter_tbl ALTER i SET DEFAULT 1000;
  2. # mysql> SHOW COLUMNS FROM testalter_tbl;
  3. +-------+---------+------+-----+---------+-------+
  4. | Field | Type    | Null | Key | Default | Extra |
  5. +-------+---------+------+-----+---------+-------+
  6. | c     | char(1) | YES  |     | NULL    |       |
  7. | i     | int(11) | YES  |     | 1000    |       |
  8. +-------+---------+------+-----+---------+-------+
  9. rows in set (0.00 sec)

你可以使用 ALTER 来修改字段的默认值，尝试以下实例：

  1. # mysql> ALTER TABLE testalter_tbl ALTER i DROP DEFAULT;
  2. # mysql> SHOW COLUMNS FROM testalter_tbl;
  3. +-------+---------+------+-----+---------+-------+
  4. | Field | Type    | Null | Key | Default | Extra |
  5. +-------+---------+------+-----+---------+-------+
  6. | c     | char(1) | YES  |     | NULL    |       |
  7. | i     | int(11) | YES  |     | NULL    |       |
  8. +-------+---------+------+-----+---------+-------+
  9. rows in set (0.00 sec)
  10. Changing a Table Type:

你也可以使用 ALTER 命令及 DROP子句来删除字段的默认值，如下实例：

  • 修改数据表类型，可以使用 ALTER 命令及 TYPE 子句来完成。尝试以下实例，我们将表 testalter_tbl 的类型修改为 MYISAM ：
  • 注意：查看数据表类型可以使用 SHOW TABLE STATUS 语句。
  1. # mysql> ALTER TABLE testalter_tbl ENGINE = MYISAM;
  2. # mysql>  SHOW TABLE STATUS LIKE 'testalter_tbl'\G
  3. # *************************** 1. row ****************
  4.            Name: testalter_tbl
  5.            Type: MyISAM
  6.      Row_format: Fixed
  7.            Rows: 0
  8.  Avg_row_length: 0
  9.     Data_length: 0
  10. Max_data_length: 25769803775
  11.    Index_length: 1024
  12.       Data_free: 0
  13.  Auto_increment: NULL
  14.     Create_time: 2007-06-03 08:04:36
  15.     Update_time: 2007-06-03 08:04:36
  16.      Check_time: NULL
  17.  Create_options:
  18.         Comment:
  19. 1 row in set (0.00 sec)

修改表名

  • 如果需要修改数据表的名称，可以在 ALTER TABLE 语句中使用 RENAME 子句来实现。
  • 尝试以下实例将数据表 testalter_tbl 重命名为 alter_tbl：
  1. # mysql> ALTER TABLE testalter_tbl RENAME TO alter_tbl;
  • ALTER 命令还可以用来创建及删除MySQL数据表的索引，该功能看下面章节中介绍。

MySQL 索引

  • MySQL索引的建立对于MySQL的高效运行是很重要的，索引可以大大提高MySQL的检索速度。
  • 打个比方，如果合理的设计且使用索引的MySQL是一辆兰博基尼的话，那么没有设计和使用索引的MySQL就是一个人力三轮车。
  • 拿汉语字典的目录页（索引）打比方，我们可以按拼音、笔画、偏旁部首等排序的目录（索引）快速查找到需要的字。
  • 索引分单列索引和组合索引。单列索引，即一个索引只包含单个列，一个表可以有多个单列索引，但这不是组合索引。组合索引，即一个索引包含多个列。
  • 创建索引时，你需要确保该索引是应用在 SQL 查询语句的条件(一般作为 WHERE 子句的条件)。
  • 实际上，索引也是一张表，该表保存了主键与索引字段，并指向实体表的记录。
  • 上面都在说使用索引的好处，但过多的使用索引将会造成滥用。因此索引也会有它的缺点：虽然索引大大提高了查询速度，同时却会降低更新表的速度，如对表进行INSERT、UPDATE和DELETE。因为更新表时，MySQL不仅要保存数据，还要保存一下索引文件。
  • 建立索引会占用磁盘空间的索引文件。

创建普通索引

  1. # 这是最基本的索引，它没有任何限制。它有以下几种创建方式：
  2. CREATE INDEX indexName ON mytable(username(length));
  3. # 如果是CHAR，VARCHAR类型，length可以小于字段实际长度；如果是BLOB和TEXT类型，必须指定 length。

修改表结构(添加索引)

  1. # ALTER table tableName ADD INDEX indexName(columnName)
  2. # 创建表的时候直接指定
  3. CREATE TABLE mytable(
  4.  ID INT NOT NULL,
  5.  username VARCHAR(16) NOT NULL,
  6.  INDEX [indexName] (username(length))
  7.  );
  8.  
  9. # 删除索引的语法
  10. DROP INDEX [indexName] ON mytable;

创建唯一索引

  • 它与前面的普通索引类似，不同的就是：索引列的值必须唯一，但允许有空值。如果是组合索引，则列值的组合必须唯一。它有以下几种创建方式：
  1. # CREATE UNIQUE INDEX indexName ON mytable(username(length)) 
  2.  
  3. # 修改表结构
  4. ALTER table mytable ADD UNIQUE [indexName] (username(length))
  5.  
  6. # 创建表的时候直接指定
  7. CREATE TABLE mytable(
  8. ID INT NOT NULL,
  9. username VARCHAR(16) NOT NULL,
  10. UNIQUE [indexName] (username(length))
  11. );

使用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 ，用于全文索引。
  1. #以下实例为在表中添加索引。
  2. mysql> ALTER TABLE testalter_tbl ADD INDEX (c);
  3.  
  4. # 你还可以在 ALTER 命令中使用 DROP 子句来删除索引。尝试以下实例删除索引:
  5. mysql> ALTER TABLE testalter_tbl DROP INDEX c;

使用 ALTER 命令添加和删除主键

  • 主键只能作用于一个列上，添加主键索引时，你需要确保该主键默认不为空（NOT NULL）。实例如下：
  1. # mysql> ALTER TABLE testalter_tbl MODIFY i INT NOT NULL;
  2. # mysql> ALTER TABLE testalter_tbl ADD PRIMARY KEY (i);
  3.  
  4. # 你也可以使用 ALTER 命令删除主键：
  5. mysql> ALTER TABLE testalter_tbl DROP PRIMARY KEY;
  6. # 删除主键时只需指定PRIMARY KEY，但在删除索引时，你必须知道索引名。

显示索引信息

  • 你可以使用 SHOW INDEX 命令来列出表中的相关的索引信息。可以通过添加 \G 来格式化输出信息。
  1. # 尝试以下实例:
  2. mysql> SHOW INDEX FROM table_name; \G
  3. ........

MySQL 临时表

  • MySQL 临时表在我们需要保存一些临时数据时是非常有用的临时表只在当前连接可见，当关闭连接时，Mysql会自动删除表并释放所有空间。
  • 临时表在MySQL 3.23版本中添加，如果你的MySQL版本低于 3.23版本就无法使用MySQL的临时表。不过现在一般很少有再使用这么低版本的MySQL数据库服务了。
  • MySQL临时表只在当前连接可见，如果你使用PHP脚本来创建MySQL临时表，那每当PHP脚本执行完成后，该临时表也会自动销毁。
  • 如果你使用了其他MySQL客户端程序连接MySQL数据库服务器来创建临时表，那么只有在关闭客户端程序时才会销毁临时表，当然你也可以手动销毁。

示例

  1. mysql> CREATE TEMPORARY TABLE SalesSummary (
  2.     -> product_name VARCHAR(50) NOT NULL
  3.     -> , total_sales DECIMAL(12,2) NOT NULL DEFAULT 0.00
  4.     -> , avg_unit_price DECIMAL(7,2) NOT NULL DEFAULT 0.00
  5.     -> , total_units_sold INT UNSIGNED NOT NULL DEFAULT 0
  6. );
  7. Query OK, 0 rows affected (0.00 sec)
  8.  
  9. mysql> INSERT INTO SalesSummary
  10.     -> (product_name, total_sales, avg_unit_price, total_units_sold)
  11.     -> VALUES
  12.     -> ('cucumber', 100.25, 90, 2);
  13.  
  14. mysql> SELECT * FROM SalesSummary;
  15. +--------------+-------------+----------------+------------------+
  16. | product_name | total_sales | avg_unit_price | total_units_sold |
  17. +--------------+-------------+----------------+------------------+
  18. | cucumber     |      100.25 |          90.00 |                2 |
  19. +--------------+-------------+----------------+------------------+
  20. row in set (0.00 sec)

以下展示了使用MySQL 临时表的简单实例，以下的SQL代码可以适用于PHP脚本的mysql_query()函数

  • 当你使用 SHOW TABLES命令显示数据表列表时，你将无法看到 SalesSummary表。
  • 如果你退出当前MySQL会话，再使用 SELECT命令来读取原先创建的临时表数据，那你会发现数据库中没有该表的存在，因为在你退出时该临时表已经被销毁了。

删除MySQL 临时表

  • 默认情况下，当你断开与数据库的连接后，临时表就会自动被销毁。当然你也可以在当前MySQL会话使用 DROP TABLE 命令来手动删除临时表。
  1. mysql> CREATE TEMPORARY TABLE SalesSummary (
  2.     -> product_name VARCHAR(50) NOT NULL
  3.     -> , total_sales DECIMAL(12,2) NOT NULL DEFAULT 0.00
  4.     -> , avg_unit_price DECIMAL(7,2) NOT NULL DEFAULT 0.00
  5.     -> , total_units_sold INT UNSIGNED NOT NULL DEFAULT 0
  6. );
  7. Query OK, 0 rows affected (0.00 sec)
  8.  
  9. mysql> INSERT INTO SalesSummary
  10.     -> (product_name, total_sales, avg_unit_price, total_units_sold)
  11.     -> VALUES
  12.     -> ('cucumber', 100.25, 90, 2);
  13.  
  14. mysql> SELECT * FROM SalesSummary;
  15. +--------------+-------------+----------------+------------------+
  16. | product_name | total_sales | avg_unit_price | total_units_sold |
  17. +--------------+-------------+----------------+------------------+
  18. | cucumber     |      100.25 |          90.00 |                2 |
  19. +--------------+-------------+----------------+------------------+
  20. row in set (0.00 sec)
  21. mysql> DROP TABLE SalesSummary;
  22. mysql>  SELECT * FROM SalesSummary;
  23. ERROR 1146: Table 'RUNOOB.SalesSummary' doesn't exist

以下是手动删除临时表的实例：

MySQL 复制表

如果我们需要完全的复制MySQL的数据表，包括表的结构，索引，默认值等。 如果仅仅使用CREATE TABLE ... SELECT 命令，是无法实现的。

  • 使用 SHOW CREATE TABLE 命令获取创建数据表(CREATE TABLE) 语句，该语句包含了原数据表的结构，索引等。
  • 复制以下命令显示的SQL语句，修改数据表名，并执行SQL语句，通过以上命令 将完全的复制数据表结构。
  • 如果你想复制表的内容，你就可以使用 INSERT INTO ... SELECT 语句来实现。

实例

  • 尝试以下实例来复制表 runoob_tbl 。
  1. # mysql> SHOW CREATE TABLE runoob_tbl \G;
  2. *************************** 1. row ***************************
  3.        Table: runoob_tbl
  4. Create Table: CREATE TABLE `runoob_tbl` (
  5.   `runoob_id` int(11) NOT NULL auto_increment,
  6.   `runoob_title` varchar(100) NOT NULL default '',
  7.   `runoob_author` varchar(40) NOT NULL default '',
  8.   `submission_date` date default NULL,
  9.   PRIMARY KEY  (`runoob_id`),
  10.   UNIQUE KEY `AUTHOR_INDEX` (`runoob_author`)
  11. ) ENGINE=InnoDB
  12. row in set (0.00 sec)
  13.  
  14. ERROR:
  15. No query specified

步骤一：获取数据表的完整结构

  1. # mysql> CREATE TABLE `clone_tbl` (
  2.   -> `runoob_id` int(11) NOT NULL auto_increment,
  3.   -> `runoob_title` varchar(100) NOT NULL default '',
  4.   -> `runoob_author` varchar(40) NOT NULL default '',
  5.   -> `submission_date` date default NULL,
  6.   -> PRIMARY KEY  (`runoob_id`),
  7.   -> UNIQUE KEY `AUTHOR_INDEX` (`runoob_author`)
  8. -> ) ENGINE=InnoDB;
  9. Query OK, 0 rows affected (1.80 sec)

步骤二：修改SQL语句的数据表名，并执行SQL语句

  1. # 执行完第二步骤后，你将在数据库中创建新的克隆表 clone_tbl。 如果你想拷贝数据表的数据你可以使用 INSERT INTO... SELECT 语句来实现。
  2.  
  3. mysql> INSERT INTO clone_tbl (runoob_id,
  4.     ->                        runoob_title,
  5.     ->                        runoob_author,
  6.     ->                        submission_date)
  7.     -> SELECT runoob_id,runoob_title,
  8.     ->        runoob_author,submission_date
  9.     -> FROM runoob_tbl;
  10. Query OK, 3 rows affected (0.07 sec)
  11. Records: 3  Duplicates: 0  Warnings: 0
  12.  
  13. # 执行以上步骤后，你将完整的复制表，包括表结构及表数据。

步骤三：

MySQL 序列使用

  • MySQL 序列是一组整数：1, 2, 3, ...，由于一张数据表只能有一个字段自增主键， 如果你想实现其他字段也实现自动增加，就可以使用MySQL序列来实现。

使用 AUTO_INCREMENT

  • MySQL 中最简单使用序列的方法就是使用 MySQL AUTO_INCREMENT 来定义列。

实例

  • 以下实例中创建了数据表 insect， insect 表中 id 无需指定值可实现自动增长。
  1. mysql> CREATE TABLE insect
  2.     -> (
  3.     -> id INT UNSIGNED NOT NULL AUTO_INCREMENT,
  4.     -> PRIMARY KEY (id),
  5.     -> name VARCHAR(30) NOT NULL, # type of insect
  6.     -> date DATE NOT NULL, # date collected
  7.     -> origin VARCHAR(30) NOT NULL # where collected
  8. );
  9. Query OK, 0 rows affected (0.02 sec)
  10. mysql> INSERT INTO insect (id,name,date,origin) VALUES
  11.     -> (NULL,'housefly','2001-09-10','kitchen'),
  12.     -> (NULL,'millipede','2001-09-10','driveway'),
  13.     -> (NULL,'grasshopper','2001-09-10','front yard');
  14. Query OK, 3 rows affected (0.02 sec)
  15. Records: 3  Duplicates: 0  Warnings: 0
  16. mysql> SELECT * FROM insect ORDER BY id;
  17. +----+-------------+------------+------------+
  18. | id | name        | date       | origin     |
  19. +----+-------------+------------+------------+
  20. |  1 | housefly    | 2001-09-10 | kitchen    |
  21. |  2 | millipede   | 2001-09-10 | driveway   |
  22. |  3 | grasshopper | 2001-09-10 | front yard |
  23. +----+-------------+------------+------------+
  24. 3 rows in set (0.00 sec)

获取AUTO_INCREMENT值

  • 在MySQL的客户端中你可以使用 SQL中的LAST_INSERT_ID( ) 函数来获取最后的插入表中的自增列的值。
  • 在PHP或PERL脚本中也提供了相应的函数来获取最后的插入表中的自增列的值。
  1. # 使用 mysql_insertid 属性来获取 AUTO_INCREMENT 的值。 实例如下：
  2.  
  3. $dbh->do ("INSERT INTO insect (name,date,origin)
  4. VALUES('moth','2001-09-14','windowsill')");
  5. my $seq = $dbh->{mysql_insertid};

PERL实例

  1. PHP 通过 mysql_insert_id ()函数来获取执行的插入SQL语句中 AUTO_INCREMENT列的值。
  2.  
  3. mysql_query ("INSERT INTO insect (name,date,origin)
  4. VALUES('moth','2001-09-14','windowsill')", $conn_id);
  5. $seq = mysql_insert_id ($conn_id);

PHP实例

重置序列

  • 如果你删除了数据表中的多条记录，并希望对剩下数据的AUTO_INCREMENT列进行重新排列，那么你可以通过删除自增的列，然后重新添加来实现。 不过该操作要非常小心，如果在删除的同时又有新记录添加，有可能会出现数据混乱。操作如下所示：
  1. # mysql> ALTER TABLE insect DROP id;
  2. # mysql> ALTER TABLE insect
  3.     -> ADD id INT UNSIGNED NOT NULL AUTO_INCREMENT FIRST,
  4.     -> ADD PRIMARY KEY (id);
  • 设置序列的开始值
  • 一般情况下序列的开始值为1，但如果你需要指定一个开始值100，那我们可以通过以下语句来实现：
  1. # mysql> CREATE TABLE insect
  2.     -> (
  3.     -> id INT UNSIGNED NOT NULL AUTO_INCREMENT,
  4.     -> PRIMARY KEY (id),
  5.     -> name VARCHAR(30) NOT NULL,
  6.     -> date DATE NOT NULL,
  7.     -> origin VARCHAR(30) NOT NULL
  8. )engine=innodb auto_increment=100 charset=utf8;
  9. # 或者你也可以在表创建成功后，通过以下语句来实现：
  10. # mysql> ALTER TABLE t AUTO_INCREMENT = 100;

MySQL 处理重复数据

  • 有些 MySQL 数据表中可能存在重复的记录，有些情况我们允许重复数据的存在，但有时候我们也需要删除这些重复的数据。
  • 本章节我们将为大家介绍如何防止数据表出现重复数据及如何删除数据表中的重复数据。

防止表中出现重复数据

  • 你可以在 MySQL 数据表中设置指定的字段为 PRIMARY KEY（主键） 或者 UNIQUE（唯一） 索引来保证数据的唯一性。
  • 让我们尝试一个实例：下表中无索引及主键，所以该表允许出现多条重复记录。
  1. CREATE TABLE person_tbl
  2. (
  3.     first_name CHAR(20),
  4.     last_name CHAR(20),
  5.     sex CHAR(10)
  6. );
  7. # 如果你想设置表中字段 first_name，last_name 数据不能重复，你可以设置双主键模式来设置数据的唯一性， 如果你设置了双主键，
  8.   那么那个键的默认值不能为 NULL，可设置为 NOT NULL。如下所示：
  9.  
  10. CREATE TABLE person_tbl
  11. (
  12.    first_name CHAR(20) NOT NULL,
  13.    last_name CHAR(20) NOT NULL,
  14.    sex CHAR(10),
  15.    PRIMARY KEY (last_name, first_name)
  16. );
  • 如果我们设置了唯一索引，那么在插入重复数据时，SQL 语句将无法执行成功,并抛出错。
  • INSERT IGNORE INTO 与 INSERT INTO 的区别就是 INSERT IGNORE 会忽略数据库中已经存在的数据，如果数据库没有数据，就插入新的数据，如果有数据的话就跳过这条数据。这样就可以保留数据库中已经存在数据，达到在间隙中插入数据的目的。
  • 以下实例使用了 INSERT IGNORE INTO，执行后不会出错，也不会向数据表中插入重复数据：
  1. # mysql> INSERT IGNORE INTO person_tbl (last_name, first_name)
  2.     -> VALUES( 'Jay', 'Thomas');
  3. Query OK, 1 row affected (0.00 sec)
  4. # mysql> INSERT IGNORE INTO person_tbl (last_name, first_name)
  5.     -> VALUES( 'Jay', 'Thomas');
  6. Query OK, 0 rows affected (0.00 sec)
  • INSERT IGNORE INTO 当插入数据时，在设置了记录的唯一性后，如果插入重复数据，将不返回错误，只以警告形式返回。 而 REPLACE INTO 如果存在 primary 或 unique 相同的记录，则先删除掉。再插入新记录。
  • 另一种设置数据的唯一性方法是添加一个 UNIQUE 索引，如下所示：
  1. CREATE TABLE person_tbl
  2. (
  3.    first_name CHAR(20) NOT NULL,
  4.    last_name CHAR(20) NOT NULL,
  5.    sex CHAR(10),
  6.    UNIQUE (last_name, first_name)
  7. );

统计重复数据

  • 以下我们将统计表中 first_name 和 last_name的重复记录数：
  1. # mysql> SELECT COUNT(*) as repetitions, last_name, first_name
  2.     -> FROM person_tbl
  3.     -> GROUP BY last_name, first_name
  4.     -> HAVING repetitions > 1;
  • 以上查询语句将返回 person_tbl 表中重复的记录数。 一般情况下，查询重复的值，请执行以下操作：

    • 确定哪一列包含的值可能会重复。
    • 在列选择列表使用COUNT(*)列出的那些列。
    • 在GROUP BY子句中列出的列。
    • HAVING子句设置重复数大于1。
  • 过滤重复数据
  1. # 如果你需要读取不重复的数据可以在 SELECT 语句中使用 DISTINCT 关键字来过滤重复数据。
  2. # mysql> SELECT DISTINCT last_name, first_name
  3.     -> FROM person_tbl;
  4. # 你也可以使用 GROUP BY 来读取数据表中不重复的数据：
  5. # mysql> SELECT last_name, first_name
  6.     -> FROM person_tbl
  7.     -> GROUP BY (last_name, first_name);
  • 删除重复数据
  1. # 如果你想删除数据表中的重复数据，你可以使用以下的SQL语句：
  2.  
  3. # mysql> CREATE TABLE tmp SELECTlast_name, first_name, sex FROM person_tblGROUP BY (last_name, first_name, sex);
  4. # mysql> DROP TABLE person_tbl;
  5. # mysql> ALTER TABLE tmp RENAME TO person_tbl;
  6. # 当然你也可以在数据表中添加 INDEX（索引） 和 PRIMAY KEY（主键）这种简单的方法来删除表中的重复记录。方法如下：
  7.  
  8. # mysql> ALTER IGNORE TABLE person_tbl
  9.     -> ADD PRIMARY KEY (last_name, first_name);

MySQL 导出导入数据

  • MySQL中你可以使用SELECT...INTO OUTFILE语句来简单的导出数据到文本文件上。
  • 使用 SELECT ... INTO OUTFILE 语句导出数据
  1. # 以下实例中我们将数据表 runoob_tbl 数据导出到 /tmp/runoob.txt 文件中:
  2. mysql> SELECT * FROM runoob_tbl
  3.     -> INTO OUTFILE '/tmp/runoob.txt';
  4.  
  5. # 你可以通过命令选项来设置数据输出的指定格式，以下实例为导出 CSV 格式：
  6. mysql> SELECT * FROM passwd INTO OUTFILE '/tmp/runoob.txt'
  7.     -> FIELDS TERMINATED BY ',' ENCLOSED BY '"'
  8.     -> LINES TERMINATED BY '\r\n';
  9. # 在下面的例子中，生成一个文件，各值用逗号隔开。这种格式可以被许多程序使用。
  10. SELECT a,b,a+b INTO OUTFILE '/tmp/result.text'
  11. FIELDS TERMINATED BY ',' OPTIONALLY ENCLOSED BY '"'
  12. LINES TERMINATED BY '\n'
  13. 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服务器所拥有。这意味着，虽然你就可以读取该文件，但可能无法将其删除。

导出表作为原始数据

  • mysqldump 是 mysql 用于转存储数据库的实用程序。它主要产生一个 SQL 脚本，其中包含从头重新创建数据库所必需的命令 CREATE TABLE INSERT 等。
  • 使用 mysqldump 导出数据需要使用 --tab 选项来指定导出文件指定的目录，该目标必须是可写的。
  1. #以下实例将数据表 runoob_tbl 导出到 /tmp 目录中：
  2. $ mysqldump -u root -p --no-create-info \
  3.             --tab=/tmp RUNOOB runoob_tbl
  4. password ******

导出 SQL 格式的数据

  1. $ mysqldump -u root -p RUNOOB runoob_tbl > dump.txt
  2. password ******
  3. 以上命令创建的文件内容如下：
  4.  
  5. -- MySQL dump 8.23
  6. --
  7. -- Host: localhost    Database: RUNOOB
  8. ---------------------------------------------------------
  9. -- Server version       3.23.58
  10.  
  11. --
  12. -- Table structure for table `runoob_tbl`
  13. --
  14.  
  15. CREATE TABLE runoob_tbl (
  16.   runoob_id int(11) NOT NULL auto_increment,
  17.   runoob_title varchar(100) NOT NULL default '',
  18.   runoob_author varchar(40) NOT NULL default '',
  19.   submission_date date default NULL,
  20.   PRIMARY KEY  (runoob_id),
  21.   UNIQUE KEY AUTHOR_INDEX (runoob_author)
  22. ) TYPE=MyISAM;
  23.  
  24. --
  25. -- Dumping data for table `runoob_tbl`
  26. --
  27.  
  28. INSERT INTO runoob_tbl
  29.        VALUES (1,'Learn PHP','John Poul','2007-05-24');
  30. INSERT INTO runoob_tbl
  31.        VALUES (2,'Learn MySQL','Abdul S','2007-05-24');
  32. INSERT INTO runoob_tbl
  33.        VALUES (3,'JAVA Tutorial','Sanjay','2007-05-06');
  34.  
  35. # 如果你需要导出整个数据库的数据，可以使用以下命令：
  36. $ mysqldump -u root -p RUNOOB > database_dump.txt
  37. password ******
  38.  
  39. # 如果需要备份所有数据库，可以使用以下命令：
  40. $ mysqldump -u root -p --all-databases > database_dump.txt
  41. password ******
  42. --all-databases 选项在 MySQL 3.23.12 及以后版本加入。
  43. # 该方法可用于实现数据库的备份策略。

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

  1. # 如果你需要将数据拷贝至其他的 MySQL 服务器上, 你可以mysqldump 命令中指定数据库名及数据表。
  2.  
  3. # 在源主机上执行以下命令，将数据备份至 dump.txt 文件中:
  4. $ mysqldump -u root -p database_name table_name > dump.txt
  5. password *****
  6.  
  7. #如果完整备份数据库，则无需使用特定的表名称。
  8. # 如果你需要将备份的数据库导入到MySQL服务器中，可以使用以下命令，使用以下命令你需要确认数据库已经创建：
  9. $ mysql -u root -p database_name < dump.txt
  10. password *****
  11.  
  12. # 你也可以使用以下命令将导出的数据直接导入到远程的服务器上，但请确保两台服务器是相通的，是可以相互访问的：
  13. $ mysqldump -u root -p database_name \
  14.        | mysql -h other-host.com database_name
  15. # 以上命令中使用了管道来将导出的数据导入到指定的远程主机上。

将数据表及数据库拷贝至其他主机

MySQL 导入数据

  • mysql 命令导入
  1. # 使用 mysql 命令导入语法格式为：
  2. mysql -u用户名    -p密码    <  要导入的数据库数据(runoob.sql)
  3.  
  4. # 实例：
  5. # mysql -uroot -p123456 < runoob.sql
  6. # 以上命令将将备份的整个数据库 runoob.sql 导入。
  • source 命令导入
  1. # source 命令导入数据库需要先登录到数库终端：
  2.  
  3. mysql> create database abc;      # 创建数据库
  4. mysql> use abc;                  # 使用已创建的数据库
  5. mysql> set names utf8;           # 设置编码
  6. mysql> source /home/abc/abc.sql  # 导入备份数据库
  • 使用 LOAD DATA 导入数据
  • MySQL 中提供了LOAD DATA INFILE语句来插入数据。 以下实例中将从当前目录中读取文件 dump.txt ，将该文件中的数据插入到当前数据库的 mytbl 表中。
  1. # 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) 也是可选的，不过，用户必须至少指定它们中的一个。
  1. # mysql> LOAD DATA LOCAL INFILE 'dump.txt' INTO TABLE mytbl
  2.        -> FIELDS TERMINATED BY ':'
  3.        -> LINES TERMINATED BY '\r\n';
  • LOAD DATA默认情况下是按照数据文件中列的顺序插入数据的如果数据文件中的列与插入表中的列不一致，则需要指定列的顺序。
  • 如，在数据文件中的列顺序是 a,b,c，但在插入表的列顺序为b,c,a，则数据导入语法如下：
  1. # mysql> LOAD DATA LOCAL INFILE 'dump.txt'
  2.         -> INTO TABLE mytbl (b, c, a);
  • 使用 mysqlimport 导入数据

    • mysqlimport 客户端提供了 LOAD DATA INFILEQL 语句的一个命令行接口。mysqlimport 的大多数选项直接对应 LOAD DATA INFILE 子句。
  1. # 从文件 dump.txt 中将数据导入到 mytbl 数据表中, 可以使用以下命令：
  2. $ mysqlimport -u root -p --local mytbl dump.txt
  3. password *****
  4.  
  5. # mysqlimport 命令可以指定选项来设置指定格式,命令语句格式如下：
  6. $ mysqlimport -u root -p --local --fields-terminated-by=":" \
  7.    --lines-terminated-by="\r\n"  mytbl dump.txt
  8. password *****
  9.  
  10. # mysqlimport 语句中使用 --columns 选项来设置列的顺序：
  11. $ mysqlimport -u root -p --local --columns=b,c,a \
  12.     mytbl dump.txt
  13. password *****
  • mysqlimport的常用选项介绍
选项 功能
-d or --delete 新数据导入数据表中之前删除数据数据表中的所有信息
-f or --force 不管是否遇到错误，mysqlimport将强制继续插入数据
-i or --ignore mysqlimport跳过或者忽略那些有相同唯一 关键字的行， 导入文件中的数据将被忽略。
-l or -lock-tables 数据被插入之前锁住表，这样就防止了， 你在更新数据库时，用户的查询和更新受到影响。
-r or -replace 这个选项与－i选项的作用相反；此选项将替代 表中有相同唯一关键字的记录。
--fields-enclosed- by= char 指定文本文件中数据的记录时以什么括起的， 很多情况下 数据以双引号括起。 默认的情况下数据是没有被字符括起的。
--fields-terminated- by=char 指定各个数据的值之间的分隔符，在句号分隔的文件中， 分隔符是句号。您可以用此选项指定数据之间的分隔符。 默认的分隔符是跳格符（Tab）
--lines-terminated- by=str 此选项指定文本文件中行与行之间数据的分隔字符串 或者字符。 默认的情况下mysqlimport以newline为行分隔符。 您可以选择用一个字符串来替代一个单个的字符： 一个新行或者一个回车。
  • mysqlimport 命令常用的选项还有 -v 显示版本（version）， -p 提示输入密码（password）等。
  1. # 首先linux 下查看mysql相关目录
  2. [root@op-workorder bin]# whereis mysql
  3.  mysql: /usr/bin/mysql /usr/lib64/mysql /usr/include/mysql
  4.  
  5. # 导出数据库用mysqldump命令
  6. cd /home/work/mysql/bin # 先cd到mysql的运行路径下，再执行一下命令　
  7.  
  8. # 1. 导出数据和表结构
  9. 　　　./mysqldump -uroot -p bsp > bsp.sql
  10. 　　　mysqldump -u用户名 -p密码 数据库名 > 数据库名.sql
  11.  
  12. # 2. 只导出表结构
  13. 　　　mysqldump -u用户名 -p密码 -d 数据库名 > 数据库名.sql
  14.      mysqldump -uroot -p -d dbname > dbname .sql
  15.  
  16. # 3. 导入数据库
  17. 　　# 1、首先建空数据库　
  18. 　　　　mysql>create database bsp charset utf8;
  19. 　　# 2、导入数据库（方法一）
  20. 　　　　　# 选择数据库
  21. 　　　　　　mysql>use bsp;
  22. 　　     # 导入数据（注意sql文件的路径）
  23. 　　　　　　mysql>source /home/work/project/bsp/bsp.sql
  24. 　　# 3、导入数据库（方法二）
  25. 　　　　 mysql -u用户名 -p密码 数据库名 < 数据库名.sql
  26. 　　# 4、执行导出数据库报错问题解决
  27. # 报错：mysqldump: Couldn't execute 'SHOW VARIABLES LIKE 'gtid\_mode'': Table 
          'performance_schema.session_variables' doesn't exist (1146)
  28. 1）mysql_upgrade -u root -p --force #更新
  29. 2）service mysql restart #restart mysql service
  30. 3）mysqldump -u root -p test > test.sql #重新备份数据

MySQL 函数

  • MySQL 有很多内置的函数，以下列出了这些函数的说明。

  • MySQL 字符串函数

函数 描述 实例
ASCII(s) 返回字符串 s 的第一个字符的 ASCII 码。

返回 CustomerName 字段第一个字母的 ASCII 码：

  1. SELECT ASCII(CustomerName) AS NumCodeOfFirstChar
  2. FROM Customers;
CHAR_LENGTH(s) 返回字符串 s 的字符数

返回字符串 RUNOOB 的字符数

  1. SELECT CHAR_LENGTH("RUNOOB") AS LengthOfString;
CHARACTER_LENGTH(s) 返回字符串 s 的字符数

返回字符串 RUNOOB 的字符数

  1. SELECT CHARACTER_LENGTH("RUNOOB") AS LengthOfString;
CONCAT(s1,s2...sn) 字符串 s1,s2 等多个字符串合并为一个字符串

合并多个字符串

  1. SELECT CONCAT("SQL ", "Runoob ", "Gooogle ", "Facebook") AS ConcatenatedString;
CONCAT_WS(x, s1,s2...sn) 同 CONCAT(s1,s2,...) 函数，但是每个字符串之间要加上 x，x 可以是分隔符

合并多个字符串，并添加分隔符：

  1. SELECT CONCAT_WS("-", "SQL", "Tutorial", "is", "fun!")AS ConcatenatedString;
FIELD(s,s1,s2...) 返回第一个字符串 s 在字符串列表(s1,s2...)中的位置

返回字符串 c 在列表值中的位置：

  1. SELECT FIELD("c", "a", "b", "c", "d", "e");
FIND_IN_SET(s1,s2) 返回在字符串s2中与s1匹配的字符串的位置

返回字符串 c 在指定字符串中的位置：

  1. SELECT FIND_IN_SET("c", "a,b,c,d,e");
FORMAT(x,n) 函数可以将数字 x 进行格式化 "#,###.##", 将 x 保留到小数点后 n 位，最后一位四舍五入。

格式化数字 "#,###.##" 形式：

  1. SELECT FORMAT(250500.5634, 2);     -- 输出 250,500.56
INSERT(s1,x,len,s2) 字符串 s2 替换 s1 的 x 位置开始长度为 len 的字符串

从字符串第一个位置开始的 6 个字符替换为 runoob：

  1. SELECT INSERT("google.com", 1, 6, "runnob");  -- 输出：runoob.com
LOCATE(s1,s) 从字符串 s 中获取 s1 的开始位置

获取 b 在字符串 abc 中的位置：

  1. SELECT LOCATE('st','myteststring');  -- 5

返回字符串 abc 中 b 的位置：

  1. SELECT LOCATE('b', 'abc') -- 2
LCASE(s) 将字符串 s 的所有字母变成小写字母

字符串 RUNOOB 转换为小写：

  1. SELECT LCASE('RUNOOB') -- runoob
LEFT(s,n) 返回字符串 s 的前 n 个字符

返回字符串 runoob 中的前两个字符：

  1. SELECT LEFT('runoob',2) -- ru
LOWER(s) 将字符串 s 的所有字母变成小写字母

字符串 RUNOOB 转换为小写：

  1. SELECT LOWER('RUNOOB') -- runoob
LPAD(s1,len,s2) 在字符串 s1 的开始处填充字符串 s2，使字符串长度达到 len

将字符串 xx 填充到 abc 字符串的开始处：

  1. SELECT LPAD('abc',5,'xx') -- xxabc
LTRIM(s) 去掉字符串 s 开始处的空格

去掉字符串 RUNOOB开始处的空格：

  1. SELECT LTRIM("    RUNOOB") AS LeftTrimmedString;-- RUNOOB
MID(s,n,len) 从字符串 s 的 n 位置截取长度为 len 的子字符串，同 SUBSTRING(s,n,len)

从字符串 RUNOOB 中的第 2 个位置截取 3个 字符：

  1. SELECT MID("RUNOOB", 2, 3) AS ExtractString; -- UNO
POSITION(s1 IN s) 从字符串 s 中获取 s1 的开始位置

返回字符串 abc 中 b 的位置：

  1. SELECT POSITION('b' in 'abc') -- 2
REPEAT(s,n) 将字符串 s 重复 n 次

将字符串 runoob 重复三次：

  1. SELECT REPEAT('runoob',3) -- runoobrunoobrunoob
REPLACE(s,s1,s2) 将字符串 s2 替代字符串 s 中的字符串 s1

将字符串 abc 中的字符 a 替换为字符 x：

  1. SELECT REPLACE('abc','a','x') --xbc
REVERSE(s) 将字符串s的顺序反过来

将字符串 abc 的顺序反过来：

  1. SELECT REVERSE('abc') -- cba
RIGHT(s,n) 返回字符串 s 的后 n 个字符

返回字符串 runoob 的后两个字符：

  1. SELECT RIGHT('runoob',2) -- ob
RPAD(s1,len,s2) 在字符串 s1 的结尾处添加字符串 s2，使字符串的长度达到 len

将字符串 xx 填充到 abc 字符串的结尾处：

  1. SELECT RPAD('abc',5,'xx') -- abcxx
RTRIM(s) 去掉字符串 s 结尾处的空格

去掉字符串 RUNOOB 的末尾空格：

  1. SELECT RTRIM("RUNOOB     ") AS RightTrimmedString;   -- RUNOOB
SPACE(n) 返回 n 个空格

返回 10 个空格：

  1. SELECT SPACE(10);
STRCMP(s1,s2) 比较字符串 s1 和 s2，如果 s1 与 s2 相等返回 0 ，如果 s1>s2 返回 1，如果 s1<s2 返回 -1

比较字符串：

  1. SELECT STRCMP("runoob", "runoob");  -- 0
SUBSTR(s, start, length) 从字符串 s 的 start 位置截取长度为 length 的子字符串

从字符串 RUNOOB 中的第 2 个位置截取 3个 字符：

  1. SELECT SUBSTR("RUNOOB", 2, 3) AS ExtractString; -- UNO
SUBSTRING(s, start, length) 从字符串 s 的 start 位置截取长度为 length 的子字符串

从字符串 RUNOOB 中的第 2 个位置截取 3个 字符：

  1. SELECT SUBSTRING("RUNOOB", 2, 3) AS ExtractString; -- UNO
SUBSTRING_INDEX(s, delimiter, number) 返回从字符串 s 的第 number 个出现的分隔符 delimiter 之后的子串。
如果 number 是正数，返回第 number 个字符左边的字符串。
如果 number 是负数，返回第(number 的绝对值(从右边数))个字符右边的字符串。		 
  1. SELECT SUBSTRING_INDEX('a*b','*',1) -- a
  2. SELECT SUBSTRING_INDEX('a*b','*',-1)    -- b
  3. SELECT SUBSTRING_INDEX(SUBSTRING_INDEX('a*b*c*d*e','*',3),'*',-1)    -- c
TRIM(s) 去掉字符串 s 开始和结尾处的空格

去掉字符串 RUNOOB 的首尾空格：

  1. SELECT TRIM('    RUNOOB    ') AS TrimmedString;
UCASE(s) 将字符串转换为大写

将字符串 runoob 转换为大写：

  1. SELECT UCASE("runoob"); -- RUNOOB
UPPER(s) 将字符串转换为大写

将字符串 runoob 转换为大写：

  1. SELECT UPPER("runoob"); -- RUNOOB
  • MySQL 数字函数
函数名 描述 实例
ABS(x) 返回 x 的绝对值　　

返回 -1 的绝对值：

  1. SELECT ABS(-1) -- 返回1
ACOS(x) 求 x 的反余弦值(参数是弧度) 
  1. SELECT ACOS(0.25);
ASIN(x) 求反正弦值(参数是弧度) 
  1. SELECT ASIN(0.25);
ATAN(x) 求反正切值(参数是弧度) 
  1. SELECT ATAN(2.5);
ATAN2(n, m) 求反正切值(参数是弧度) 
  1. SELECT ATAN2(-0.8, 2);
AVG(expression) 返回一个表达式的平均值，expression 是一个字段

返回 Products 表中Price 字段的平均值：

  1. SELECT AVG(Price) AS AveragePrice FROM Products;
CEIL(x) 返回大于或等于 x 的最小整数　 
  1. SELECT CEIL(1.5) -- 返回2
CEILING(x) 返回大于或等于 x 的最小整数　 
  1. SELECT CEIL(1.5) -- 返回2
COS(x) 求余弦值(参数是弧度) 
  1. SELECT COS(2);
COT(x) 求余切值(参数是弧度) 
  1. SELECT COT(6);
COUNT(expression) 返回查询的记录总数，expression 参数是一个字段或者 * 号

返回 Products 表中 products 字段总共有多少条记录：

  1. SELECT COUNT(ProductID) AS NumberOfProducts FROM Products;
DEGREES(x) 将弧度转换为角度　　 
  1. SELECT DEGREES(3.1415926535898) -- 180
n DIV m 整除，n 为被除数，m 为除数

计算 10 除于 5：

  1. SELECT 10 DIV 5;  -- 2
EXP(x) 返回 e 的 x 次方　　

计算 e 的三次方：

  1. SELECT EXP(3) -- 20.085536923188
FLOOR(x) 返回小于或等于 x 的最大整数　　

小于或等于 1.5 的整数：

  1. SELECT FLOOR(1.5) -- 返回1
GREATEST(expr1, expr2, expr3, ...) 返回列表中的最大值

返回以下数字列表中的最大值：

  1. SELECT GREATEST(3, 12, 34, 8, 25); -- 34

返回以下字符串列表中的最大值：

  1. SELECT GREATEST("Google", "Runoob", "Apple");   -- Runoob
LEAST(expr1, expr2, expr3, ...) 返回列表中的最小值

返回以下数字列表中的最小值：

  1. SELECT LEAST(3, 12, 34, 8, 25); -- 3

返回以下字符串列表中的最小值：

  1. SELECT LEAST("Google", "Runoob", "Apple");   -- Apple
LN 返回数字的自然对数

返回 2 的自然对数：

  1. SELECT LN(2);  -- 0.6931471805599453
LOG(x) 返回自然对数(以 e 为底的对数)　　 
  1. SELECT LOG(20.085536923188) -- 3
LOG10(x) 返回以 10 为底的对数　　 
  1. SELECT LOG10(100) -- 2
LOG2(x) 返回以 2 为底的对数

返回以 2 为底 6 的对数：

  1. SELECT LOG2(6);  -- 2.584962500721156
MAX(expression) 返回字段 expression 中的最大值

返回数据表 Products 中字段 Price 的最大值：

  1. SELECT MAX(Price) AS LargestPrice FROM Products;
MIN(expression) 返回字段 expression 中的最小值

返回数据表 Products 中字段 Price 的最小值：

  1. SELECT MIN(Price) AS LargestPrice FROM Products;
MOD(x,y) 返回 x 除以 y 以后的余数　

5 除于 2 的余数：

  1. SELECT MOD(5,2) -- 1
PI() 返回圆周率(3.141593）　　 
  1. SELECT PI() --3.141593
POW(x,y) 返回 x 的 y 次方　

2 的 3 次方：

  1. SELECT POW(2,3) -- 8
POWER(x,y) 返回 x 的 y 次方　

2 的 3 次方：

  1. SELECT POWER(2,3) -- 8
RADIANS(x) 将角度转换为弧度　　

180 度转换为弧度：

  1. SELECT RADIANS(180) -- 3.1415926535898
RAND() 返回 0 到 1 的随机数　　 
  1. SELECT RAND() --0.93099315644334
ROUND(x) 返回离 x 最近的整数 
  1. SELECT ROUND(1.23456) --1
SIGN(x) 返回 x 的符号，x 是负数、0、正数分别返回 -1、0 和 1　 
  1. SELECT SIGN(-10) -- (-1)
SIN(x) 求正弦值(参数是弧度)　　 
  1. SELECT SIN(RADIANS(30)) -- 0.5
SQRT(x) 返回x的平方根　　

25 的平方根：

  1. SELECT SQRT(25) -- 5
SUM(expression) 返回指定字段的总和

计算 OrderDetails 表中字段 Quantity 的总和：

  1. SELECT SUM(Quantity) AS TotalItemsOrdered FROM OrderDetails;
TAN(x) 求正切值(参数是弧度) 
  1. SELECT TAN(1.75);  -- -5.52037992250933
TRUNCATE(x,y) 返回数值 x 保留到小数点后 y 位的值（与 ROUND 最大的区别是不会进行四舍五入） 
  1. SELECT TRUNCATE(1.23456,3) -- 1.234
  • MySQL 日期函数
函数名 描述 实例
ADDDATE(d,n) 计算起始日期 d 加上 n 天的日期 
  1. SELECT ADDDATE("2017-06-15", INTERVAL 10 DAY);
  2. ->2017-06-25
ADDTIME(t,n) 时间 t 加上 n 秒的时间 
  1. SELECT ADDTIME('2011-11-11 11:11:11', 5)
  2. ->2011-11-11 11:11:16 (秒)
CURDATE() 返回当前日期 
  1. SELECT CURDATE();
  2. -> 2018-09-19
CURRENT_DATE() 返回当前日期 
  1. SELECT CURRENT_DATE();
  2. -> 2018-09-19
CURRENT_TIME 返回当前时间 
  1. SELECT CURRENT_TIME();
  2. -> 19:59:02
CURRENT_TIMESTAMP() 返回当前日期和时间 
  1. SELECT CURRENT_TIMESTAMP()
  2. -> 2018-09-19 20:57:43
CURTIME() 返回当前时间 
  1. SELECT CURTIME();
  2. -> 19:59:02
DATE() 从日期或日期时间表达式中提取日期值 
  1. SELECT DATE("2017-06-15");
  2. -> 2017-06-15
DATEDIFF(d1,d2) 计算日期 d1->d2 之间相隔的天数 
  1. SELECT DATEDIFF('2001-01-01','2001-02-02')
  2. -> -32
DATE_ADD(d，INTERVAL expr type) 计算起始日期 d 加上一个时间段后的日期 
  1. SELECT ADDDATE('2011-11-11 11:11:11',1)
  2. -> 2011-11-12 11:11:11    (默认是天)
  3.  
  4. SELECT ADDDATE('2011-11-11 11:11:11', INTERVAL 5 MINUTE)
  5. -> 2011-11-11 11:16:11 (TYPE的取值与上面那个列出来的函数类似)
DATE_FORMAT(d,f) 按表达式 f的要求显示日期 d 
  1. SELECT DATE_FORMAT('2011-11-11 11:11:11','%Y-%m-%d %r')
  2. -> 2011-11-11 11:11:11 AM
DATE_SUB(date,INTERVAL expr type) 函数从日期减去指定的时间间隔。

Orders 表中 OrderDate 字段减去 2 天：

  1. SELECT OrderId,DATE_SUB(OrderDate,INTERVAL 2 DAY) AS OrderPayDate
  2. FROM Orders
DAY(d) 返回日期值 d 的日期部分 
  1. SELECT DAY("2017-06-15");
  2. -> 15
DAYNAME(d) 返回日期 d 是星期几，如 Monday,Tuesday 
  1. SELECT DAYNAME('2011-11-11 11:11:11')
  2. ->Friday
DAYOFMONTH(d) 计算日期 d 是本月的第几天 
  1. SELECT DAYOFMONTH('2011-11-11 11:11:11')
  2. ->11
DAYOFWEEK(d) 日期 d 今天是星期几，1 星期日，2 星期一，以此类推 
  1. SELECT DAYOFWEEK('2011-11-11 11:11:11')
  2. ->6
DAYOFYEAR(d) 计算日期 d 是本年的第几天 
  1. SELECT DAYOFYEAR('2011-11-11 11:11:11')
  2. ->315
EXTRACT(type FROM d) 从日期 d 中获取指定的值，type 指定返回的值。
type可取值为：

  • MICROSECOND
  • SECOND
  • MINUTE
  • HOUR
  • DAY
  • WEEK
  • MONTH
  • QUARTER
  • YEAR
  • SECOND_MICROSECOND
  • MINUTE_MICROSECOND
  • MINUTE_SECOND
  • HOUR_MICROSECOND
  • HOUR_SECOND
  • HOUR_MINUTE
  • DAY_MICROSECOND
  • DAY_SECOND
  • DAY_MINUTE
  • DAY_HOUR
  • YEAR_MONTH
 
  1. SELECT EXTRACT(MINUTE FROM '2011-11-11 11:11:11')
  2. -> 11
FROM_DAYS(n) 计算从 0000 年 1 月 1 日开始 n 天后的日期 
  1. SELECT FROM_DAYS(1111)
  2. -> 0003-01-16
HOUR(t) 返回 t 中的小时值 
  1. SELECT HOUR('1:2:3')
  2. -> 1
LAST_DAY(d) 返回给给定日期的那一月份的最后一天 
  1. SELECT LAST_DAY("2017-06-20");
  2. -> 2017-06-30
LOCALTIME() 返回当前日期和时间 
  1. SELECT LOCALTIME()
  2. -> 2018-09-19 20:57:43
LOCALTIMESTAMP() 返回当前日期和时间 
  1. SELECT LOCALTIMESTAMP()
  2. -> 2018-09-19 20:57:43
MAKEDATE(year, day-of-year) 基于给定参数年份 year 和所在年中的天数序号 day-of-year 返回一个日期 
  1. SELECT MAKEDATE(2017, 3);
  2. -> 2017-01-03
MAKETIME(hour, minute, second) 组合时间，参数分别为小时、分钟、秒 
  1. SELECT MAKETIME(11, 35, 4);
  2. -> 11:35:04
MICROSECOND(date) 返回日期参数所对应的微秒数 
  1. SELECT MICROSECOND("2017-06-20 09:34:00.000023");
  2. -> 23
MINUTE(t) 返回 t 中的分钟值 
  1. SELECT MINUTE('1:2:3')
  2. -> 2
MONTHNAME(d) 返回日期当中的月份名称，如 November 
  1. SELECT MONTHNAME('2011-11-11 11:11:11')
  2. -> November
MONTH(d) 返回日期d中的月份值，1 到 12 
  1. SELECT MONTH('2011-11-11 11:11:11')
  2. ->11
NOW() 返回当前日期和时间 
  1. SELECT NOW()
  2. -> 2018-09-19 20:57:43
PERIOD_ADD(period, number) 为 年-月 组合日期添加一个时段 
  1. SELECT PERIOD_ADD(201703, 5);
  2. -> 201708
PERIOD_DIFF(period1, period2) 返回两个时段之间的月份差值 
  1. SELECT PERIOD_DIFF(201710, 201703);
  2. -> 7
QUARTER(d) 返回日期d是第几季节，返回 1 到 4 
  1. SELECT QUARTER('2011-11-11 11:11:11')
  2. -> 4
SECOND(t) 返回 t 中的秒钟值 
  1. SELECT SECOND('1:2:3')
  2. -> 3
SEC_TO_TIME(s) 将以秒为单位的时间 s 转换为时分秒的格式 
  1. SELECT SEC_TO_TIME(4320)
  2. -> 01:12:00
STR_TO_DATE(string, format_mask) 将字符串转变为日期 
  1. SELECT STR_TO_DATE("August 10 2017", "%M %d %Y");
  2. -> 2017-08-10
SUBDATE(d,n) 日期 d 减去 n 天后的日期 
  1. SELECT SUBDATE('2011-11-11 11:11:11', 1)
  2. ->2011-11-10 11:11:11 (默认是天)
SUBTIME(t,n) 时间 t 减去 n 秒的时间 
  1. SELECT SUBTIME('2011-11-11 11:11:11', 5)
  2. ->2011-11-11 11:11:06 (秒)
SYSDATE() 返回当前日期和时间 
  1. SELECT SYSDATE()
  2. -> 2018-09-19 20:57:43
TIME(expression) 提取传入表达式的时间部分 
  1. SELECT TIME("19:30:10");
  2. -> 19:30:10
TIME_FORMAT(t,f) 按表达式 f 的要求显示时间 t 
  1. SELECT TIME_FORMAT('11:11:11','%r')
  2. 11:11:11 AM
TIME_TO_SEC(t) 将时间 t 转换为秒 
  1. SELECT TIME_TO_SEC('1:12:00')
  2. -> 4320
TIMEDIFF(time1, time2) 计算时间差值 
  1. SELECT TIMEDIFF("13:10:11", "13:10:10");
  2. -> 00:00:01
TIMESTAMP(expression, interval) 单个参数时，函数返回日期或日期时间表达式；有2个参数时，将参数加和 
  1. SELECT TIMESTAMP("2017-07-23",  "13:10:11");
  2. -> 2017-07-23 13:10:11
TO_DAYS(d) 计算日期 d 距离 0000 年 1 月 1 日的天数 
  1. SELECT TO_DAYS('0001-01-01 01:01:01')
  2. -> 366
WEEK(d) 计算日期 d 是本年的第几个星期，范围是 0 到 53 
  1. SELECT WEEK('2011-11-11 11:11:11')
  2. -> 45
WEEKDAY(d) 日期 d 是星期几，0 表示星期一，1 表示星期二 
  1. SELECT WEEKDAY("2017-06-15");
  2. -> 3
WEEKOFYEAR(d) 计算日期 d 是本年的第几个星期，范围是 0 到 53 
  1. SELECT WEEKOFYEAR('2011-11-11 11:11:11')
  2. -> 45
YEAR(d) 返回年份 
  1. SELECT YEAR("2017-06-15");
  2. -> 2017
YEARWEEK(date, mode) 返回年份及第几周（0到53），mode 中 0 表示周天，1表示周一，以此类推 
  1. SELECT YEARWEEK("2017-06-15");
  2. -> 201724
  • MySQL 高级函数
函数名 描述 实例
BIN(x) 返回 x 的二进制编码

15 的 2 进制编码:

  1. SELECT BIN(15); -- 1111
BINARY(s) 将字符串 s 转换为二进制字符串 
  1. SELECT BINARY "RUNOOB";
  2. -> RUNOOB
 
  1. CASE expression
  2.     WHEN condition1 THEN result1
  3.     WHEN condition2 THEN result2
  4.    ...
  5.     WHEN conditionN THEN resultN
  6.     ELSE result
  7. END
 CASE 表示函数开始，END 表示函数结束。如果 condition1 成立，则返回 result1, 如果 condition2 成立，则返回 result2，当全部不成立则返回 result，而当有一个成立之后，后面的就不执行了。 
  1. SELECT CASE
  2. 　　WHEN 1 > 0
  3. 　　THEN '1 > 0'
  4. 　　WHEN 2 > 0
  5. 　　THEN '2 > 0'
  6. 　　ELSE '3 > 0'
  7. 　　END
  8. ->1 > 0
CAST(x AS type) 转换数据类型

字符串日期转换为日期：

  1. SELECT CAST("2017-08-29" AS DATE);
  2. -> 2017-08-29
COALESCE(expr1, expr2, ...., expr_n) 返回参数中的第一个非空表达式（从左向右） 
  1. SELECT COALESCE(NULL, NULL, NULL, 'runoob.com', NULL, 'google.com');
  2. -> runoob.com
CONNECTION_ID() 返回服务器的连接数 
  1. SELECT CONNECTION_ID();
  2. -> 4292835
CONV(x,f1,f2) 返回 f1 进制数变成 f2 进制数 
  1. SELECT CONV(15, 10, 2);
  2. -> 1111
CONVERT(s USING cs) 函数将字符串 s 的字符集变成 cs 
  1. SELECT CHARSET('ABC')
  2. ->utf-8    
  3.  
  4. SELECT CHARSET(CONVERT('ABC' USING gbk))
  5. ->gbk
CURRENT_USER() 返回当前用户 
  1. SELECT CURRENT_USER();
  2. -> guest@%
DATABASE() 返回当前数据库名 
  1. SELECT DATABASE();
  2. -> runoob
IF(expr,v1,v2) 如果表达式 expr 成立，返回结果 v1；否则，返回结果 v2。 
  1. SELECT IF(1 > 0,'正确','错误')
  2. ->正确
IFNULL(v1,v2) 如果 v1 的值不为 NULL，则返回 v1，否则返回 v2。 
  1. SELECT IFNULL(null,'Hello Word')
  2. ->Hello Word
ISNULL(expression) 判断表达式是否为 NULL 
  1. SELECT ISNULL(NULL);
  2. ->1
LAST_INSERT_ID() 返回最近生成的 AUTO_INCREMENT 值 
  1. SELECT LAST_INSERT_ID();
  2. ->6
NULLIF(expr1, expr2) 比较两个字符串，如果字符串 expr1 与 expr2 相等 返回 NULL，否则返回 expr1 
  1. SELECT NULLIF(25, 25);
  2. ->
SESSION_USER() 返回当前用户 
  1. SELECT SESSION_USER();
  2. -> guest@%
SYSTEM_USER() 返回当前用户 
  1. SELECT SYSTEM_USER();
  2. -> guest@%
USER() 返回当前用户 
  1. SELECT USER();
  2. -> guest@%
VERSION() 返回数据库的版本号 
  1. SELECT VERSION()
  2. -> 5.6.34

MySQL 运算符

  • 介绍 MySQL 的运算符及运算符的优先级。 MySQL 主要有以下几种运算符：

    • 算术运算符
    • 比较运算符
    • 逻辑运算符
    • 位运算符

算术运算符

  • MySQL 支持的算术运算符包括:
  1. # 运算符   # 作用
  2. +         # 加法
  3. -         # 减法
  4. *         # 乘法
  5. / 或 DIV  # 除法
  6. % 或 MOD  # 取余
  • 在除法运算和模运算中，如果除数为0，将是非法除数，返回结果为NULL。
  1. # 1、加
  2. mysql> select 1+2;
  3. +-----+
  4. | 1+2 |
  5. +-----+
  6. |   3 |
  7. +-----+
  8.  
  9. # 2、减
  10. mysql> select 1-2;
  11. +-----+
  12. | 1-2 |
  13. +-----+
  14. |  -1 |
  15. +-----+
  16.  
  17. # 3、乘
  18. mysql> select 2*3;
  19. +-----+
  20. | 2*3 |
  21. +-----+
  22. |   6 |
  23. +-----+
  24.  
  25. # 4、除
  26. mysql> select 2/3;
  27. +--------+
  28. | 2/3    |
  29. +--------+
  30. | 0.6667 |
  31. +--------+
  32.  
  33. # 5、商
  34. mysql> select 10 DIV 4;
  35. +----------+
  36. | 10 DIV 4 |
  37. +----------+
  38. |        2 |
  39. +----------+
  40.  
  41. # 6、取余
  42. mysql> select 10 MOD 4;
  43. +----------+
  44. | 10 MOD 4 |
  45. +----------+
  46. |        2 |
  47. +----------+

比较运算符

  • SELECT 语句中的条件语句经常要使用比较运算符。通过这些比较运算符，可以判断表中的哪些记录是符合条件的。比较结果为真，则返回 1，为假则返回 0，比较结果不确定则返回 NULL。
符号 描述 备注
= 等于  
<>, != 不等于  
> 大于  
< 小于  
<= 小于等于  
>= 大于等于  
BETWEEN 在两值之间 >=min&&<=max
NOT BETWEEN 不在两值之间  
IN 在集合中  
NOT IN 不在集合中  
<=> 严格比较两个NULL值是否相等 两个操作码均为NULL时，其所得值为1；而当一个操作码为NULL时，其所得值为0
LIKE 模糊匹配  
REGEXP 或 RLIKE 正则式匹配  
IS NULL 为空  
IS NOT NULL 不为空   
  1. # mysql> select 2=3;
  2. +-----+
  3. | 2=3 |
  4. +-----+
  5. |   0 |
  6. +-----+
  7. # mysql> select NULL = NULL;
  8. +-------------+
  9. | NULL = NULL |
  10. +-------------+
  11. |        NULL |
  12. +-------------+

1、等于

  1. # mysql> select 2<>3;
  2. +------+
  3. | 2<>3 |
  4. +------+
  5. |    1 |
  6. +------+

2、不等于

  1. # 与 = 的区别在于当两个操作码均为 NULL 时，其所得值为 1 而不为 NULL，而当一个操作码为 NULL 时，其所得值为 0而不为 NULL。
  2. # mysql> select 2<=>3;
  3. +-------+
  4. | 2<=>3 |
  5. +-------+
  6. |     0 |
  7. +-------+
  8. # mysql> select null=null;
  9. +-----------+
  10. | null=null |
  11. +-----------+
  12. |      NULL |
  13. +-----------+
  14. # mysql> select null<=>null;
  15. +-------------+
  16. | null<=>null |
  17. +-------------+
  18. |           1 |
  19. +-------------+

3、安全等于

  1. # mysql> select 2<3;
  2. +-----+
  3. | 2<3 |
  4. +-----+
  5. |   1   |
  6. +-----+

4、小于

  1. # mysql> select 2<=3;
  2. +------+
  3. | 2<=3 |
  4. +------+
  5. |    1   |
  6. +------+

5、小于等于

  1. # mysql> select 2>3;
  2. +-----+
  3. | 2>3 |
  4. +-----+
  5. |   0   |
  6. +-----+
  7.  
  8. # mysql> select 2>=3;
  9. +------+
  10. | 2>=3 |
  11. +------+
  12. |    0  |
  13. +------+

6、大于、大于等于

  1. # mysql> select 5 between 1 and 10;
  2. +--------------------+
  3. | 5 between 1 and 10 |
  4. +--------------------+
  5. |                  1 |
  6. +--------------------+

7、BETWEEN

  1. # mysql> select 5 in (1,2,3,4,5);
  2. +------------------+
  3. | 5 in (1,2,3,4,5) |
  4. +------------------+
  5. |                1 |
  6. +------------------+
  7.  
  8. # mysql> select 5 not in (1,2,3,4,5);
  9. +----------------------+
  10. | 5 not in (1,2,3,4,5) |
  11. +----------------------+
  12. |                    0 |
  13. +----------------------+

8、IN、NOT IN

  1. #
  2. mysql> select null is NULL;
  3. +--------------+
  4. | null is NULL |
  5. +--------------+
  6. |            1 |
  7. +--------------+
  8. mysql> select 'a' is NULL;
  9. +-------------+
  10. | 'a' is NULL |
  11. +-------------+
  12. |           0 |
  13. +-------------+

9、IS NULL

  1. # mysql> select null IS NOT NULL;
  2. +------------------+
  3. | null IS NOT NULL |
  4. +------------------+
  5. |                0 |
  6. +------------------+        
  7.  
  8. # mysql> select 'a' IS NOT NULL;
  9. +-----------------+
  10. | 'a' IS NOT NULL |
  11. +-----------------+
  12. |               1 |
  13. +-----------------+

10、IS NOT NULL

  1. # mysql> select '12345' like '12%';
  2. +--------------------+
  3. | '' like '12%' |
  4. +--------------------+
  5. |                  1 |
  6. +--------------------+
  7.  
  8. # mysql> select '12345' like '12_';
  9. +--------------------+
  10. | '' like '12_' |
  11. +--------------------+
  12. |                  0 |
  13. +--------------------+

11、LIKE

  1. # mysql> select 'beijing' REGEXP 'jing';
  2. +-------------------------+
  3. | 'beijing' REGEXP 'jing' |
  4. +-------------------------+
  5. |                       1 |
  6. +-------------------------+
  7.  
  8. # mysql> select 'beijing' REGEXP 'xi';
  9. +-----------------------+
  10. | 'beijing' REGEXP 'xi' |
  11. +-----------------------+
  12. |                     0 |
  13. +-----------------------+

12、REGEXP

逻辑运算符

  • 逻辑运算符用来判断表达式的真假。如果表达式是真，结果返回 1。如果表达式是假，结果返回 0。
  1. #运算符号 # 作用
  2. NOT 或 ! # 逻辑非
  3. AND      # 逻辑与
  4. OR       # 逻辑或
  5. XOR      # 逻辑异或
  1. # mysql> select 2 and 0;
  2. +---------+
  3. | 2 and 0 |
  4. +---------+
  5. |       0 |
  6. +---------+
  7.  
  8. # mysql> select 2 and 1;
  9. +---------+
  10. | 2 and 1 |
  11. +---------+
  12. |       1 |
  13. +---------+

1、与

  1. # mysql> select 2 or 0;
  2. +--------+
  3. | 2 or 0 |
  4. +--------+
  5. |      1 |
  6. +--------+
  7.  
  8. # mysql> select 2 or 1;
  9. +--------+
  10. | 2 or 1 |
  11. +--------+
  12. |      1 |
  13. +--------+
  14.  
  15. # mysql> select 0 or 0;
  16. +--------+
  17. | 0 or 0 |
  18. +--------+
  19. |      0 |
  20. +--------+
  21.  
  22. # mysql> select 1 || 0;
  23. +--------+
  24. | 1 || 0 |
  25. +--------+
  26. |      1 |
  27. +--------+

2、或

  1. # mysql> select not 1;
  2. +-------+
  3. | not 1 |
  4. +-------+
  5. |     0 |
  6. +-------+
  7.  
  8. # mysql> select !0;
  9. +----+
  10. | !0 |
  11. +----+
  12. |  1 |
  13. +----+

3、非

  1. # mysql> select 1 xor 1;
  2. +---------+
  3. | 1 xor 1 |
  4. +---------+
  5. |       0 |
  6. +---------+
  7.  
  8. # mysql> select 0 xor 0;
  9. +---------+
  10. | 0 xor 0 |
  11. +---------+
  12. |       0 |
  13. +---------+
  14.  
  15. # mysql> select 1 xor 0;
  16. +---------+
  17. | 1 xor 0 |
  18. +---------+
  19. |       1 |
  20. +---------+
  21.  
  22. # mysql> select null or 1;
  23. +-----------+
  24. | null or 1 |
  25. +-----------+
  26. |         1 |
  27. +-----------+
  28.  
  29. # mysql> select 1 ^ 0;
  30. +-------+
  31. | 1 ^ 0 |
  32. +-------+
  33. |     1 |
  34. +-------+

4、异或

位运算符

  • 位运算符是在二进制数上进行计算的运算符。位运算会先将操作数变成二进制数，进行位运算。然后再将计算结果从二进制数变回十进制数。
  1. # 运算符号    # 作用
  2. &            # 按位与
  3. |            # 按位或
  4. ^            # 按位异或
  5. !            # 取反
  6. <<           # 左移
  7. >>           # 右移
  1. # 1、按位与
  2. mysql> select 3&5;
  3. +-----+
  4. | 3&5 |
  5. +-----+
  6. |   1 |
  7. +-----+
  8.  
  9. # 2、按位或
  10. mysql> select 3|5;
  11. +-----+
  12. | 3|5 |
  13. +-----+
  14. |   7 |
  15. +-----+
  16.  
  17. # 3、按位异或
  18. mysql> select 3^5;
  19. +-----+
  20. | 3^5 |
  21. +-----+
  22. |   6 |
  23. +-----+
  24.  
  25. # 4、按位取反
  26. mysql> select ~18446744073709551612;
  27. +-----------------------+
  28. | ~18446744073709551612 |
  29. +-----------------------+
  30. |                     3 |
  31. +-----------------------+
  32.  
  33. # 5、按位右移
  34. mysql> select 3>>1;
  35. +------+
  36. | 3>>1 |
  37. +------+
  38. |    1 |
  39. +------+
  40.  
  41. # 6、按位左移
  42. mysql> select 3<<1;
  43. +------+
  44. | 3<<1 |
  45. +------+
  46. |    6 |
  47. +------+

运算符优先级

  • 最低优先级为： :=

  • 最高优先级为： !、BINARY、 COLLATE。

聚合函数

  1. # 总数：count
  2. # 查询男性有多少人，女性有多少人
  3. select count(*) from students where gender = 1;
  4. select count(*) from students where gender = 2;
  1. # 最大值：max
  2. # 查询最大的年龄
  3. select max(age) from students;
  4.  
  5. # 查询女性的最高 身高
  6. select max(height) from students where gender = 2;
  7.  
  8. # 最小值：min
  9. select min(height) from students where gender = 2;
  1. # 求和：sum
  2. # 计算所有人的年龄总和
  3. select sum(age) from students;
  1. # 平均值：avg
  2. # 计算平均年龄
  3. select avg(age) from students;
  4.  
  5. # 计算平均年龄 sum(age)/count(*)
  6.  
  7. # 四舍五入 round(123.23 , 1) 保留1位小数
  8. # 计算所有人的平均年龄，保留3位小数
  9. select round(avg(age),3) from students;
  10.  
  11. # 计算男性的平均身高 保留2位小数
  12. select round(avg(height),2) from students where gender = 1;
  1. # 查询类型 cate_name 为 '超级本' 的商品名称 name 、价格 price ( where )
  2. select name,price from goods where cate_name = "超级本";
  3.  
  4. # 显示商品的种类
  5. # 1 分组的方式( group by )
  6. select cate_name from goods group by cate_name;
  7.  
  8. # 2 去重的方法( distinct )
  9. select distinct cate_name from goods;
  10.  
  11. # 求所有电脑产品的平均价格 avg ,并且保留两位小数( round )
  12. select round(avg(price),2) from goods;
  13.  
  14. # 显示 每种类型 cate_name (由此可知需要分组)的 平均价格
  15. select cate_name,avg(price) from goods group by cate_name;
  16.  
  17. #查询 每种类型 的商品中 最贵 max 、最便宜 min 、平均价 avg 、数量 count
  18. select max(price),min(price),avg(price),count(*) from goods group by cate_name;
  19.  
  20. # 查询所有价格大于 平均价格 的商品，并且按 价格降序 排序 order desc
  21. # 1 查询平局价格(avg_price)
  22. select avg(price) as avg_price from goods;
  23.  
  24. # 2 使用子查询
  25. select * from goods where price > (select avg(price) as avg_price from goods) order by price desc;
  26.  
  27. # 查询每种类型中最贵的电脑信息(难)
  28. # 1 查找 每种类型 中 最贵的 max_price 价格
  29. select cate_name,max(price) as max_price from goods group by cate_name;
  30.  
  31. # 2 关联查询 inner join 每种类型 中最贵的物品信息
  32. select * from goods inner join(select cate_name,max(price) as max_price from goods group by cate_name) as max_price_goods
  33. on goods.cate_name=max_price_goods.cate_name and goods.price=max_price_goods.max_price;
  34.  
  35. # 创建"商品分类"表
  36. # 第一步    创建表 (商品种类表 goods_cates )
  37. create table if not exists goods_cates(
  38. id int unsigned primary key auto_increment,
  39. name varchar(40) not null
  40. );
  41. # 第二步    同步 商品分类表 数据 将商品的所有 (种类信息) 写入到 (商品种类表) 中 按照 分组 的方式查询 goods 表中的所有 种类(cate_name)
  42. select cate_name from goods group by cate_name;
  43.  
  44. # (注意) 把查询出来的 结果 写入 goods_cates 表里去 ( insert into ) 只插入name
  45. insert into goods_cates(name) (select cate_name from goods group by cate_name);
  46.  
  47. # 第三部 同步 商品表 数据 通过 goods_cates 数据表来更新 goods 表
  48. # 因为要通过 goods_cates表 更新 goods 表 所以要把两个表连接起来
  49. select * from goods inner join goods_cates on goods.cate_name = goods_cates.name;
  50.  
  51. # 把 商品表 goods 中的 cate_name 全部替换成 商品分类表中的 商品id ( update ... set )
  52. update (goods inner join goods_cates on goods.cate_name = goods_cates.name) set goods.cate_name = goods_cates.id;
  53.  
  54. # 第四部 修改表结构
  55. # 查看表结构(注意 两个表中的 外键类型需要一致)
  56. desc goods;
  57.  
  58. #修改表结构 alter table 字段名字不同 change,把 cate_name 改成 cate_id int unsigned not null
  59. alter table goods change cate_name cate_id int unsigned not null;
  60.  
  61. # 创建 商品品牌表 goods_brands
  62. # 第一步 创建 "商品品牌表" 表
  63. # 第一种方式 先创建表
  64. create table goods_brands (
  65. id int unsigned primary key auto_increment,
  66. name varchar(40) not null);
  67. # 插入数据 brand_name(分组)
  68. # 按照 分组 的方式查询 goods 表中的所有 种类(brand_name)
  69. select brand_name from goods group by brand_name;
  70.  
  71. # (注意) 把查询出来的 结果 写入 goods_brands 表里去 ( insert into ) 只插入name
  72. insert into goods_brands(name) (select brand_name from goods group by brand_name);
  73.  
  74. # 第二种方式 创建表的同时插入数据(了解,不建议使用)
  75. create table goods_brands (
  76. id int unsigned primary key auto_increment,
  77. name varchar(40) not null) select brand_name as name from goods group by brand_name;
  78. # 第二步 同步数据
  79. # 通过goods_brands数据表来更新goods数据表 g.brand_name=b.id
  80. update (goods inner join goods_brands on goods.brand_name = goods_brands.name) set goods.brand_name = goods_brands.id;
  81.  
  82. # 第三步 修改表结构
  83. # 通过alter table语句修改表结构 brand_id int unsigned not null
  84. alter table goods change brand_name brand_id int unsigned not null;
  85.  
  86. # 外键的使用(了解)
  87. # 创建外键
  88. # -- 向goods表里插入任意一条数据
  89. insert into goods (name,cate_id,brand_id,price) values('老王牌拖拉机', 10, 10,'');
  90.  
  91. # 约束 数据的插入 使用 外键 foreign key
  92. alter table goods add foreign key (brand_id) references goods_brands(id);
  93. alter table goods add foreign key (cate_id) references goods_cates(id);
  94. alter table goods add foreign key(brand_id) references goods_brands(id);
  95.  
  96. # 失败原因 老王牌拖拉机 delete
  97. delete from goods where name="老王牌拖拉机";
  98. # 创建表的同时设置外键 (注意 goods_cates 和 goods_brands 两个表必须事先存在)
  99. create table goods(
  100. id int primary key auto_increment not null,
  101. name varchar(40) default '',
  102. price decimal(5,2),
  103. cate_id int unsigned,
  104. brand_id int unsigned,
  105. is_show bit default 1,
  106. is_saleoff bit default 0,
  107. foreign key(cate_id) references goods_cates(id),
  108. foreign key(brand_id) references goods_brands(id)
  109. );
  110.  
  111. # 如何取消外键约束
  112. #需要先获取外键约束名称,该名称系统会自动生成,可以通过查看表创建语来获取名称
  113. show create table goods;
  114.  
  115. # 获取名称之后就可以根据名称来删除外键约束
  116. alter table goods drop foreign key goods_ibfk_1;
  117. alter table goods drop foreign key goods_ibfk_2;
  118.  
  119. # 总结:在实际开发中,很少会使用到外键约束,会极大的降低表更新的效率

sql强化演练( goods 表练习)

MySQL 的介绍到这篇基本就算完事了，后期我会继续更新，关注不迷路哦，多多支持！！！

MySQL 【进阶查询】的更多相关文章

  1. mysql 进阶查询（学习笔记）

    学习笔记,来源:实验楼 ,链接: https://www.shiyanlou.com/courses/9   一.日期计算: 1.要想确定每个宠物有多大,可以使用函数TIMESTAMPDIFF()计算 ...

  2. python进阶09 MySQL高级查询

    python进阶09 MySQL高级查询 一.筛选条件 # 比较运算符 # 等于:= 不等于:!= 或<> 大于:> 小于:< 大于等于>= 小于等于:<= #空: ...

  3. MySQL进阶5--分组函数 / 分组排序和分组查询 group by(having) /order by

    MySQL进阶--分组排序和分组查询 group by(having) /order by /* 介绍分组函数 功能:用做统计使用,又称为聚合函数或组函数 1.分类: sum, avg 求和 /平均数 ...

  4. MySQL进阶篇(03)：合理的使用索引结构和查询

    本文源码:GitHub·点这里 || GitEE·点这里 一.高性能索引 1.查询性能问题 在MySQL使用的过程中,所谓的性能问题,在大部分的场景下都是指查询的性能,导致查询缓慢的根本原因是数据量的 ...

  5. MySQL进阶:约束,多表设计,多表查询,视图,数据库备份与还原

    MySQL进阶 知识点梳理 一.约束 1. 外键约束 为什么要有外键约束 例如:一个user表,一个orderlist 如果现在想要直接删除id为1的张三,但是orderlist里还有用户id为1的订 ...

  6. MYSQL进阶学习笔记十：MySQL慢查询！（视频序号：进阶_23-24)

    知识点十一:MySQL 慢查询的应用(23) 一.慢查询定义 MySQL记录下查询超过指定时间的语句,我们将超过指定时间的SQL语句查询称为慢查询. 查看时间限制 show variables lik ...

  7. mysql进阶(二十九)常用函数

    mysql进阶(二十九)常用函数 一.数学函数 ABS(x) 返回x的绝对值 BIN(x) 返回x的二进制(OCT返回八进制,HEX返回十六进制) CEILING(x) 返回大于x的最小整数值 EXP ...

  8. mysql进阶(二十八)MySQL GRANT REVOKE用法

    mysql进阶(二十八)MySQL GRANT REVOKE用法   MySQL的权限系统围绕着两个概念: 认证->确定用户是否允许连接数据库服务器: 授权->确定用户是否拥有足够的权限执 ...

  9. mysql进阶(二十七)数据库索引原理

    mysql进阶(二十七)数据库索引原理 前言   本文主要是阐述MySQL索引机制,主要是说明存储引擎Innodb.   第一部分主要从数据结构及算法理论层面讨论MySQL数据库索引的数理基础.    ...

随机推荐

  1. 云服务器之——Linux下配置JDK环境

    在Linux下jdk的安装已经操作了很多次,每次发现自己还是会忘记之前的操作,所以今天就简单的来做个记录. 第一步:下载jdk安装包 登录oracle官网:https://www.oracle.com ...

  2. Spring Security基本原理

    近期研究了Spring Security,现进行记录. 首先先进行一个最简单的demo.默认情况下,在Spring Boot里,如果在classpath下面有Spring Security相关的jar ...

  3. PDCA理念融入软件测试

    PDCA理念融入软件测试    摘要:软件测试作为软件质量保障的重要手段,PDCA循环是全面质量管理所应遵循的科学程序.本文结合软件测试工作的特点,通过文档规范的方式,将PDCA的理念融入软件测试,提 ...

  4. 微软亚洲研究院开源图数据库GraphView

    我们很高兴地宣布,由微软亚洲研究院系统算法组开发的图数据库GraphView通过GitHub平台开源.GraphView是一款中间件软件,方便用户使用关系数据库SQL Server 或Azure SQ ...

  5. 对话|人工智能先驱Yoshua Bengio

    ​​ ​ Bengio"> 今年1月份,微软收购深度学习初创公司Maluuba时,Maluuba公司德高望重的顾问.深度学习先驱Yoshua Bengio也接手了微软的人工智能研究顾问 ...

  6. Android注解支持Support Annotations详解

    ###注解支持(Support Annotations)Android support library从19.1版本开始引入了一个新的注解库,它包含很多有用的元注解,你能用它们修饰你的代码,帮助你发现 ...

  7. Animate.css动画库，简单的使用，以及源码剖析

    animate.css是什么?能做些什么? animate.css是一个css动画库,使用它可以很方便的快捷的实现,我们想要的动画效果,而省去了操作js的麻烦.同时呢,它也是一个开源的库,在GitHu ...

  8. 【读书笔记】https://source.android.google.cn/compatibility/tests?hl=en

    AuthorBlog:秋城https://www.cnblogs.com/houser0323/ Android Platform Testing This content is geared tow ...

  9. javascript设计模式－－策略模式

    javascript策略模式总结 1.什么是策略模式? 策略模式的定义是:定义一系列的算法,把他们独立封装起来,并且可以相互替换. 例如我们需要写一段代码来计算员工的奖金.当绩效为a时,奖金为工资的5 ...

  10. 初识 jquery.simulate.js 模拟键盘事件

    用jquery 和 jquery.simulate.js 实现模拟键盘事件,点击上下左右div相当于点击键盘的上下左右键 <!DOCTYPE html> <html> < ...