SELECT what_to_select
FROM which_table
WHERE conditions_to_satisfy;

最简单的形式 SELECT 从表 中 检索所有内容：

MySQL的> SELECT * FROM pet;
+ ---------- + -------- + --------- + ------ + ------------ + ------------ +
| 名字| 老板| 物种| 性别 出生| 死亡|
+ ---------- + -------- + --------- + ------ + ------------ + ------------ +
| 蓬松| 哈罗德| 猫| f | 1993-02-04 | NULL |
| 爪子| 格温| 猫| m | 1994-03-17 | NULL |
| 巴菲| 哈罗德| 狗| f | 1989-05-13 | NULL |
| 方| 班尼| 狗| m | 1990-08-27 | NULL |
| 鲍泽尔| 黛安娜 狗| m | 1979-08-31 | 1995-07-29 |
| Chirpy | 格温| 鸟| f | 1998-09-11 | NULL |
| 惠斯勒| 格温| 鸟| NULL | 1997-12-09 | NULL |
| 苗条| 班尼| 蛇| m | 1996-04-29 | NULL |
| 马勃| 黛安娜 仓鼠| f | 1999-03-30 | NULL |
+ ---------- + -------- + --------- + ------ + ------------ + ------------ +

SELECT 如果要查看整个表格，例如在刚刚加载初始数据集之后， 这种形式 非常有用。 例如，您可能会认为Bowser的出生日期似乎不太合适。 咨询你原来的血统书，你会发现正确的出生年应该是1989年，而不是1979年。

至少有两种方法可以解决这个问题：

如上一节所示，可以轻松检索整个表。 只是省略 声明中 的 WHERE 条款 SELECT 。 但通常你不希望看到整个表格，特别是当它变大时。 相反，您通常对回答特定问题更感兴趣，在这种情况下，您可以对所需信息指定一些约束。 让我们看看他们回答的有关您的宠物的问题的一些选择查询。

您只能从表中选择特定行。 例如，如果您想验证您对Bowser出生日期所做的更改，请选择Bowser的记录，如下所示：

MySQL的> SELECT * FROM pet WHERE name = 'Bowser';
+ -------- + ------- + --------- + ------ + ------------ +  - ---------- +
| 名字| 老板| 物种| 性别 出生| 死亡|
+ -------- + ------- + --------- + ------ + ------------ +  - ---------- +
| 鲍泽尔| 黛安娜 狗| m | 1989-08-31 | 1995-07-29 |
+ -------- + ------- + --------- + ------ + ------------ +  - ---------- +

输出确认年份被正确记录为1989年，而不是1979年。

字符串比较通常不区分大小写，因此您可以将名称指定为 'bowser' ， 'BOWSER' 等等。 查询结果是一样的。

您可以在任何列上指定条件，而不仅仅是 name 。 例如，如果您想知道1998年或之后出生的动物，请测试该 birth 栏：

MySQL的> SELECT * FROM pet WHERE birth >= '1998-1-1';
+ ---------- + ------- + --------- + ------ + ------------ + ------- +
| 名字| 老板| 物种| 性别 出生| 死亡|
+ ---------- + ------- + --------- + ------ + ------------ + ------- +
| Chirpy | 格温| 鸟| f | 1998-09-11 | NULL |
| 马勃| 黛安娜 仓鼠| f | 1999-03-30 | NULL |
+ ---------- + ------- + --------- + ------ + ------------ + ------- +

例如，您可以结合条件来定位雌性狗：

MySQL的> SELECT * FROM pet WHERE species = 'dog' AND sex = 'f';
+ ------- + -------- + --------- + ------ + ------------ +  - ----- +
| 名字| 老板| 物种| 性别 出生| 死亡|
+ ------- + -------- + --------- + ------ + ------------ +  - ----- +
| 巴菲| 哈罗德| 狗| f | 1989-05-13 | NULL |
+ ------- + -------- + --------- + ------ + ------------ +  - ----- +

前面的查询使用 AND 逻辑运算符。 还有一个 OR 运营商：

MySQL的> SELECT * FROM pet WHERE species = 'snake' OR species = 'bird';
+ ---------- + ------- + --------- + ------ + ------------ + ------- +
| 名字| 老板| 物种| 性别 出生| 死亡|
+ ---------- + ------- + --------- + ------ + ------------ + ------- +
| Chirpy | 格温| 鸟| f | 1998-09-11 | NULL |
| 惠斯勒| 格温| 鸟| NULL | 1997-12-09 | NULL |
| 苗条| 班尼| 蛇| m | 1996-04-29 | NULL |
+ ---------- + ------- + --------- + ------ + ------------ + ------- +

AND 并且 OR 可以混合，但 AND 优先级高于 OR 。 如果您同时使用这两个运算符，最好使用括号明确指出条件应如何分组：

MySQL的> SELECT * FROM pet WHERE (species = 'cat' AND sex = 'm')
       OR (species = 'dog' AND sex = 'f');
+ ------- + -------- + --------- + ------ + ------------ +  - ----- +
| 名字| 老板| 物种| 性别 出生| 死亡|
+ ------- + -------- + --------- + ------ + ------------ +  - ----- +
| 爪子| 格温| 猫| m | 1994-03-17 | NULL |
| 巴菲| 哈罗德| 狗| f | 1989-05-13 | NULL |
+ ------- + -------- + --------- + ------ + ------------ +  - ----- +

如果您不想查看表中的整行，只需将您感兴趣的列命名为逗号分隔。 例如，如果您想知道您的动物何时出生，请选择 name 和 birth 列：

MySQL的> SELECT name, birth FROM pet;
+ ---------- + ------------ +
| 名字| 出生|
+ ---------- + ------------ +
| 蓬松| 1993-02-04 |
| 爪子| 1994-03-17 |
| 巴菲| 1989-05-13 |
| 方| 1990-08-27 |
| 鲍泽尔| 1989-08-31 |
| Chirpy | 1998-09-11 |
| 惠斯勒| 1997-12-09 |
| 苗条| 1996-04-29 |
| 马勃| 1999-03-30 |
+ ---------- + ------------ +

要找出谁拥有宠物，请使用此查询：

MySQL的> SELECT owner FROM pet;
+ -------- +
| 老板|
+ -------- +
| 哈罗德|
| 格温|
| 哈罗德|
| 班尼|
| 黛安娜
| 格温|
| 格温|
| 班尼|
| 黛安娜
+ -------- +

请注意，查询只是 owner 从每条记录中 检索 列，其中一些只出现一次。 要最小化输出，请通过添加关键字检索每个唯一的输出记录一次 DISTINCT ：

MySQL的> SELECT DISTINCT owner FROM pet;
+ -------- +
| 老板|
+ -------- +
| 班尼|
| 黛安娜
| 格温|
| 哈罗德|
+ -------- +

您可以使用 WHERE 子句将行选择与列选择组合在一起。 例如，要仅获取狗和猫的出生日期，请使用以下查询：

MySQL的> SELECT name, species, birth FROM pet
       WHERE species = 'dog' OR species = 'cat';
+ -------- + --------- + ------------ +
| 名字| 物种| 出生|
+ -------- + --------- + ------------ +
| 蓬松| 猫| 1993-02-04 |
| 爪子| 猫| 1994-03-17 |
| 巴菲| 狗| 1989-05-13 |
| 方| 狗| 1990-08-27 |
| 鲍泽尔| 狗| 1989-08-31 |
+ -------- + --------- + ------------ +

您可能已在前面的示例中注意到结果行没有按特定顺序显示。 当行以某种有意义的方式排序时，通常更容易检查查询输出。 要对结果进行排序，请使用 ORDER BY 子句。

这是动物的生日，按日期排序：

MySQL的> SELECT name, birth FROM pet ORDER BY birth;
+ ---------- + ------------ +
| 名字| 出生|
+ ---------- + ------------ +
| 巴菲| 1989-05-13 |
| 鲍泽尔| 1989-08-31 |
| 方| 1990-08-27 |
| 蓬松| 1993-02-04 |
| 爪子| 1994-03-17 |
| 苗条| 1996-04-29 |
| 惠斯勒| 1997-12-09 |
| Chirpy | 1998-09-11 |
| 马勃| 1999-03-30 |
+ ---------- + ------------ +

在字符类型列上，排序与所有其他比较操作一样，通常以不区分大小写的方式执行。 这意味着除了它们的情况之外，对于相同的列，订单是未定义的。 您可以使用 BINARY 类似的 方式强制对列进行区分大小写的排序 ： 。 ORDER BY BINARY col_name

默认排序顺序是升序，首先是最小值。 要按反向（降序）排序，请将 DESC 关键字 添加到要排序 的列的名称：

MySQL的> SELECT name, birth FROM pet ORDER BY birth DESC;
+ ---------- + ------------ +
| 名字| 出生|
+ ---------- + ------------ +
| 马勃| 1999-03-30 |
| Chirpy | 1998-09-11 |
| 惠斯勒| 1997-12-09 |
| 苗条| 1996-04-29 |
| 爪子| 1994-03-17 |
| 蓬松| 1993-02-04 |
| 方| 1990-08-27 |
| 鲍泽尔| 1989-08-31 |
| 巴菲| 1989-05-13 |
+ ---------- + ------------ +

您可以对多个列进行排序，并且可以按不同方向对不同列进行排序。 例如，要按动物类型按升序排序，然后按动物类型中的出生日期按降序排序（最年轻的动物首先），请使用以下查询：

MySQL的> SELECT name, species, birth FROM pet
       ORDER BY species, birth DESC;
+ ---------- + --------- + ------------ +
| 名字| 物种| 出生|
+ ---------- + --------- + ------------ +
| Chirpy | 鸟| 1998-09-11 |
| 惠斯勒| 鸟| 1997-12-09 |
| 爪子| 猫| 1994-03-17 |
| 蓬松| 猫| 1993-02-04 |
| 方| 狗| 1990-08-27 |
| 鲍泽尔| 狗| 1989-08-31 |
| 巴菲| 狗| 1989-05-13 |
| 马勃| 仓鼠| 1999-03-30 |
| 苗条| 蛇| 1996-04-29 |
+ ---------- + --------- + ------------ +

该 DESC 关键字仅适用于紧邻其前面的列名（ birth ）; 它不会影响 species 列排序顺序。

MySQL提供了几个可用于在日期上执行计算的函数，例如，计算年龄或提取日期的部分。

要确定每只宠物的年龄，请使用此 TIMESTAMPDIFF() 功能。 它的参数是你想要表达结果的单位，以及两个可以取得差异的日期。 以下查询显示了每只宠物的出生日期，当前日期和年龄。 一个 别名 （ age ）是用来制造最终输出列标签更有意义。

MySQL的> SELECT name, birth, CURDATE(),
       TIMESTAMPDIFF(YEAR,birth,CURDATE()) AS age
       FROM pet;
+ ---------- + ------------ + ------------ + ------ +
| 名字| 出生| CURDATE（）| 年龄|
+ ---------- + ------------ + ------------ + ------ +
| 蓬松| 1993-02-04 | 2003-08-19 | 10 |
| 爪子| 1994-03-17 | 2003-08-19 | 9 |
| 巴菲| 1989-05-13 | 2003-08-19 | 14 |
| 方| 1990-08-27 | 2003-08-19 | 12 |
| 鲍泽尔| 1989-08-31 | 2003-08-19 | 13 |
| Chirpy | 1998-09-11 | 2003-08-19 | 4 |
| 惠斯勒| 1997-12-09 | 2003-08-19 | 5 |
| 苗条| 1996-04-29 | 2003-08-19 | 7 |
| 马勃| 1999-03-30 | 2003-08-19 | 4 |
+ ---------- + ------------ + ------------ + ------ +

查询有效，但如果以某种顺序显示行，则可以更轻松地扫描结果。 这可以通过添加一个 ORDER BY name 子句来按名称对输出进行排序 来完成 ：

MySQL的> SELECT name, birth, CURDATE(),
       TIMESTAMPDIFF(YEAR,birth,CURDATE()) AS age
       FROM pet ORDER BY name;
+ ---------- + ------------ + ------------ + ------ +
| 名字| 出生| CURDATE（）| 年龄|
+ ---------- + ------------ + ------------ + ------ +
| 鲍泽尔| 1989-08-31 | 2003-08-19 | 13 |
| 巴菲| 1989-05-13 | 2003-08-19 | 14 |
| Chirpy | 1998-09-11 | 2003-08-19 | 4 |
| 爪子| 1994-03-17 | 2003-08-19 | 9 |
| 方| 1990-08-27 | 2003-08-19 | 12 |
| 蓬松| 1993-02-04 | 2003-08-19 | 10 |
| 马勃| 1999-03-30 | 2003-08-19 | 4 |
| 苗条| 1996-04-29 | 2003-08-19 | 7 |
| 惠斯勒| 1997-12-09 | 2003-08-19 | 5 |
+ ---------- + ------------ + ------------ + ------ +

要通过 age 而不是 对输出进行排序 name ，只需使用不同的 ORDER BY 子句：

MySQL的> SELECT name, birth, CURDATE(),
       TIMESTAMPDIFF(YEAR,birth,CURDATE()) AS age
       FROM pet ORDER BY age;
+ ---------- + ------------ + ------------ + ------ +
| 名字| 出生| CURDATE（）| 年龄|
+ ---------- + ------------ + ------------ + ------ +
| Chirpy | 1998-09-11 | 2003-08-19 | 4 |
| 马勃| 1999-03-30 | 2003-08-19 | 4 |
| 惠斯勒| 1997-12-09 | 2003-08-19 | 5 |
| 苗条| 1996-04-29 | 2003-08-19 | 7 |
| 爪子| 1994-03-17 | 2003-08-19 | 9 |
| 蓬松| 1993-02-04 | 2003-08-19 | 10 |
| 方| 1990-08-27 | 2003-08-19 | 12 |
| 鲍泽尔| 1989-08-31 | 2003-08-19 | 13 |
| 巴菲| 1989-05-13 | 2003-08-19 | 14 |
+ ---------- + ------------ + ------------ + ------ +

类似的查询可用于确定死亡动物的死亡年龄。 您可以通过检查 death 值 是否确定这些动物 NULL 。 然后，对于那些具有非 NULL 值的人，计算 death 和 birth 值 之间的差异 ：

MySQL的> SELECT name, birth, death,
       TIMESTAMPDIFF(YEAR,birth,death) AS age
       FROM pet WHERE death IS NOT NULL ORDER BY age;
+ -------- + ------------ + ------------ + ------ +
| 名字| 出生| 死亡| 年龄|
+ -------- + ------------ + ------------ + ------ +
| 鲍泽尔| 1989-08-31 | 1995-07-29 | 5 |
+ -------- + ------------ + ------------ + ------ +

查询使用 death IS NOT NULL 而不是 death <> NULL 因为 NULL 是使用通常的比较运算符无法比较的特殊值。 这将在后面讨论。 请参见 第3.3.4.6节“使用NULL值” 。

如果你想知道哪些动物下个月有生日怎么办？ 对于这种类型的计算，年和日是无关紧要的; 您只想提取 birth 列 的月份部分 。 MySQL提供了用于提取日期的部分，如一些功能 YEAR() ， MONTH() 和 DAYOFMONTH() 。 MONTH() 这是适当的功能。 看看它是如何工作的，运行，显示两者的价值一个简单的查询 birth 和 MONTH(birth) ：

MySQL的> SELECT name, birth, MONTH(birth) FROM pet;
+ ---------- + ------------ + -------------- +
| 名字| 出生| 月（出生）|
+ ---------- + ------------ + -------------- +
| 蓬松| 1993-02-04 | 2 |
| 爪子| 1994-03-17 | 3 |
| 巴菲| 1989-05-13 | 5 |
| 方| 1990-08-27 | 8 |
| 鲍泽尔| 1989-08-31 | 8 |
| Chirpy | 1998-09-11 | 9 |
| 惠斯勒| 1997-12-09 | 12 |
| 苗条| 1996-04-29 | 4 |
| 马勃| 1999-03-30 | 3 |
+ ---------- + ------------ + -------------- +

在接下来的一个月里寻找有生日的动物也很简单。 假设当前月份是4月。 然后是月份值 4 ，您可以查找5月（月 5 ） 出生的动物， 如下所示：

MySQL的> SELECT name, birth FROM pet WHERE MONTH(birth) = 5;
+ ------- + ------------ +
| 名字| 出生|
+ ------- + ------------ +
| 巴菲| 1989-05-13 |
+ ------- + ------------ +

如果当前月份是12月，则会出现一个小的复杂情况。 你不能只在月份数字（ 12 ）中 添加一个 并查找月份出生的动物 13 ，因为没有这样的月份。 相反，你寻找1月（月 1 ） 出生的动物 。

您可以编写查询，以便无论当前月份是什么，它都可以工作，因此您不必使用特定月份的数字。 DATE_ADD() 使您可以将时间间隔添加到给定日期。 如果您将值添加一个月 CURDATE() ，然后 使用 ，则提取月份部分 MONTH() ，结果将生成查找生日的月份：

MySQL的> SELECT name, birth FROM pet
       WHERE MONTH(birth) = MONTH(DATE_ADD(CURDATE(),INTERVAL 1 MONTH));

完成相同任务的另一种方法是 1 在使用模数函数（ MOD ）将月份值换行 （ 0 如果它是当前 值） 之后 添加 以获取当前 任务 之后的下一个月 12 ：

MySQL的> SELECT name, birth FROM pet
       WHERE MONTH(birth) = MOD(MONTH(CURDATE()), 12) + 1;

MONTH() 返回 1 和 之间的数字 12 。 并 MOD(something,12) 在 0 和 之间返回一个数字 11 。 所以添加必须在之后 MOD() ，否则我们将从11月（ 11 ）到1月（ 1 ）。

如果计算使用无效日期，则计算失败并生成警告：

MySQL的> SELECT '2018-10-31' + INTERVAL 1 DAY;
+ ------------------------------- +
| '2018-10-31'+ INTERVAL 1 DAY |
+ ------------------------------- +
| 2018-11-01 |
+ ------------------------------- +
MySQL的> SELECT '2018-10-32' + INTERVAL 1 DAY;
+ ------------------------------- +
| '2018-10-32'+ INTERVAL 1 DAY |
+ ------------------------------- +
| NULL |
+ ------------------------------- +
MySQL的> SHOW WARNINGS;
+ --------- + ------ + -------------------------------- -------- +
| 等级| 代码| 消息|
+ --------- + ------ + -------------------------------- -------- +
| 警告| 1292 | 日期时间值不正确：'2018-10-32'|
+ --------- + ------ + -------------------------------- -------- +

在 NULL 你习惯它之前， 这个 价值可能会令人惊讶。 从概念上讲，它 NULL 意味着 “ 缺失的未知值 ”， 并且与其他值的处理方式略有不同。

要测试 NULL ，请使用 IS NULL 和 IS NOT NULL 运算符，如下所示：

MySQL的> SELECT 1 IS NULL, 1 IS NOT NULL;
+ ----------- + --------------- +
| 1 IS NULL | 1 IS NOT NULL |
+ ----------- + --------------- +
| 0 | 1 |
+ ----------- + --------------- +

你不能使用算术比较操作符，如 = ， < 或 <> 以测试 NULL 。 要自己演示，请尝试以下查询：

MySQL的> SELECT 1 = NULL, 1 <> NULL, 1 < NULL, 1 > NULL;
+ ---------- + ----------- + ---------- + ---------- +
| 1 = NULL | 1 <> NULL | 1 <空| 1> NULL |
+ ---------- + ----------- + ---------- + ---------- +
| NULL | NULL | NULL | NULL |
+ ---------- + ----------- + ---------- + ---------- +

因为任何算术比较的结果 NULL 也是 NULL ，所以你不能从这种比较中获得任何有意义的结果。

在MySQL中， 0 或 NULL 意味着虚假，其他任何意味着真实。 布尔运算的默认真值是 1 。

这种特殊处理 NULL 是为什么在上一节中，有必要确定哪些动物不再使用 death IS NOT NULL 而不是 death <> NULL 。

NULL 在a中， 两个 值被视为相等 GROUP BY 。

在执行操作时 ORDER BY ， NULL 如果您这样做 ORDER BY ... ASC ，则 首先显示值，如果您执行 ，则显示最后 值 ORDER BY ... DESC 。

使用时常见的错误 NULL 是假设无法将零或空字符串插入到定义为的列中 NOT NULL ，但事实并非如此。 这些实际上是价值，而 NULL 意味着 “ 没有价值。 “ 你可以通过使用 IS [NOT] NULL 如下所示 轻松地测试这个 ：

MySQL的> SELECT 0 IS NULL, 0 IS NOT NULL, '' IS NULL, '' IS NOT NULL;
+ ----------- + -------- + ------------ + -------- -------- +
| 0 IS NULL | 0 IS NOT NULL | ''是空的| ''不是空|
+ ----------- + -------- + ------------ + -------- -------- +
| 0 | 1 | 0 | 1 |
+ ----------- + -------- + ------------ + -------- -------- +

因此，完全可以将零或空字符串插入到 NOT NULL 列中，因为这些实际上是这样的 NOT NULL 。 请参见 第B.4.4.3节“NULL值的问题” 。

MySQL提供标准的SQL模式匹配以及基于扩展正则表达式的模式匹配形式，类似于Unix实用程序（如 vi ， grep 和 sed） 使用的扩展正则表达式 。

SQL模式匹配使您可以使用 _ 匹配任何单个字符并 % 匹配任意数量的字符（包括零个字符）。 在MySQL中，SQL模式默认情况下不区分大小写。 这里显示了一些例子。 不要使用 = 或 <> 使用SQL模式时。 请改用 LIKE 或 NOT LIKE 比较运算符。

要查找以 b 下列 开头的名称 ：

MySQL的> SELECT * FROM pet WHERE name LIKE 'b%';
+ -------- + -------- + --------- + ------ + ------------ +  - ----------- +
| 名字| 老板| 物种| 性别 出生| 死亡|
+ -------- + -------- + --------- + ------ + ------------ +  - ----------- +
| 巴菲| 哈罗德| 狗| f | 1989-05-13 | NULL |
| 鲍泽尔| 黛安娜 狗| m | 1989-08-31 | 1995-07-29 |
+ -------- + -------- + --------- + ------ + ------------ +  - ----------- +

要查找以以下结尾的名称 fy ：

MySQL的> SELECT * FROM pet WHERE name LIKE '%fy';
+ -------- + -------- + --------- + ------ + ------------ +  - ------ +
| 名字| 老板| 物种| 性别 出生| 死亡|
+ -------- + -------- + --------- + ------ + ------------ +  - ------ +
| 蓬松| 哈罗德| 猫| f | 1993-02-04 | NULL |
| 巴菲| 哈罗德| 狗| f | 1989-05-13 | NULL |
+ -------- + -------- + --------- + ------ + ------------ +  - ------ +

要查找包含名称 w ：

MySQL的> SELECT * FROM pet WHERE name LIKE '%w%';
+ ---------- + ------- + --------- + ------ + ------------ + ------------ +
| 名字| 老板| 物种| 性别 出生| 死亡|
+ ---------- + ------- + --------- + ------ + ------------ + ------------ +
| 爪子| 格温| 猫| m | 1994-03-17 | NULL |
| 鲍泽尔| 黛安娜 狗| m | 1989-08-31 | 1995-07-29 |
| 惠斯勒| 格温| 鸟| NULL | 1997-12-09 | NULL |
+ ---------- + ------- + --------- + ------ + ------------ + ------------ +

要查找包含五个字符的名称，请使用 _ 模式字符的 五个实例 ：

MySQL的> SELECT * FROM pet WHERE name LIKE '_____';
+ ------- + -------- + --------- + ------ + ------------ +  - ----- +
| 名字| 老板| 物种| 性别 出生| 死亡|
+ ------- + -------- + --------- + ------ + ------------ +  - ----- +
| 爪子| 格温| 猫| m | 1994-03-17 | NULL |
| 巴菲| 哈罗德| 狗| f | 1989-05-13 | NULL |
+ ------- + -------- + --------- + ------ + ------------ +  - ----- +

MySQL提供的另一种模式匹配使用扩展的正则表达式。 当您测试此类模式的匹配项时，请使用 REGEXP_LIKE() 函数（ REGEXP 或 RLIKE 运算符，它们是同义词 REGEXP_LIKE() ）。

以下列表描述了扩展正则表达式的一些特征：

为了演示扩展正则表达式的工作原理， LIKE 先前显示 的 查询将在此处重写以供使用 REGEXP_LIKE() 。

要查找 以...开头的名称 b ，请使用 ^ 以匹配名称的开头：

MySQL的> SELECT * FROM pet WHERE REGEXP_LIKE(name, '^b');
+ -------- + -------- + --------- + ------ + ------------ +  - ----------- +
| 名字| 老板| 物种| 性别 出生| 死亡|
+ -------- + -------- + --------- + ------ + ------------ +  - ----------- +
| 巴菲| 哈罗德| 狗| f | 1989-05-13 | NULL |
| 鲍泽尔| 黛安娜 狗| m | 1979-08-31 | 1995-07-29 |
+ -------- + -------- + --------- + ------ + ------------ +  - ----------- +

要强制将正则表达式比较区分大小写，请使用区分大小写的排序规则，或使用 BINARY 关键字使其中一个字符串成为二进制字符串，或指定 c 匹配控制字符。 这些查询中的每 b 一个在名称的开头 仅匹配小写 ：

SELECT * FROM pet WHERE REGEXP_LIKE（name，'^ b'COLLATE utf8mb4_0900_as_cs）;
SELECT * FROM pet WHERE REGEXP_LIKE（name，BINARY'^ b'）;
SELECT * FROM pet WHERE REGEXP_LIKE（name，'^ b'，'c'）;

要查找以？结尾的名称 fy ，请使用 $ 以匹配名称的末尾：

MySQL的> SELECT * FROM pet WHERE REGEXP_LIKE(name, 'fy$');
+ -------- + -------- + --------- + ------ + ------------ +  - ------ +
| 名字| 老板| 物种| 性别 出生| 死亡|
+ -------- + -------- + --------- + ------ + ------------ +  - ------ +
| 蓬松| 哈罗德| 猫| f | 1993-02-04 | NULL |
| 巴菲| 哈罗德| 狗| f | 1989-05-13 | NULL |
+ -------- + -------- + --------- + ------ + ------------ +  - ------ +

要查找包含a的名称 w ，请使用以下查询：

MySQL的> SELECT * FROM pet WHERE REGEXP_LIKE(name, 'w');
+ ---------- + ------- + --------- + ------ + ------------ + ------------ +
| 名字| 老板| 物种| 性别 出生| 死亡|
+ ---------- + ------- + --------- + ------ + ------------ + ------------ +
| 爪子| 格温| 猫| m | 1994-03-17 | NULL |
| 鲍泽尔| 黛安娜 狗| m | 1989-08-31 | 1995-07-29 |
| 惠斯勒| 格温| 鸟| NULL | 1997-12-09 | NULL |
+ ---------- + ------- + --------- + ------ + ------------ + ------------ +

因为正则表达式模式匹配，如果它出现在值的任何位置，则在上一个查询中不必在模式的任何一侧放置通配符以使其与整个值匹配，就像SQL模式一样。

要查找包含五个字符的名称，请使用 ^ 和 $ 匹配名称的开头和结尾，以及 . 中间的 五个实例 ：

MySQL的> SELECT * FROM pet WHERE REGEXP_LIKE(name, '^.....$');
+ ------- + -------- + --------- + ------ + ------------ +  - ----- +
| 名字| 老板| 物种| 性别 出生| 死亡|
+ ------- + -------- + --------- + ------ + ------------ +  - ----- +
| 爪子| 格温| 猫| m | 1994-03-17 | NULL |
| 巴菲| 哈罗德| 狗| f | 1989-05-13 | NULL |
+ ------- + -------- + --------- + ------ + ------------ +  - ----- +

您还可以使用 （ “ repeat- -times ” ）运算符 编写上一个查询 ： {n} n

MySQL的> SELECT * FROM pet WHERE REGEXP_LIKE(name, '^.{5}$');
+ ------- + -------- + --------- + ------ + ------------ +  - ----- +
| 名字| 老板| 物种| 性别 出生| 死亡|
+ ------- + -------- + --------- + ------ + ------------ +  - ----- +
| 爪子| 格温| 猫| m | 1994-03-17 | NULL |
| 巴菲| 哈罗德| 狗| f | 1989-05-13 | NULL |
+ ------- + -------- + --------- + ------ + ------------ +  - ----- +

有关正则表达式语法的更多信息，请参见 第12.5.2节“正则表达式” 。

数据库通常用于回答 “ 表格中某种类型的数据出现频率 的问题 ？ “ 例如，您可能想知道您拥有多少只宠物，或每个拥有者拥有多少只宠物，或者您可能想要对您的动物进行各种类型的人口普查操作。

计算你拥有的动物总数与 “ 桌子中 有多少行 pet ” 是同一个问题 ？ “ 因为每只宠物有一条记录。 COUNT(*) 计算行数，因此计算动物的查询如下所示：

MySQL的> SELECT COUNT(*) FROM pet;
+ ---------- +
| COUNT（*）|
+ ---------- +
| 9 |
+ ---------- +

之前，您检索了拥有宠物的人的姓名。 COUNT() 如果您想知道每个拥有者有多少宠物， 您可以使用 ：

MySQL的> SELECT owner, COUNT(*) FROM pet GROUP BY owner;
+ -------- + ---------- +
| 老板| COUNT（*）|
+ -------- + ---------- +
| 班尼| 2 |
| 黛安娜 2 |
| 格温| 3 |
| 哈罗德| 2 |
+ -------- + ---------- +

上述查询用于 GROUP BY 对每个记录进行分组 owner 。 使用的 COUNT() 结合 GROUP BY 是在各种分组表征您的数据非常有用。 以下示例显示了执行动物普查操作的不同方法。

每种动物数量：

MySQL的> SELECT species, COUNT(*) FROM pet GROUP BY species;
+ --------- + ---------- +
| 物种| COUNT（*）|
+ --------- + ---------- +
| 鸟| 2 |
| 猫| 2 |
| 狗| 3 |
| 仓鼠| 1 |
| 蛇| 1 |
+ --------- + ---------- +

每性别的动物数量：

MySQL的> SELECT sex, COUNT(*) FROM pet GROUP BY sex;
+ ------ + ---------- +
| 性别 COUNT（*）|
+ ------ + ---------- +
| NULL | 1 |
| f | 4 |
| m | 4 |
+ ------ + ---------- +

（在此输出中， NULL 表示性别未知。）

每种物种和性别组合的动物数量：

MySQL的> SELECT species, sex, COUNT(*) FROM pet GROUP BY species, sex;
+ --------- + ------ + ---------- +
| 物种| 性别 COUNT（*）|
+ --------- + ------ + ---------- +
| 鸟| NULL | 1 |
| 鸟| f | 1 |
| 猫| f | 1 |
| 猫| m | 1 |
| 狗| f | 1 |
| 狗| m | 2 |
| 仓鼠| f | 1 |
| 蛇| m | 1 |
+ --------- + ------ + ---------- +

使用时无需检索整个表 COUNT() 。 例如，以前的查询，只在狗和猫上执行时，如下所示：

MySQL的> SELECT species, sex, COUNT(*) FROM pet
       WHERE species = 'dog' OR species = 'cat'
       GROUP BY species, sex;
+ --------- + ------ + ---------- +
| 物种| 性别 COUNT（*）|
+ --------- + ------ + ---------- +
| 猫| f | 1 |
| 猫| m | 1 |
| 狗| f | 1 |
| 狗| m | 2 |
+ --------- + ------ + ---------- +

或者，如果你想要每性别的动物数量仅适用于已知性别的动物：

MySQL的> SELECT species, sex, COUNT(*) FROM pet
       WHERE sex IS NOT NULL
       GROUP BY species, sex;
+ --------- + ------ + ---------- +
| 物种| 性别 COUNT（*）|
+ --------- + ------ + ---------- +
| 鸟| f | 1 |
| 猫| f | 1 |
| 猫| m | 1 |
| 狗| f | 1 |
| 狗| m | 2 |
| 仓鼠| f | 1 |
| 蛇| m | 1 |
+ --------- + ------ + ---------- +

如果除了 COUNT() 值 之外还要指定要选择的列 ，则 GROUP BY 应该存在一个用于命名相同列 的 子句。 否则，会发生以下情况：

另请参见 第12.20.3节“GROUP BY的MySQL处理” 。 有关 行为和相关优化的 信息 ， 请参见 第12.20.1节“聚合（GROUP BY）函数描述” 。 COUNT(expr)

该 pet 表记录了您拥有的宠物。 如果您想记录有关它们的其他信息，例如生活中的事件，例如兽医的访问或者出生时，您需要另一张桌子。 这张桌子应该是什么样的？ 它需要包含以下信息：

鉴于这些注意事项， 表 的 CREATE TABLE 语句 event 可能如下所示：

MySQL的> CREATE TABLE event (name VARCHAR(20), date DATE,
       type VARCHAR(15), remark VARCHAR(255));

与 pet 表一样，最简单的方法是通过创建包含以下信息的制表符分隔文本文件来加载初始记录。

像这样加载记录：

MySQL的> LOAD DATA LOCAL INFILE 'event.txt' INTO TABLE event;

根据您从 pet 表中 运行的查询中学到的内容 ，您应该能够对 event 表中 的记录执行检索 ; 原则是一样的。 但是， event 表格本身 何时 不足以回答您可能会问的问题？

假设你想要找出每只宠物的窝的年龄。 我们之前看到过如何计算两个日期的年龄。 母亲的垃圾日期在 event 表格中，但要计算她在该日期的年龄，您需要她的出生日期，该日期存储在 pet 表格中。 这意味着查询需要两个表：

MySQL的> SELECT pet.name,
       TIMESTAMPDIFF(YEAR,birth,date) AS age,
       remark
       FROM pet INNER JOIN event
         ON pet.name = event.name
       WHERE event.type = 'litter';
+ -------- + ------ + ----------------------------- +
| 名字| 年龄| 备注|
+ -------- + ------ + ----------------------------- +
| 蓬松| 2 | 4只小猫，3只雌性，1只雄性|
| 巴菲| 4 | 5只小狗，2只雌性，3只雄性|
| 巴菲| 5 | 3只小狗，3只雌性|
+ -------- + ------ + ----------------------------- +

有关此查询的注意事项有以下几点：

您不需要两个不同的表来执行连接。 如果要将表中的记录与同一表中的其他记录进行比较，有时将表连接到自身会很有用。 例如，要在您的宠物中找到繁殖对，您可以 pet 自己 加入 表格，以生成候选对的活体雄性和类似物种的雌性：

MySQL的> SELECT p1.name, p1.sex, p2.name, p2.sex, p1.species
       FROM pet AS p1 INNER JOIN pet AS p2
         ON p1.species = p2.species
         AND p1.sex = 'f' AND p1.death IS NULL
         AND p2.sex = 'm' AND p2.death IS NULL;
+ -------- + ------ + ------- + ------ + --------- +
| 名字| 性别 名字| 性别 物种|
+ -------- + ------ + ------- + ------ + --------- +
| 蓬松| f | 爪子| m | 猫|
| 巴菲| f | 方| m | 狗|
+ -------- + ------ + ------- + ------ + --------- +

在此查询中，我们为表名指定别名以引用列，并保持每个列引用与表关联的表的实例。