这个答案包括:

• 第1部分
  • 使用内部联接连接两个或多个表（有关其他信息，请参阅wikipedia条目）
  • 如何使用联合查询
  • 左外部联接和右外部联接（此stackOverflow答案非常适合描述联接的类型）
  相交查询（以及如何在数据库不支持它们的情况下重现它们）--这是SQL-Server的一个功能（请参阅信息），也是我最初编写这篇文章的部分原因。
  • 子查询-它们是什么，可以在哪里使用以及要注意什么
  笛卡尔加入了-哦，苦难！

  从数据库中的多个表中检索数据有多种方法。在这个答案中，我将使用ANSI-92联接语法。这可能与其他一些使用较老的ANSI-89语法的教程不同（如果您习惯于使用89，可能会显得不那么直观--但我所能说的只是尝试一下），因为当查询开始变得更复杂时，它更容易理解。为什么要用它？是否有业绩增益？简短的回答是否定的，但是一旦你习惯了它就更容易阅读了。更容易阅读其他人使用这种语法编写的查询。

  我还将使用一个小型车场的概念，其中有一个数据库，以保持跟踪什么汽车它有可用。业主已经雇用你作为他的IT计算机的家伙，并期望你能够提供他要求的数据，在一个帽子下降。

  我做了一些查找表，这些表将由最终的表使用。这将给我们提供一个合理的工作模型。首先，我将对一个具有以下结构的示例数据库运行查询。我会试着想想刚开始时所犯的常见错误，并解释其中的错误--当然也会展示如何纠正它们。

  第一个表是简单的颜色列表，以便我们知道我们在车场有什么颜色。

  mysql> create table colors(id int(3) not null auto_increment primary key, 
      -> color varchar(15), paint varchar(10));
  Query OK, 0 rows affected (0.01 sec)
  
  mysql> show columns from colors;
  +-------+-------------+------+-----+---------+----------------+
  | Field | Type        | Null | Key | Default | Extra          |
  +-------+-------------+------+-----+---------+----------------+
  | id    | int(3)      | NO   | PRI | NULL    | auto_increment |
  | color | varchar(15) | YES  |     | NULL    |                |
  | paint | varchar(10) | YES  |     | NULL    |                |
  +-------+-------------+------+-----+---------+----------------+
  3 rows in set (0.01 sec)
  
  mysql> insert into colors (color, paint) values ('Red', 'Metallic'), 
      -> ('Green', 'Gloss'), ('Blue', 'Metallic'), 
      -> ('White' 'Gloss'), ('Black' 'Gloss');
  Query OK, 5 rows affected (0.00 sec)
  Records: 5  Duplicates: 0  Warnings: 0
  
  mysql> select * from colors;
  +----+-------+----------+
  | id | color | paint    |
  +----+-------+----------+
  |  1 | Red   | Metallic |
  |  2 | Green | Gloss    |
  |  3 | Blue  | Metallic |
  |  4 | White | Gloss    |
  |  5 | Black | Gloss    |
  +----+-------+----------+
  5 rows in set (0.00 sec)
  

  品牌表确定了不同品牌的汽车可以出售出去的货场。

  mysql> create table brands (id int(3) not null auto_increment primary key, 
      -> brand varchar(15));
  Query OK, 0 rows affected (0.01 sec)
  
  mysql> show columns from brands;
  +-------+-------------+------+-----+---------+----------------+
  | Field | Type        | Null | Key | Default | Extra          |
  +-------+-------------+------+-----+---------+----------------+
  | id    | int(3)      | NO   | PRI | NULL    | auto_increment |
  | brand | varchar(15) | YES  |     | NULL    |                |
  +-------+-------------+------+-----+---------+----------------+
  2 rows in set (0.01 sec)
  
  mysql> insert into brands (brand) values ('Ford'), ('Toyota'), 
      -> ('Nissan'), ('Smart'), ('BMW');
  Query OK, 5 rows affected (0.00 sec)
  Records: 5  Duplicates: 0  Warnings: 0
  
  mysql> select * from brands;
  +----+--------+
  | id | brand  |
  +----+--------+
  |  1 | Ford   |
  |  2 | Toyota |
  |  3 | Nissan |
  |  4 | Smart  |
  |  5 | BMW    |
  +----+--------+
  5 rows in set (0.00 sec)
  

  模型表将涵盖不同类型的汽车，这将是更简单的使用不同的汽车类型，而不是实际的汽车模型。

  mysql> create table models (id int(3) not null auto_increment primary key, 
      -> model varchar(15));
  Query OK, 0 rows affected (0.01 sec)
  
  mysql> show columns from models;
  +-------+-------------+------+-----+---------+----------------+
  | Field | Type        | Null | Key | Default | Extra          |
  +-------+-------------+------+-----+---------+----------------+
  | id    | int(3)      | NO   | PRI | NULL    | auto_increment |
  | model | varchar(15) | YES  |     | NULL    |                |
  +-------+-------------+------+-----+---------+----------------+
  2 rows in set (0.00 sec)
  
  mysql> insert into models (model) values ('Sports'), ('Sedan'), ('4WD'), ('Luxury');
  Query OK, 4 rows affected (0.00 sec)
  Records: 4  Duplicates: 0  Warnings: 0
  
  mysql> select * from models;
  +----+--------+
  | id | model  |
  +----+--------+
  |  1 | Sports |
  |  2 | Sedan  |
  |  3 | 4WD    |
  |  4 | Luxury |
  +----+--------+
  4 rows in set (0.00 sec)
  

  最后，把所有其他的桌子绑在一起，把所有东西绑在一起的桌子。ID字段实际上是用于识别汽车的唯一批号。

  mysql> create table cars (id int(3) not null auto_increment primary key, 
      -> color int(3), brand int(3), model int(3));
  Query OK, 0 rows affected (0.01 sec)
  
  mysql> show columns from cars;
  +-------+--------+------+-----+---------+----------------+
  | Field | Type   | Null | Key | Default | Extra          |
  +-------+--------+------+-----+---------+----------------+
  | id    | int(3) | NO   | PRI | NULL    | auto_increment |
  | color | int(3) | YES  |     | NULL    |                |
  | brand | int(3) | YES  |     | NULL    |                |
  | model | int(3) | YES  |     | NULL    |                |
  +-------+--------+------+-----+---------+----------------+
  4 rows in set (0.00 sec)
  
  mysql> insert into cars (color, brand, model) values (1,2,1), (3,1,2), (5,3,1), 
      -> (4,4,2), (2,2,3), (3,5,4), (4,1,3), (2,2,1), (5,2,3), (4,5,1);
  Query OK, 10 rows affected (0.00 sec)
  Records: 10  Duplicates: 0  Warnings: 0
  
  mysql> select * from cars;
  +----+-------+-------+-------+
  | id | color | brand | model |
  +----+-------+-------+-------+
  |  1 |     1 |     2 |     1 |
  |  2 |     3 |     1 |     2 |
  |  3 |     5 |     3 |     1 |
  |  4 |     4 |     4 |     2 |
  |  5 |     2 |     2 |     3 |
  |  6 |     3 |     5 |     4 |
  |  7 |     4 |     1 |     3 |
  |  8 |     2 |     2 |     1 |
  |  9 |     5 |     2 |     3 |
  | 10 |     4 |     5 |     1 |
  +----+-------+-------+-------+
  10 rows in set (0.00 sec)
  

  这将给我们足够的数据（我希望）来覆盖下面的不同类型联接的例子，也给出足够的数据使它们值得。

  因此，进入到它的坚韧，老板想知道所有的跑车的ID，他有。

  这是一个简单的两个表连接。我们有一个识别模型的表和其中有可用库存的表。如您所见，cars表的model列中的数据与我们拥有的cars表的models列相关。现在，我们知道models表的ID为1，用于sports，因此让我们编写连接。

  select
      ID,
      model
  from
      cars
          join models
              on model=ID
  

  所以这个查询看起来不错，对吧？我们已经标识了这两个表，并包含了我们需要的信息，并且使用了一个正确标识要联接在什么列上的联接。

  ERROR 1052 (23000): Column 'ID' in field list is ambiguous
  

  哦不！在我们的第一个查询中有一个错误！是的，而且是李子。您可以看到，查询确实得到了正确的列，但其中一些列存在于两个表中，因此数据库对我们所指的实际列以及列的位置感到困惑。解决这个有两个方案。第一个很好而且简单，我们可以使用tablename.columnname来告诉数据库我们的确切意思，如下所示:

  select
      cars.ID,
      models.model
  from
      cars
          join models
              on cars.model=models.ID
  
  +----+--------+
  | ID | model  |
  +----+--------+
  |  1 | Sports |
  |  3 | Sports |
  |  8 | Sports |
  | 10 | Sports |
  |  2 | Sedan  |
  |  4 | Sedan  |
  |  5 | 4WD    |
  |  7 | 4WD    |
  |  9 | 4WD    |
  |  6 | Luxury |
  +----+--------+
  10 rows in set (0.00 sec)
  

  另一种可能更常用，称为表别名。本例中的表具有漂亮而简短的名称，但键入KPI_DAILY_SALES_BY_Department之类的内容可能会很快变旧，因此一种简单的方法是将表昵称如下:

  select
      a.ID,
      b.model
  from
      cars a
          join models b
              on a.model=b.ID
  

  现在，回到请求。正如您所看到的，我们有我们需要的信息，但我们也有没有被要求的信息，所以我们需要在语句中包含一个where子句，以便只得到所要求的跑车。由于我更喜欢表别名方法，而不是反复使用表名，因此从这一点开始，我将坚持使用它。

  显然，我们需要向查询中添加一个where子句。我们可以通过id=1或model='Sports'来识别跑车。由于ID和主键都是索引的（而且很少键入），所以让我们在查询中使用它。

  select
      a.ID,
      b.model
  from
      cars a
          join models b
              on a.model=b.ID
  where
      b.ID=1
  
  +----+--------+
  | ID | model  |
  +----+--------+
  |  1 | Sports |
  |  3 | Sports |
  |  8 | Sports |
  | 10 | Sports |
  +----+--------+
  4 rows in set (0.00 sec)
  

  答对了！老板很高兴。当然，作为一个老板，他从不满足自己的要求，他看了看信息，然后说我也想要颜色。

  好的，我们已经编写了查询的很好的一部分，但是我们需要使用第三个表，它是colors。现在，我们的主信息表cars存储了car color ID，这链接回colors ID列。因此，以与原始表类似的方式，我们可以连接第三个表:

  select
      a.ID,
      b.model
  from
      cars a
          join models b
              on a.model=b.ID
          join colors c
              on a.color=c.ID
  where
      b.ID=1
  
  +----+--------+
  | ID | model  |
  +----+--------+
  |  1 | Sports |
  |  3 | Sports |
  |  8 | Sports |
  | 10 | Sports |
  +----+--------+
  4 rows in set (0.00 sec)
  

  该死的，虽然正确地联接了表并且链接了相关列，但是我们忘记了从我们刚刚链接的新表中拉入实际信息。

  select
      a.ID,
      b.model,
      c.color
  from
      cars a
          join models b
              on a.model=b.ID
          join colors c
              on a.color=c.ID
  where
      b.ID=1
  
  +----+--------+-------+
  | ID | model  | color |
  +----+--------+-------+
  |  1 | Sports | Red   |
  |  8 | Sports | Green |
  | 10 | Sports | White |
  |  3 | Sports | Black |
  +----+--------+-------+
  4 rows in set (0.00 sec)
  

  好吧，我们暂时不用管老板了。现在，我们来更详细地解释一下。正如您所看到的，我们语句中的from子句链接了我们的主表（我经常使用包含信息的表而不是查找表或维度表）。当所有的表都被切换时，这个查询也能正常工作，但是当我们在几个月后再来读这个查询时，这个查询的意义就不大了，所以最好的方法是尝试编写一个好的，易于理解的查询--直观地布置它，使用好的缩进，这样所有的东西都能尽可能清晰地显示出来。如果你继续教别人，试着在他们的查询中灌输这些特征--尤其是当你要排除他们的故障时。

  用这种方式链接越来越多的表是完全可能的。

  select
      a.ID,
      b.model,
      c.color
  from
      cars a
          join models b
              on a.model=b.ID
          join colors c
              on a.color=c.ID
          join brands d
              on a.brand=d.ID
  where
      b.ID=1
  

  虽然我忘了在join语句中包含一个表，我们可能希望在其中联接多个列，但下面是一个示例。如果models表具有特定于品牌的模型，因此也有一个名为brand的列，该列链接回id字段上的brands表，则可以如下所示:

  select
      a.ID,
      b.model,
      c.color
  from
      cars a
          join models b
              on a.model=b.ID
          join colors c
              on a.color=c.ID
          join brands d
              on a.brand=d.ID
              and b.brand=d.ID
  where
      b.ID=1
  

  您可以看到，上面的查询不仅将连接的表链接到主cars表，而且还指定了已经连接的表之间的连接。如果没有这样做，则结果称为笛卡尔联接--这是dba表示不好的说法。笛卡尔联接是返回行的联接，因为信息没有告诉数据库如何限制结果，所以查询返回符合条件的所有行。

  因此，为了给出笛卡尔联接的一个示例，让我们运行以下查询:

  select
      a.ID,
      b.model
  from
      cars a
          join models b
  
  +----+--------+
  | ID | model  |
  +----+--------+
  |  1 | Sports |
  |  1 | Sedan  |
  |  1 | 4WD    |
  |  1 | Luxury |
  |  2 | Sports |
  |  2 | Sedan  |
  |  2 | 4WD    |
  |  2 | Luxury |
  |  3 | Sports |
  |  3 | Sedan  |
  |  3 | 4WD    |
  |  3 | Luxury |
  |  4 | Sports |
  |  4 | Sedan  |
  |  4 | 4WD    |
  |  4 | Luxury |
  |  5 | Sports |
  |  5 | Sedan  |
  |  5 | 4WD    |
  |  5 | Luxury |
  |  6 | Sports |
  |  6 | Sedan  |
  |  6 | 4WD    |
  |  6 | Luxury |
  |  7 | Sports |
  |  7 | Sedan  |
  |  7 | 4WD    |
  |  7 | Luxury |
  |  8 | Sports |
  |  8 | Sedan  |
  |  8 | 4WD    |
  |  8 | Luxury |
  |  9 | Sports |
  |  9 | Sedan  |
  |  9 | 4WD    |
  |  9 | Luxury |
  | 10 | Sports |
  | 10 | Sedan  |
  | 10 | 4WD    |
  | 10 | Luxury |
  +----+--------+
  40 rows in set (0.00 sec)
  

  天哪，真难看。然而，就数据库而言，正是所求。在查询中，我们从cars中请求id，从models中请求model。但是，因为我们没有指定如何连接表，数据库已经匹配了第一个表的每一行和第二个表的每一行。

  好吧，老板回来了，他又想要更多的信息。我想要同样的清单，但也包括四轮驱动在其中。

  然而，这给了我们一个很好的借口，看看两种不同的方法来实现这一点。我们可以在where子句中添加另一个条件，如下所示:

  select
      a.ID,
      b.model,
      c.color
  from
      cars a
          join models b
              on a.model=b.ID
          join colors c
              on a.color=c.ID
          join brands d
              on a.brand=d.ID
  where
      b.ID=1
      or b.ID=3
  

  虽然上面的方法可以很好地工作，但让我们换个角度来看，这是一个很好的借口来展示union查询是如何工作的。

  我们知道下面会把跑车全部退回:

  select
      a.ID,
      b.model,
      c.color
  from
      cars a
          join models b
              on a.model=b.ID
          join colors c
              on a.color=c.ID
          join brands d
              on a.brand=d.ID
  where
      b.ID=1
  

  下面将返回所有四轮驱动:

  select
      a.ID,
      b.model,
      c.color
  from
      cars a
          join models b
              on a.model=b.ID
          join colors c
              on a.color=c.ID
          join brands d
              on a.brand=d.ID
  where
      b.ID=3
  

  因此通过在它们之间添加union all子句，第二个查询的结果将被追加到第一个查询的结果之后。

  select
      a.ID,
      b.model,
      c.color
  from
      cars a
          join models b
              on a.model=b.ID
          join colors c
              on a.color=c.ID
          join brands d
              on a.brand=d.ID
  where
      b.ID=1
  union all
  select
      a.ID,
      b.model,
      c.color
  from
      cars a
          join models b
              on a.model=b.ID
          join colors c
              on a.color=c.ID
          join brands d
              on a.brand=d.ID
  where
      b.ID=3
  
  +----+--------+-------+
  | ID | model  | color |
  +----+--------+-------+
  |  1 | Sports | Red   |
  |  8 | Sports | Green |
  | 10 | Sports | White |
  |  3 | Sports | Black |
  |  5 | 4WD    | Green |
  |  7 | 4WD    | White |
  |  9 | 4WD    | Black |
  +----+--------+-------+
  7 rows in set (0.00 sec)
  

  如您所见，首先返回第一个查询的结果，然后是第二个查询的结果。

  在本例中，简单地使用第一个查询当然会容易得多，但是union查询对于特定情况可能非常有用。它们是从不容易连接在一起的表（或者完全不相关的表）返回特定结果的好方法。不过，有一些规则需要遵循。

  • 来自第一个查询的列类型必须与来自下面其他每一个查询的列类型匹配。
  • 来自第一个查询的列的名称将用于标识整个结果集。
  • 每个查询中的列数必须相同。

  现在，您可能想知道使用union和使用union all有什么区别。Union查询将删除重复项，而Union All则不会。这确实意味着在使用union时，在使用unionALL时，性能会受到很小的影响，但结果可能是值得的--不过，我不会在本文中推测这类事情。

  在这一点上，这里可能值得注意一些额外的注意事项。

  • 如果要对结果排序，可以使用order by，但不能再使用别名。在上面的查询中，用a.id追加顺序将导致错误--就结果而言，该列被称为id而不是a.id-尽管两个查询中使用了相同的别名。
  • 我们只能有一条order by语句，并且它必须作为最后一条语句。

  在下一个示例中，我将向表中添加一些额外的行。

  我已将holden添加到brands表中。我还在cars中添加了一行，它的color值为12-在colors表中没有引用。

  好了，老板又回来了，汪汪要求-*我要我们每个品牌的数量和车的数量！`-通常情况下，我们刚讨论到一个有趣的部分，老板要更多的工作。

  好的，所以我们要做的第一件事就是得到一份可能的品牌的完整列表。

  select
      a.brand
  from
      brands a
  
  +--------+
  | brand  |
  +--------+
  | Ford   |
  | Toyota |
  | Nissan |
  | Smart  |
  | BMW    |
  | Holden |
  +--------+
  6 rows in set (0.00 sec)
  

  现在，当我们将它加入到我们的cars表中时，我们得到以下结果:

  select
      a.brand
  from
      brands a
          join cars b
              on a.ID=b.brand
  group by
      a.brand
  
  +--------+
  | brand  |
  +--------+
  | BMW    |
  | Ford   |
  | Nissan |
  | Smart  |
  | Toyota |
  +--------+
  5 rows in set (0.00 sec)
  

  这当然是一个问题--我们没有看到任何提到我添加的可爱的holden品牌。

  这是因为联接会在两个表中查找匹配的行。由于cars中没有类型为holden的数据，因此不会返回。这就是我们可以使用outer联接的地方。这将返回来自一个表的所有结果，无论它们在另一个表中是否匹配:

  select
      a.brand
  from
      brands a
          left outer join cars b
              on a.ID=b.brand
  group by
      a.brand
  
  +--------+
  | brand  |
  +--------+
  | BMW    |
  | Ford   |
  | Holden |
  | Nissan |
  | Smart  |
  | Toyota |
  +--------+
  6 rows in set (0.00 sec)
  

  现在我们有了这个功能，我们可以添加一个可爱的聚合函数来获得计数并暂时摆脱老板的困扰。

  select
      a.brand,
      count(b.id) as countOfBrand
  from
      brands a
          left outer join cars b
              on a.ID=b.brand
  group by
      a.brand
  
  +--------+--------------+
  | brand  | countOfBrand |
  +--------+--------------+
  | BMW    |            2 |
  | Ford   |            2 |
  | Holden |            0 |
  | Nissan |            1 |
  | Smart  |            1 |
  | Toyota |            5 |
  +--------+--------------+
  6 rows in set (0.00 sec)
  

  说完，老板就躲开了。

  现在，为了更详细地解释这一点，外部联接可以是left或right类型。左或右定义了哪个表是完全包含的。左外部联接将包括左侧表中的所有行，而右外部联接将右侧表中的所有结果带入结果（您猜到了）。

  某些数据库允许完全外部联接，这将从两个表返回结果（无论匹配与否），但并非所有数据库都支持这一功能。

  现在，我可能想知道，您是否可以在查询中合并连接类型--答案是肯定的，您绝对可以。

  select
      b.brand,
      c.color,
      count(a.id) as countOfBrand
  from
      cars a
          right outer join brands b
              on b.ID=a.brand
          join colors c
              on a.color=c.ID
  group by
      a.brand,
      c.color
  
  +--------+-------+--------------+
  | brand  | color | countOfBrand |
  +--------+-------+--------------+
  | Ford   | Blue  |            1 |
  | Ford   | White |            1 |
  | Toyota | Black |            1 |
  | Toyota | Green |            2 |
  | Toyota | Red   |            1 |
  | Nissan | Black |            1 |
  | Smart  | White |            1 |
  | BMW    | Blue  |            1 |
  | BMW    | White |            1 |
  +--------+-------+--------------+
  9 rows in set (0.00 sec)
  

  那么，为什么这不是预期的结果呢？这是因为尽管我们选择了从cars到brands的外部连接，但它没有在连接到colors中指定--因此特定的连接只会带回两个表中匹配的结果。

  下面是一个查询，它可以获得我们所期望的结果:

  select
      a.brand,
      c.color,
      count(b.id) as countOfBrand
  from
      brands a
          left outer join cars b
              on a.ID=b.brand
          left outer join colors c
              on b.color=c.ID
  group by
      a.brand,
      c.color
  
  +--------+-------+--------------+
  | brand  | color | countOfBrand |
  +--------+-------+--------------+
  | BMW    | Blue  |            1 |
  | BMW    | White |            1 |
  | Ford   | Blue  |            1 |
  | Ford   | White |            1 |
  | Holden | NULL  |            0 |
  | Nissan | Black |            1 |
  | Smart  | White |            1 |
  | Toyota | NULL  |            1 |
  | Toyota | Black |            1 |
  | Toyota | Green |            2 |
  | Toyota | Red   |            1 |
  +--------+-------+--------------+
  11 rows in set (0.00 sec)
  

  正如我们所看到的，我们在查询中有两个外部连接，结果正如所期望的那样通过。

  那么，其他类型的连接呢？十字路口呢？

  不是所有数据库都支持交集，但几乎所有数据库都允许您通过连接（或者至少是结构良好的where语句）创建交集。

  交集是一种联接类型，与上面描述的联合有点类似--但区别在于它只返回由联合联接的各个单独查询之间相同（我的意思是相同）的数据行。只有在所有方面都相同的行才会返回。

  一个简单的例子如下:

  select
      *
  from
      colors
  where
      ID>2
  intersect
  select
      *
  from
      colors
  where
      id<4
  

  正常的union查询将返回表的所有行（第一个查询返回id>2上的任何内容，第二个查询返回具有id<4的任何内容），从而得到完整的集合，而intersect查询将只返回与id=3匹配的行，因为它同时满足这两个条件。

  现在，如果您的数据库不支持intersect查询，则可以通过以下查询轻松地满足上述要求:

  select
      a.ID,
      a.color,
      a.paint
  from
      colors a
          join colors b
              on a.ID=b.ID
  where
      a.ID>2
      and b.ID<4
  
  +----+-------+----------+
  | ID | color | paint    |
  +----+-------+----------+
  |  3 | Blue  | Metallic |
  +----+-------+----------+
  1 row in set (0.00 sec)
  

  如果希望使用不支持交集查询的数据库在两个不同的表之间执行交集，则需要在表的每一列上创建一个联接。