查看“Mysql常见查询示例”的源代码

以下是使用MySQL解决一些常见问题的示例。


===创建表===
其中一些示例使用表格shop来存储每个交易者（dealer）的每个商品（item number）的价格。假设每个交易者对于每个商品都有一个固定的价格，那么（article，dealer）是记录的主键。

启动命令行工具mysql并选择一个数据库：

 $> mysql your-database-name
使用以下语句创建并填充示例表格：

 CREATE TABLE shop (
 article INT UNSIGNED DEFAULT '0000' NOT NULL,
 dealer CHAR(20) DEFAULT '' NOT NULL,
 price DECIMAL(16,2) DEFAULT '0.00' NOT NULL,
 PRIMARY KEY(article, dealer));
 INSERT INTO shop VALUES
 (1,'A',3.45),(1,'B',3.99),(2,'A',10.99),(3,'B',1.45),
 (3,'C',1.69),(3,'D',1.25),(4,'D',19.95);
执行完语句后，表格应该有以下内容：

 SELECT * FROM shop ORDER BY article;

 +---------+--------+-------+
 | article | dealer | price |
 +---------+--------+-------+
 | 1 | A | 3.45 |
 | 1 | B | 3.99 |
 | 2 | A | 10.99 |
 | 3 | B | 1.45 |
 | 3 | C | 1.69 |
 | 3 | D | 1.25 |
 | 4 | D | 19.95 |
 +---------+--------+-------+

===查询列的最大值===
 SELECT MAX(article) AS article FROM shop;
 
 +---------+
 | article |
 +---------+
 | 4 |
 +---------+


===找到某一列最大值所在行===
这可以通过子查询轻松完成：

 SELECT article, dealer, price
 FROM shop
 WHERE price=(SELECT MAX(price) FROM shop);
 
 +---------+--------+-------+
 | article | dealer | price |
 +---------+--------+-------+
 | 0004 | D | 19.95 |
 +---------+--------+-------+

另一种解决方案是使用 LEFT JOIN，如下所示：

 SELECT s1.article, s1.dealer, s1.price
 FROM shop s1
 LEFT JOIN shop s2 ON s1.price < s2.price
 WHERE s2.article IS NULL;

你也可以通过按价格降序排序所有行，并使用 MySQL 特定的 LIMIT 子句仅获取第一行，像这样：

 SELECT article, dealer, price
 FROM shop
 ORDER BY price DESC
 LIMIT 1;

 注意
 
 如果有几个价格都是 19.95 的最贵商品，则 LIMIT 解决方案只会显示其中一个。


===找到每个组的最大列值===
 SELECT article, MAX(price) AS price
 FROM shop
 GROUP BY article
 ORDER BY article;
 
 +---------+-------+
 | article | price |
 +---------+-------+
 | 0001 | 3.99 |
 | 0002 | 10.99 |
 | 0003 | 1.69 |
 | 0004 | 19.95 |
 +---------+-------+


===找到持有某一列分组最大值的行===

可以使用以下子查询解决此问题：

 SELECT article, dealer, price
 FROM shop s1
 WHERE price=(SELECT MAX(s2.price)
 FROM shop s2
 WHERE s1.article = s2.article)
 ORDER BY article;
 
 +---------+--------+-------+
 | article | dealer | price |
 +---------+--------+-------+
 | 0001 | B | 3.99 |
 | 0002 | A | 10.99 |
 | 0003 | C | 1.69 |
 | 0004 | D | 19.95 |
 +---------+--------+-------+

上述示例使用了相关子查询，这可能效率不高。解决该问题的其他可能性是在FROM子句中使用非相关子查询、LEFT JOIN或带有窗口函数的公共表达式。


非相关子查询：

 SELECT s1.article, dealer, s1.price
 FROM shop s1
 JOIN (
 SELECT article, MAX(price) AS price
 FROM shop
 GROUP BY article) AS s2
 ON s1.article = s2.article AND s1.price = s2.price
 ORDER BY article;


LEFT JOIN：

 SELECT s1.article, s1.dealer, s1.price
 FROM shop s1
 LEFT JOIN shop s2 ON s1.article = s2.article AND s1.price < s2.price
 WHERE s2.article IS NULL
 ORDER BY s1.article;

LEFT JOIN基于这样的事实：当s1.price达到最大值时，没有s2.price的值更大，因此相应的s2.article值为NULL。


带有窗口函数的公共表达式：

 WITH s1 AS (
    SELECT article, dealer, price,
           RANK() OVER (PARTITION BY article
                            ORDER BY price DESC
                       ) AS `Rank`
      FROM shop
 )
 SELECT article, dealer, price
   FROM s1
   WHERE `Rank` = 1
 ORDER BY article;


===使用用户定义变量===
您可以使用MySQL用户变量来记住结果，而无需将其存储在客户端的临时变量中。 

例如，要查找价格最高和最低的文章，可以执行以下操作：

 mysql> SELECT @min_price:=MIN(price),@max_price:=MAX(price) FROM shop;
 mysql> SELECT * FROM shop WHERE price=@min_price OR price=@max_price;
 +---------+--------+-------+
 | article | dealer | price |
 +---------+--------+-------+
 | 0003 | D | 1.25 |
 | 0004 | D | 19.95 |
 +---------+--------+-------+

 注意
 还可以将数据库对象（例如表或列）的名称存储在用户变量中，然后在SQL语句中使用此变量；但是，这需要使用准备好的语句。


===使用外键===

MySQL支持外键，允许跨表引用相关数据，并且外键约束可以帮助保持相关数据的一致性。

外键关系涉及一个保存初始列值的父表和一个引用父列值的子表。外键约束定义在子表上。

以下示例通过单列外键关系关联父表和子表，并展示了外键约束如何强制引用完整性。

创建父表和子表：

 CREATE TABLE parent (
 id INT NOT NULL,
 PRIMARY KEY (id)
 ) ENGINE=INNODB;
 
 CREATE TABLE child (
 id INT,
 parent_id INT,
 INDEX par_ind (parent_id),
 FOREIGN KEY (parent_id)
 REFERENCES parent(id)
 ) ENGINE=INNODB;

向父表中插入一行：

 mysql> INSERT INTO parent (id) VALUES (1);
验证数据是否插入成功：

 mysql> SELECT * FROM parent;
 +----+
 | id |
 +----+
 | 1 |
 +----+
向子表中插入一行：

 mysql> INSERT INTO child (id,parent_id) VALUES (1,1);
插入操作成功，因为父表中存在parent_id为1的记录。

向子表中插入一个parent_id值在父表中不存在的行：

 mysql> INSERT INTO child (id,parent_id) VALUES(2,2);
 ERROR 1452 (23000): Cannot add or update a child row: a foreign key constraint fails
 (test.child, CONSTRAINT child_ibfk_1 FOREIGN KEY (parent_id)
 REFERENCES parent (id))
 该操作失败，因为指定的parent_id值在父表中不存在。

尝试从父表中删除先前插入的行：

 mysql> DELETE FROM parent WHERE id VALUES = 1;
 ERROR 1451 (23000): Cannot delete or update a parent row: a foreign key constraint fails
 (test.child, CONSTRAINT child_ibfk_1 FOREIGN KEY (parent_id)
 REFERENCES parent (id))
 该操作失败，因为子表中的记录包含引用的id（parent_id）值。

当一项操作影响父表中具有匹配行的键值时，其结果取决于FOREIGN KEY子句中的ON UPDATE和ON DELETE子句指定的引用操作。省略ON DELETE和ON UPDATE子句（与当前子表定义相同）等同于指定RESTRICT选项，该选项拒绝影响父表中具有匹配行的键值的操作。

为了演示ON DELETE和ON UPDATE引用操作，删除子表并重新创建它以包括ON UPDATE和ON DELETE子句及CASCADE选项。CASCADE选项在删除或更新父表中的行时自动删除或更新子表中的匹配行。

 DROP TABLE child;
 
 CREATE TABLE child (
 id INT,
 parent_id INT,
 INDEX par_ind (parent_id),
 FOREIGN KEY (parent_id)
 REFERENCES parent(id)
 ON UPDATE CASCADE
 ON DELETE CASCADE
 ) ENGINE=INNODB;
向子表中插入以下行：

 mysql> INSERT INTO child (id,parent_id) VALUES(1,1),(2,1),(3,1);
验证数据是否插入成功：

 mysql> SELECT * FROM child;
 +------+-----------+
 | id | parent_id |
 +------+-----------+
 | 1 | 1 |
 | 2 | 1 |
 | 3 | 1 |
 +------+-----------+
更新父表中的id，将其从1更改为2。

 mysql> UPDATE parent SET id = 2 WHERE id = 1;
验证更新是否成功：

 mysql> SELECT * FROM parent;
 +----+
 | id |
 +----+
 | 2 |
 +----+
验证ON UPDATE CASCADE引用操作是否更新了子表：

 mysql> SELECT * FROM child;
 +------+-----------+
 | id | parent_id |
 +------+-----------+
 | 1 | 2 |
 | 2 | 2 |
 | 3 | 2 |
 +------+-----------+
为演示ON DELTE CASCADE引用操作，从父表中删除parent_id = 2的记录，这将删除父表中的所有记录。

 mysql> DELETE FROM parent WHERE id = 2;
由于子表中的所有记录都与parent_id = 2相关联，因此ON DELETE CASCADE引用操作将从子表中删除所有记录：

 mysql> SELECT * FROM child;
 Empty set (0.00 sec)