本文概述了关系和非关系数据库的区别，你还将了解如何根据它们的优缺点来决定哪一个更适合相应的项目。

我们将讨论：

• 数据库的定义
  • SQL 是什么?
• 关系型数据库
  • 特点
  • ACID 属性
• 非关系型数据库
  • 类型
  • BASE 属性
• 关系型数据库 VS 非关系型数据库
• 拓展阅读

什么是数据库？针对初学者的定义

在计算机里，数据是以不同形式出现的信息片段。它可以是文本、数字、图像、音频片段或视频。

信息集合需要被存储、处理和解释。这时就需要一种可按需轻松搜索、访问、提取和检索已保存资源的方法。该方法可以使计算机或人类分析可访问的数据、执行计算和比较、做出逻辑决策得出结论。

当然可以使用 Excel 电子表格等软件将数据存储在文件中，这样也可以完成有限的工作。

但是，如果数据量很大，使用 Excel 处理就捉襟见肘了。

在数据量增大时，Excel 无法快速检索。并且 Excel 很难固定其数据结构。

数据库是一种更易于访问、更高效且更有条理的长期存储和处理信息的方式。

数据库存储数据的规范性和系统性以及其检索数据的便捷性使其成为基于 Web 的应用程序中重要的部分。

数据库几乎可以用于所有应用程序。它们可以用来存储用户信息，例如用户名、电子邮件地址、加密密码和物理地址。

它们还存储用户行为。例如，在电商网站中，数据库会保存并跟踪“收藏”的商品。

一般使用数据库管理系统（或简称 DBMS）来管理数据库。

数据库管理系统是一个软件程序，充当最终用户和数据库中间的媒介。可以通过数据库管理系统创建和管理数据库。也可以执行查询来访问、修改和操作存储在数据库中的数据。

只需通过一些命令就可以方便轻松地存储、检索、更新和删除数据。

谈到数据库管理系统，通常有两种类型可供选择：

• 关系型数据库（也就是 SQL 数据库）
• 非关系型数据库（也就是 NoSQL 数据库）

SQL 是什么?

SQL 是 Structured Query Language 的缩写。

你可能会听过它以两种发音方式 - “S. Q. L.”（ess-kew-ell）或“se-quel”（/ˈsēkwəl/）。

无论哪种方式，SQL 都代表数据库处理的语言。

具体来说，使用 SQL，可以编写数据库查询以和数据库进行通信。查询可以是用于执行任何 CRUD（创建、读取、更新、删除）操作的命令。

SQL 是关系数据库管理系统的首选语言，将在下一节中详细介绍。

什么是关系数据库？

关系数据库（或 SQL 数据库）已经存在了一段时间。第一个关系数据库出现在 1970 年，关系数据库至今仍然很流行，一些最常见的如：

• PostgreSQL
• Microsoft SQL Server
• MySQL
• Oracle
• SQLite

关系数据库以结构化和表的方式存储数据。也就是说，它将信息存储在表中，可以将其视为数据的存储容器。例如，一家公司可以有一个 employees 表来存储其员工的数据。

关系数据库具有严格的、静态的预定义逻辑架构（schema）。可以将数据库架构视为一个组织蓝图——一组规则：哪些可以插入表、哪些不能插入表、以及如何设置数据。

在每个表中，至少有一个列（column）。这些列具有特定的数据类型，例如 INTEGER 或 VARCHAR。在 employees 表中，一些列可能是 employee_id、name、department、email 和 salary。

所有列和其数据类型构成架构。

             EMPLOYEES

+-------------+------+------------+-------+--------+
| employee_id | name | department | email | salary |
+-------------+------+------------+-------+--------+

一个表也会包含行（rows） 或 记录（records）。记录是遵守预定义架构的单个数据条目。本质上，它是一个数据项。

             EMPLOYEES
+-------------+------------------+------------+-----------------------+--------+
| employee_id |       name       | department |         email         | salary |
+-------------+------------------+------------+-----------------------+--------+
|           1 |  John Doe        | IT         | johndoe@company.com   |   3500 |
|           2 |  Kelly Kellinson | Marketing  | kelly@company.com     |   1500 |
|           3 |  Mike Manson     | Product    | mikekane@company.com  |   2300 |
+-------------+------------------+------------+-----------------------+--------+

由于关系数据库支持 SQL，所以可以直接执行查询。例如，如果想 view 月薪 greater than 2000 dollars 的 employees 的 names，那么可以编写如下 SQL 查询：

SELECT name FROM employees
WHERE salary > 2000;

执行上面的查询，会获得以下输出：

+-------------+
|    name     |
+-------------+
| John Doe    |
| Mike Manson |
+-------------+

关系数据库的特点

到目前为止，已经了解了关系数据库：

• 是表格格式
• 非常有条理，并且数据以某种结构存储
• 具有严格、预定义的架构
• 使用 SQL 执行数据库查询和操作数据

此外，一个关系数据库可以有多个表，正如数据库管理系统的名称所暗示的那样，这些表可以是相互关联的。

例如，一家电商公司可能有一个 products 表、一个 users 表、一个 emails 表和一个 orders 表。

由于表和存储在其中的信息之间存在连接和关联，可以使用命令来连接表。

关系数据库有一个主键，它作为标识符，确保表中的每一项都是唯一的，从而确保表中没有重复和冗余的数据。

外键 用于表示在表之间的关系。

不同表中的数据可以有不同的关系：

• 一对一的关系：在这种情况下，一个表中的记录仅与另一个表中的一条记录相关。电商网站中一对一关系的示例是，一个用户只能拥有一个电子邮件地址，且一个电子邮件地址只能属于一个用户。
• 一对多关系：在这种情况下，一张表中的一条记录与另一张表中的多条其他记录相关。例如，在电商网站中，一个用户可以下许多订单，但每个订单都是由一个用户下的。
• 多对多关系：在这种情况下，一个表中的一个或多个记录可以与另一个表中的一个或多个记录相关。例如，在电商网站中，一个订单可以有很多产品，而一个产品可以被购买多次。

关系数据库中的 ACID 属性

关系数据库提供 ACID 数据一致性模型。

ACID 是原子性（Atomicity）、一致性（Consistency）、事务隔离（Isolation）、持久性（Durability） 的首字母缩写词。

原子性意味着事务是原子的并且采取 “all or nothing” 的方法。

也就是，要么整个操作成功，从头到尾完成，要么不成功，整个操作“回滚”。

所有操作都保证以成功或失败结束，不存在部分成功。

一致性是确保数据库结构从事务开始到结束保持不变。一致性确保进入数据库的任何数据都遵循已设置的规则和约束。它可以保护和维护关系数据库中数据的完整性。

事务隔离意味着尽管在任何时候都发生了许多事务，但每个事务都被视为一个原子的、独立的单元，并且事务似乎是按顺序发生的。

例如，如果两个事务同时发生，此属性可确保一个事务以及那里发生的更改不会以任何方式影响另一个事务。

最后，持久性意味着事务的任何结果和更改都已提交，因此是永久性的，并且将持续存在，即使出现系统故障也是如此。

ACID 模型可确保数据库可靠且安全。

什么是非关系数据库？

非关系型数据库也称为 NoSQL 数据库。经常会看到 NoSQL 代表“Not only SQL”和“Non-SQL”。

无论哪种方式，非关系数据库都是指不使用关系数据模型的数据库。

尽管这个术语和这种类型的数据库已经存在了几十年，但 NoSQL 数据库在 1990 年代后期才开始受欢迎，当时 Internet 也变得越来越流行。

关系数据库已无法满足互联网海量且复杂的数据。

一些最流行的非关系数据库：

• MongoDB
• Redis
• Apache Cassandra
• Google Cloud Bigtable
• Amazon DynamoDB

非关系数据库不以表格式存储和组织数据。不同数据点之间没有表、行、列或关系。

相反，数据存储在集合中。数据库通常是非结构化的并使用动态架构。

非关系数据库的类型

有四种主要类型的非关系数据库：

• 列式数据库
• 键-值数据库
• 面向文档的数据库
• 图数据库

列式数据库在概念上类似于关系数据库，但它们使用组或列集（也称为列族）而不是行来逻辑组织相关数据。可以通过使用与单个列关联的唯一行键来独立访问列族。列式数据库搜索特定数据的速度很快，因为无需通过不相关的信息行来查找要搜索的内容。

键-值数据库是最简单的非关系数据库类型之一。数据以键值对集合的形式存储在字典或哈希表中。这种类型的数据库具有唯一的键。键充当指向特定值的指针并与该值相关联。分配给键的值可以是任何信息和数据类型。要检索和访问该值，请使用唯一键作为引用。

面向文档的数据库也以键值对的方式存储数据。但是其值是一个文档，它有一个唯一的键作为它的标识符。文档可以是任何格式，例如 XML、YAML 或二进制，通常采用 JSON 格式。这种类型的数据库以半结构化的方式存储数据。没有架构或预定义的结构。正因为如此，它更灵活，可以在项目需求发生变化时重新安排和重新设计数据库结构。它还提供了类似 SQL 的查询语言或者通过 API 来对数据执行查询以及 CRUD 操作。

图数据库是最复杂的非关系数据库类型，它们可以处理大量数据。图数据库专注于数据元素之间的连接和关系，并使用图论来存储、搜索和管理这些关系。图数据库使用 nodes 来存储数据，用 nodes 表示单个实体或数据。一个节点连接到另一个节点。为了表示实体之间的连接或关系，图数据库还用到了 edges。

非关系数据库中的 BASE 属性

非关系数据库提供 BASE 数据库一致性模型。该模型不像关系数据库的 ACID 模型那样严格。

BASE 是以下的首字母缩写词：

• Basic Availability 基本可用，该模型不关注数据的即时一致性。但是，该系统似乎在持续工作，并始终保证数据的可用性。
• Soft 软状态，由于缺乏即时一致性，系统的状态可能会随着时间而改变。软状态意味着系统不需要写一致性。
• Eventual 最终一致性，主要优先事项是数据的持续可用，而不是数据一致性。但是，最终在某个时候，可以期望数据是一致的。当系统停止接收输入时，可能会发生这种情况。

如何在 SQL 和 NoSQL 数据库之间进行选择

在学习了 SQL 和 NoSQL 数据库的基础知识之后，可能想知道如何为项目选择适合类型的数据库。

嗯，这个问题没有明确的答案。

两种数据库都有优点和缺点，这在很大程度上取决于正在构建的应用程序的类型、将使用的数据的类型以及的未来目标。

通常在产品中都会涉及到这两种类型的数据库。

以下是它们特征的快速摘要，可帮助决定哪一个可能更适合。

何时使用 SQL 数据库

• 需要分布在多个表中的高度结构化的数据，需要数据遵守严格的、可预测的、预定义的和已经计划好的模式。
• 数据将保持相对不变。如果不打算频繁更改数据库的结构并且不需要定期更新项目，SQL 数据库会很方便。请记住，它们提供的灵活性很小。
• 需要一致的数据。
• 数据完整性和安全性是重中之重。
• 需要复杂查询的准确结果。

SQL 数据库的一个缺点是它们是垂直扩展的。当存储变多时，需要增加当前机器上的硬件和提高计算能力。这可能代价高昂。需要增加处理能力和内存存储来处理增加的负载以提高性能。

何时使用 NoSQL 数据库

• 在一个快速的开发环境中工作，需要经常调整需求并不断更改数据库结构。
• 正在处理大量性质不同但不需要大量结构或准确性的数据。
• 正在处理需要频繁更新的数据。NoSQL 数据库提供了一个松散、灵活和动态的模式，允许对数据进行定期更改。
• 需要快速的查询结果和系统的持续可用性。
• 不想对数据库进行任何前期规划、准备或设计，而是想立即开始构建。

NoSQL 数据库的一大优势是它们可以水平扩展。

它们的设计方式可以将更多机器添加到现有机器（例如云服务器）中。与需要额外 CPU（中央处理单元）或 RAM（随机存取存储器）资源的垂直缩放相比，这种行为更可取。

但当然，NoSQL 数据库的一个缺点是它们不能确保数据的完整性和一致性。

拓展阅读

这篇文章只是触及了皮毛，最好的学习方法就是边做边学。

以下是一些学习资源，可用于了解有关数据库和 SQL 的更多信息：

• Learn SQL – Free Relational Database Courses for Beginners，为这篇文章添加书签以获取免费 SQL 课程列表。
• freeCodeCamp 关系数据库（Beta） 认证，在本课程中，你将学习到必要的开发人员工具，然后将学习如何使用代码编辑器、命令行和 Git，还将学习使用 PostgreSQL（一种关系数据库管理系统）和 SQL——它的查询语言。
• Learn About NoSQL Databases in This 3-hour Course，在本课程中，将了解四种不同的 NoSQL 数据库类型。除了理论之外，还有实战。

结语

你已经到了文章的结尾！

希望你了解了关系数据库和非关系数据库之间的主要区别。文末的额外的资源可以继续学习，将新技能付诸实践。

感谢你阅读本文，祝你编码愉快！

在本文中，我会分享一些有关 MongoDB 命令的基本知识，例如查询、过滤数据、删除、更新等等。

好的，我们开始吧！

配置

为了使用 MongoDB，首先需要在计算机上安装 MongoDB。为此，请访问官方下载中心，下载适用于你的操作系统的版本。在这篇文章里，我会以 Windows 为例。

下载 MongoDB 社区服务器设置后，你将依次点击“下一个”完成安装。完成后，转到安装了 MongoDB 的 C 驱动器。打开程序文件，然后选择 MongoDB 目录。

C: -> Program Files -> MongoDB -> Server -> 4.0(version) -> bin

在 bin 目录中，你会发现几个有趣的可执行文件。

• mongod
• mongo

我们看一下这两个文件。

mongod 代表“ Mongo Daemon”。mongod 是 MongoDB 使用的后台进程。mongod 的主要目的是管理所有 MongoDB 服务器任务，例如：接受请求，响应客户端和内存管理。

mongo 是可以与客户端（例如，系统管理员和开发人员）进行交互的命令行外壳。

现在，让我们看看如何启动和运行该服务器。在 Windows 上，首先需要在 C 驱动器中创建几个目录。在 C 驱动器中打开命令提示符，然后执行以下操作：

C:\> mkdir data/dbC:\> cd dataC:\> mkdir db

这些目录的目的是 MongoDB 需要一个文件夹来存储所有数据。MongoDB 的默认数据目录路径是驱动器上的 /data/db。因此，有必要像这样提供这些目录。

如果启动不带这些目录的 MongoDB 服务器，则可能会看到以下错误：

创建完这两个文件后，再次转到 mongodb 目录中的 bin 文件夹，然后打开其中的 shell。运行以下命令：

mongod

瞧！ 现在，我们的 MongoDB 服务器已启动并正在运行！？

为了使用此服务器，我们需要一个中介器。在 bind 文件夹中打开另一个命令窗口，然后运行以下命令：

mongo

运行此命令后，导航到运行 mongod 命令的外壳程序（这是我们的服务器）。你会在最后看到“接受连接”消息。这意味着我们的安装和配置成功！

只需在 mongo shell 中运行即可：

db

配置环境变量

为了节省时间，你可以设置环境变量。在 Windows 中，通过以下菜单完成：

Advanced System Settings -> Environment Variables -> Path(Under System Variables) -> Edit

只需复制我们的 bin 文件夹的路径，然后运行它。在我的这个示例里，是这样的：

C:\Program Files\MongoDB\Server\4.0\bin

现在你就完成设置了！

使用 MongoDB

大量的 GUI 图形用户界面（例如 MongoDB Compass，Studio 3T 等）可和 MongoDB  服务器一起使用。

它们提供了图形界面，因此你可以轻松地使用数据库并执行查询，而无需使用 Shell 并手动键入查询。

但是在本文中，我们将使用命令提示符来完成工作。

现在我们深入研究 MongoDB 命令，这些命令将帮助你在将来的项目中使用。

• 打开命令提示符，然后键入 mongod 以启动 MongoDB 服务器。
• 打开另一个外壳，然后键入 mongo 以连接到 MongoDB 数据库服务器。

1. 确定你目前在哪个数据库

db

此命令将显示你当前所在的数据库。test 是默认情况下的初始数据库。

2. 罗列数据库

show databases

我目前有四个数据库：CrudDB， admin， config 和 local。

3. 访问某个数据库

use <your_db_name>

在这里，我已移至 local 数据库。你可以使用命令 db 打印出当前数据库的名称，进行检查。

4. 创建一个数据库

使用 RDBMS（关系数据库管理系统），我们可以获得数据库、表、行和列。

但是，在 NoSQL 数据库（例如 MongoDB）中，数据以 BSON 格式（JSON 的二进制版本）存储。它们存储在称为“集合”的结构中。

在 SQL 数据库中，这些类似于表。

接下来，我们谈谈如何在 mongo shell 中创建数据库。

use <your_db_name>

等一下，我们之前有这个命令！ 为什么我再次使用它？

在 MongoDB 服务器中，如果你的数据库已经存在，则使用该命令将导航到你的数据库。

但是，如果数据库尚不存在，则 MongoDB 服务器将为你创建数据库。然后，它将导航到其中。

创建新数据库后，运行 show database 命令将不会显示你新创建的数据库。这是因为，当数据库包含一些数据（文档）后，它才会显示在你的数据库列表中。

5. 创建一个集合

使用 use 命令导航到新创建的数据库。

实际上，有两种创建集合的方法。

一种方法是将数据插入到集合中：

db.myCollection.insert({"name": "john", "age" : 22, "location": "colombo"})

即使该集合不存在，这也将创建你的集合 myCollection。然后它将插入带有 name 和 age 的文档。这些是无上限的集合。

第二种方法如下所示：

2.1 创建一个无上限的集合

db.createCollection("myCollection")

2.2 创建一个有上限的集合

db.createCollection("mySecondCollection", {capped : true, size : 2, max : 2})

这样，你将无需插入数据即可创建集合。

“有上限的集合”规定了最大的文档数，可防止文档溢出。在此示例中，我通过将其值设置为 true 启用上限。

size : 2 表示限制为 2MB，max: 2 将最大文档数设置为 2。

现在，如果你尝试在 mySecondCollection 中插入两个以上的文档，并使用 find  命令（我们将在稍后讨论），你只会看到最近插入的文档。请记住，这并不意味着第一个文档已被删除——它只是未显示。

6. 插入数据

我们可以将数据插入到新集合或之前创建的集合中。

有三种插入数据的方法：

• insertOne() 仅用于插入单个文档
• insertMany() 用于插入多个文档
• insert() 用于插入所需数量的文档

下面是一些示例：

• insertOne()

db.myCollection.insertOne(
  {
    "name": "navindu", 
    "age": 22
  }
)

• insertMany()

db.myCollection.insertMany([
  {
    "name": "navindu", 
    "age": 22
  },
  {
    "name": "kavindu", 
    "age": 20
  },

  {
    "name": "john doe", 
    "age": 25,
    "location": "colombo"
  }
])

insert() 方法类似于 insertMany() 方法。

另外，请注意，我们在文档中为 John Doe 插入了一个名为 location 的新属性。因此，如果你使用 find，则只会看到 john doe 具有 location 属性。

对于 NoSQL 数据库（例如 MongoDB），这可能是一个优势，有利于可扩展性。

7. 查询数据

你可以通过以下方法查询集合中的所有数据：

db.myCollection.find()

如果你想通过更清晰的方式查看此数据，只需在其末尾添加 .pretty() 即可。这将以漂亮的 JSON 格式显示文档。

db.myCollection.find().pretty()

等等，在这些示例中，你是否注意到了类似 _id 的东西？

无论何时插入文档，MongoDB 都会自动添加一个 _id 字段。该字段唯一地标识每个文档。如果你不想显示它，只需运行以下命令：

db.myCollection.find({}, _id: 0).pretty()

接下来，我们看一下过滤数据。

如果要显示某些特定文档，则可以指定要显示的文档的单个详细信息。

db.myCollection.find(
  {
    name: "john"
  }
)

假设你只想显示年龄在 25 岁以下的人。您可以使用 $lt 对此进行过滤。

db.myCollection.find(
  {
    age : {$lt : 25}
  }
)

同样，$gt 表示大于，$lte 表示“小于或等于”，$gte 表示“大于或等于”，$ne 是“不等于”。

8. 更新文档

假设你想更新某人的地址或年龄，该怎么做？ 请看下一个例子：

db.myCollection.update({age : 20}, {$set: {age: 23}})

第一个参数是要更新哪个文档的字段。在这里，我为简单起见指定了 age。在生产环境中，你可以使用 _id 字段。

最好使用 _id 之类的内容来更新特定的一行。 这是因为多个字段可以具有相同的年龄和名称。 因此，如果更新一行，它将影响具有相同名称和年龄的所有行。

如果你使用新属性（例如 location）更新文档，则文档将使用新属性进行更新。如果你执行 find，那么结果是：

如果你需要从单个文档中删除某个属性，则可以执行以下操作（假设你希望删除 age）：

db.myCollection.update({name: "navindu"}, {$unset: age});

9. 删除一个文档

如前所述，当你更新或删除文档时，你只需要指定 _id 即可，而不是 name，age，location。

db.myCollection.remove({name: "navindu"});

10. 删除一个集合

db.myCollection.remove({});

注意，这不等于 drop() 方法。不同之处在于 drop() 用于删除集合中的所有文档，而 remove() 方法用于删除集合本身以及所有文档。

逻辑运算符

MongoDB 提供逻辑运算符。下图总结了不同类型的逻辑运算符。

假设你要显示年龄小于 25 岁且位置在科伦坡的人，怎么做呢？

我们可以使用 $and 运算符！

db.myCollection.find({$and:[{age : {$lt : 25}}, {location: "colombo"}]});

最后，我们来谈谈聚合。

聚合

快速看一下我们了解到的有关 SQL 数据库中聚合函数的知识：

简而言之，聚合对多个文档中的值进行分组并以某种方式进行汇总。

想象一下，如果我们在 recordBook 集合中有男女学生，而我们希望每个学生都有总数。为了获得男生和女生的总和，我们可以使用 $group 聚合函数。

db.recordBook.aggregate([
  {
    $group : {_id : "$gender", result: {$sum: 1}}
  }  
]);

总结

我们讨论了 MongoDB 基础，将来构建应用程序时可能需要用到。希望你喜欢这篇文章。谢谢阅读！

如果你对此教程有任何疑问，请随时在下面的评论部分中进行评论，或者在 Facebook 或 Twitter 或 Instagram 上与我联系。

下篇再见！ ❤️✌

原文：How to get started with MongoDB in 10 minutes，作者：Navindu Jayatilake

连接（join）允许我们将分离的数据表重新构造成驱动应用程序的关系（relationship）。

本文将逐一查看 SQL 中的各种连接及其使用方式。

这里是我们将要讨论的内容：

• 什么是连接？
• 设置数据库
• 交叉连接
• 准备示例数据（导演和电影）
• 左连接与右连接
• 全外连接
• 内连接
• 使用左连接过滤数据
• 多表连接
• 带额外条件的连接
• 连接查询的现实

（剧透警告：我们将介绍五种不同类型的连接，但实际上你只需要知道其中两种！）

什么是连接

连接 是一种将两行结合成一行的操作。

这些行通常来自不同的表，但这并不绝对。

在我们着眼于如何写连接之前，我们先看一看连接的结果长啥样。

我们就以一个保存用户信息和他们的地址信息的系统为例吧。

保存用户信息的表里面的行可能长这个样子：

 id |     name     |        email        | age
----+--------------+---------------------+-----
  1 | John Smith   | johnsmith@gmail.com |  25
  2 | Jane Doe     | janedoe@Gmail.com   |  28
  3 | Xavier Wills | xavier@wills.io     |  3
...
(7 rows)

保存地址信息的表里面的行可能是这个样子：

 id |      street       |     city      | state | user_id
----+-------------------+---------------+-------+---------
  1 | 1234 Main Street  | Oklahoma City | OK    |       1
  2 | 4444 Broadway Ave | Oklahoma City | OK    |       2
  3 | 5678 Party Ln     | Tulsa         | OK    |       3
(3 rows)

我们可以写多个独立的查询，既检索用户信息，又检索地址信息。但是在理想情况下，我们可以写 一条查询，然后用同一个结果集（result set）接收所有的用户和他们的地址信息。

这正是连接让我们做的事情！

我们很快就会看到如何写这些连接，但如果我们连接用户信息表和地址信息表，就可以得到一个像这样的结果：

 id |     name     |        email        | age | id |      street       |     city      | state | user_id
----+--------------+---------------------+-----+----+-------------------+---------------+-------+---------
  1 | John Smith   | johnsmith@gmail.com |  25 |  1 | 1234 Main Street  | Oklahoma City | OK    |       1
  2 | Jane Doe     | janedoe@Gmail.com   |  28 |  2 | 4444 Broadway Ave | Oklahoma City | OK    |       2
  3 | Xavier Wills | xavier@wills.io     |  35 |  3 | 5678 Party Ln     | Tulsa         | OK    |       3
(3 rows)

在这里，我们可以在一个不错的结果集中看到用户和他们的地址。

除了产生组合结果集，连接的另一个重要用途就是为查询语句提供额外的信息，便于对结果集进行过滤。

例如，如果我们想给住在 Oklahoma 市的所有用户发送实体邮件，我们就可以使用这个连接在一起的结果集，然后根据 city 列进行过滤。

既然我们已经知道了连接的用途，那就开始写一些吧！

设置数据库

在写查询语句之前，我们需要先设置好数据库。

在这些示例中，我们将使用 PostgreSQL，但是这里展示的查询和概念可以很容易地被翻译到任何其它的现代数据库系统中（比如 MySQL、SQL Server，等等）。

我们可以使用 psql与 PostgreSQL 数据库一起工作，它是 PostgreSQL 的交互式命令行程序。如果你有其它的数据库客户端，你也可以用它们。

首先，创建我们的数据库。[安装]好 PostgreSQL 之后，在终端运行 createdb <database-name>命令，创建一个新的数据库。我管我的数据库叫 fcc：

$ createdb fcc

接下来使用命令 psql 启动一个交互式控制台，然后使用 \c <database-name> 连接到我们刚才创建的数据库：

$ psql
psql (11.5)
Type "help" for help.

john=# \c fcc
You are now connected to database "fcc" as user "john".
fcc=#

注意： 为了便于阅读，我已经去掉了这些示例中 psql 的输出，所以如果你的终端显示的内容和这里的不完全相同，也不必担心。

我鼓励你亲自动手跟着这些示例来一遍。如果你完成这些示例，你学到和记住的东西要比只阅读来的收获多得多。

现在看连接！

交叉连接

交叉连接（CROSS JOIN）是我们能做的最简单的连接，它又叫 笛卡尔乘积（Cartesian product）。

这种连接将一张表中的每一行与另一张表中的每一行逐一进行连接。

如果我们有两个列表——一个包含 1、2、3，另一个包含 A、B、C。这两个列表的笛卡尔乘积就是这样：

1A, 1B, 1C
2A, 2B, 2C
3A, 3B, 3C

第一个列表中的每一个值都与第二个列表中的每一个值进行了配对。

让我们把这个示例写成一条 SQL 查询。

我们先创建两个非常简单的表，再插入一些数据进去：

CREATE TABLE letters(
  letter TEXT
);

INSERT INTO letters(letter) VALUES ('A'), ('B'), ('C');

CREATE TABLE numbers(
  number TEXT
);

INSERT INTO numbers(number) VALUES (1), (2), (3);

我们的两个表（letters 和 numbers）都只有一列：一个简单的文本字段。

现在使用 CROSS JOIN 将它们连接在一起：

SELECT *
FROM letters
CROSS JOIN numbers;

 letter | number
--------+--------
 A      | 1
 A      | 2
 A      | 3
 B      | 1
 B      | 2
 B      | 3
 C      | 1
 C      | 2
 C      | 3
(9 rows)

这是我们能做的最简单的连接，但是即使是在这个简单的示例中，我们也能看见连接在起作用：分开的两行（一行来自 letter，一行来自 numbers）已经被 连接 成一行。

虽然这种连接通常只被当作学术范例进行讨论，但它至少有一个很好的用例：覆盖日期范围。

带日期范围的交叉连接

交叉连接的一个好用例就是从表中读取每一行，然后将其用于某个日期范围内的每一天。

例如你正在构建一个追踪每日任务的应用，如刷牙、吃早饭或洗澡。

如果你想为上周 每天 和 每个任务 都生成一条记录，你可以在某个日期范围上使用 CROSS JOIN。

我们可以使用 generate_series 函数产生这个日期范围：

SELECT generate_series(
  (CURRENT_DATE - INTERVAL '5 day'),
  CURRENT_DATE,
  INTERVAL '1 day'
)::DATE AS day;

generate_series 函数接收三个参数。

第一个参数是起始值，我们在示例中使用的是 CURRENT_DATE - INTERVAL '5 day'，它返回当前日期减去五天（五天前）的值。

第二个参数是当前日期（CURRENT_DATE）。

第三个参数是阶距（step interval），也就是值每次的增量大小。因为这些是日常任务，所以我们使用一天做为间隔（INTERVAL '1 day'）。

把这三个参数放在一起，就会生成一个日期序列：从五天前开始，到今天结束，每次前进一天。

最后，我们通过使用 ::DATE 将这些值的输出转为日期类型，去掉时间部分。我们还使用 AS day 为这一列设置了别名，让输出看起来更友好。

这个查询的输出就是过去五天加今天：

    day
------------
 2020-08-19
 2020-08-20
 2020-08-21
 2020-08-22
 2020-08-23
 2020-08-24
(6 rows)

回到我们的每日任务示例，一起创建一个存放我们想要完成的任务的简单表吧，然后插入几个任务：

CREATE TABLE tasks(
  name TEXT
);

INSERT INTO tasks(name) VALUES
('Brush teeth'),
('Eat breakfast'),
('Shower'),
('Get dressed');

task 表只有一列（name），我们往这个表中插入了四个任务。

现在让我们把任务和生成日期的查询交叉连接在一起吧：

SELECT
  tasks.name,
  dates.day
FROM tasks
CROSS JOIN
(
  SELECT generate_series(
    (CURRENT_DATE - INTERVAL '5 day'),
    CURRENT_DATE,
    INTERVAL '1 day'
  )::DATE    AS day
) AS dates

（因为我们生成日期的查询并不是一个真实的表，所以我们将它写成了子查询。）

这个查询返回了任务名和日期，结果集看起来像这样：

     name      |    day
---------------+------------
 Brush teeth   | 2020-08-19
 Brush teeth   | 2020-08-20
 Brush teeth   | 2020-08-21
 Brush teeth   | 2020-08-22
 Brush teeth   | 2020-08-23
 Brush teeth   | 2020-08-24
 Eat breakfast | 2020-08-19
 Eat breakfast | 2020-08-20
 Eat breakfast | 2020-08-21
 Eat breakfast | 2020-08-22
 ...
 (24 rows)

不出所料，日期范围内的每一天中的每一个任务都对应着一行。

CROSS JOIN 是我们能使用的最简单的连接。但是，为了查看接下来的几种类型的连接，我们需要设置更加真实的表。

准备示例数据（导演和电影）

为了展示接下来的几种连接类型，我们需要使用 电影 和 电影导演 这个例子。

在这种情况下，一部电影有一位导演，但是这不是 必需 的——想像一部新电影被宣布，但是它的导演还未确定。

我们的演员表（directors）将会保存每位演员的姓名，电影表（movie）将会保存每部电影的名字以及一个指向导演的引用（如果有的话）。

咱们先创建那两个表并插入一些数据吧：

CREATE TABLE directors(
  id SERIAL PRIMARY KEY,
  name TEXT NOT NULL
);

INSERT INTO directors(name) VALUES
('John Smith'),
('Jane Doe'),
('Xavier Wills'),
('Bev Scott'),
('Bree Jensen');

CREATE TABLE movies(
  id SERIAL PRIMARY KEY,
  name TEXT NOT NULL,
  director_id INTEGER REFERENCES directors 
);

INSERT INTO movies(name, director_id) VALUES
('Movie 1', 1),
('Movie 2', 1),
('Movie 3', 2),
('Movie 4', NULL),
('Movie 5', NULL);

我们有五位导演和五部电影，其中三部电影是有导演的。ID 为 1 的导演有两部电影，ID 为 2 的导演有一部电影。

全外连接

既然已经有了一些数据，我们就看看全外连接（FULL OUTER JOIN）吧。

FULL OUTER JOIN 与 CROSS JOIN 有些类似，但又有两个关键的区别。

第一个区别是 FULL OUTER JOIN 需要有一个 连接条件（join condition）。

连接条件声明了两张表的行与行之间是如何关联的，以及将它们连接在一起的条件。

在我们的示例中，movies 表通过 director_id 列引用演员，这一列与 directors 表的 id 列相匹配。我们将把这两列用作连接条件。

这是我们用来连接两张表的 SQL：

SELECT *
FROM movies
FULL OUTER JOIN directors
  ON directors.id = movies.director_id;

注意：我们将匹配电影和导演的连接连接声明为：ON movie.director_id = directors.id。

我们的结果集看起来就像一个奇怪的笛卡尔乘积：

  id  |  name   | director_id |  id  |     name
------+---------+-------------+------+--------------
    1 | Movie 1 |           1 |    1 | John Smith
    2 | Movie 2 |           1 |    1 | John Smith
    3 | Movie 3 |           2 |    2 | Jane Doe
    4 | Movie 4 |        NULL | NULL | NULL
    5 | Movie 5 |        NULL | NULL | NULL
 NULL | NULL    |        NULL |    5 | Bree Jensen
 NULL | NULL    |        NULL |    4 | Bev Scott
 NULL | NULL    |        NULL |    3 | Xavier Wills
(8 rows)

我们首先看到的是那些有导演的电影对应的行，这时连接条件的值为真。

然而，我们还能在这些行后面看到 每张表 中剩余的行，只是未匹配上的另一张表的对应值为 NULL。

**注意：**如果你不熟悉 NULL 值，可以从 SQL 运算符教程中查看我的解释。

我们还看到了 CROSS JOIN 与 FULL OUTER JOIN 的另一个区别：对于每张表，FULL OUTER JOIN 只会返回一行，而 CROSS JOIN 会返回多行。

内连接

下一种连接类型——内连接（INNER JOIN），是最常用的连接类型之一。

内连接 只返回连接条件为真的那些行。

在我们的示例中，movies 和 directors 表之间的内连接只会返回指派了导演的电影的记录。

语法与之前的基本一致：

SELECT *
FROM movies
INNER JOIN directors
  ON directors.id = movies.director_id;

我们的结果展示了有导演的那三部电影：

 id |  name   | director_id | id |    name
----+---------+-------------+----+------------
  1 | Movie 1 |           1 |  1 | John Smith
  2 | Movie 2 |           1 |  1 | John Smith
  3 | Movie 3 |           2 |  2 | Jane Doe
(3 rows)

由于内连接只包含满足连接条件的那些行，所以 连接两个表时，谁先谁后并不重要。

如果我们反转查询中表的顺序，我们还是会得到相同的结果：

SELECT *
FROM directors
INNER JOIN movies
  ON movies.director_id = directors.id;

 id |    name    | id |  name   | director_id
----+------------+----+---------+-------------
  1 | John Smith |  1 | Movie 1 |           1
  1 | John Smith |  2 | Movie 2 |           1
  2 | Jane Doe   |  3 | Movie 3 |           2
(3 rows)

在这个查询中，由于我们先列出了 directors 表并选取所有的列（SELECT *），所以我们会先看到 directors 表中的列，然后才是 movies 表中的列，但是得到的数据是一样的。

内连接的这个性质非常有用，但是它并不适用于所有的连接类型——比如接下来的这种类型。

左连接与右连接

接下来的两种连接类型用了一个修饰符（LEFT 或 RIGHT），它会决定哪个表的数据被包含到结果集中。

注意： LEFT JOIN 和 RIGHT JOIN 也可以被称为 LEFT OUTER JOIN 和 RIGHT OUTER JOIN。

这两种连接的使用场景是：我们想返回某个特定表中的所有数据，如果关联表中存在相应的数据，也将其返回。

如果关联的数据不存在，我们仍然可以得到“主表”的所有记录。

它是一个针对特定事物的信息和奖励信息（如果存在的话）的查询。

举个例子就好理解了。让我们找出所有的电影和它们的导演，但是我们不关心电影是否有导演——导演就是奖励：

SELECT *
FROM movies
LEFT JOIN directors
  ON directors.id = movies.director_id;

这个查询的形式与之前一样——我们只是将连接声明为了 LEFT JOIN。

在这个示例中，movies 表就是“左表”。

如果我们将查询写成一行，看起来会更容易一些：

... FROM movies LEFT JOIN directors ...

左连接返回“左表”中的所有记录。

左连接会返回“右表”中 满足连接条件 的所有记录。

“右表”中 不满足连接条件的记录会以 NULL 值返回。

 id |  name   | director_id |  id  |    name
----+---------+-------------+------+------------
  1 | Movie 1 |           1 |    1 | John Smith
  2 | Movie 2 |           1 |    1 | John Smith
  3 | Movie 3 |           2 |    2 | Jane Doe
  4 | Movie 4 |        NULL | NULL | NULL
  5 | Movie 5 |        NULL | NULL | NULL
(5 rows)

看着这个结果集，我们就能明白为何这种连接在 所有的这个和部分的那个（如果存在的话） 类型的连接中特别有用了。

右连接

除了调换了关于两表的要求外，右连接（RIGHT JOIN）的工作原理与 LEFT JOIN 一模一样。

在右连接中，“右表”中的所有行全部返回，而“左表”根据连接条件返回。

我们还是使用上面的那个查询，只不过这一次要将 LEFT JOIN 替换成 RIGHT JOIN：

SELECT *
FROM movies
RIGHT JOIN directors
  ON directors.id = movies.director_id;

  id  |  name   | director_id | id |     name
------+---------+-------------+----+--------------
    1 | Movie 1 |           1 |  1 | John Smith
    2 | Movie 2 |           1 |  1 | John Smith
    3 | Movie 3 |           2 |  2 | Jane Doe
 NULL | NULL    |        NULL |  5 | Bree Jensen
 NULL | NULL    |        NULL |  4 | Bev Scott
 NULL | NULL    |        NULL |  3 | Xavier Wills
(6 rows)

我们现在的结果集返回了 directors 表的所有行和 movies 数据（如果存在的话）。

我们所做的就是切换“主表”，“主表”就是不管数据存在与否，我们都想查看到所有数据的那个表。

生产应用程序中的左连接与右连接

在生产应用程序中，我只用过 LEFT JOIN，从未用过 RIGHT JOIN。

我这么做的原因是：我认为 LEFT JOIN 让查询更易于阅读和理解。

当我写查询语句时，我喜欢从“基础”结果集开始思考，比如所有的电影。然后在它的基础上引入（或去除）一些东西。

因为我喜欢从基础开始，而 LEFT JOIN 恰好满足了这种思路。我想要的是基础表（“左表”）中的所有行和“右表”中满足条件的行。

在实践中，我觉得我没有在生产应用中见过 RIGHT JOIN。RIGHT JOIN 并没有错，我只是认为它会让查询更难理解。

重写右连接

如果我们想翻转上面的场景，返回所有的导演和满足条件的电影，我们可以将 RIGHT JOIN 重写为 LEFT JOIN。

我们只需要翻转两个表在查询语句中的顺序，再把 RIGHT 改成 LEFT 即可：

SELECT *
FROM directors
LEFT JOIN movies
  ON movies.director_id = directors.id;

注意： 我喜欢将被连接的表（“右表”，即上面示例中的 movies）写在连接条件中的第一个（(ON movies.director_id = ...），不过这只是我的个人偏好。

使用左连接过滤数据

LEFT JOIN（或 RIGHT JOIN）有两个用例。

第一个用例我们已经讲了：返回一个表中的所有数据，以及另一个表中满足条件的数据。

第二个用例是 在第二个表中的数据不存在的情况下，返回第一个表中的所有行。

这个场景看起来像这样：找出 不属于任何电影 的导演。

为此，我们从 LEFT JOIN 开始，将 directors 作为主表或“左表”：

SELECT *
FROM directors
LEFT JOIN movies
  ON movies.director_id = directors.id;

对于那些不属于任何电影的导演来说，来自 movies 表的列都是 NULL：

 id |     name     |  id  |  name   | director_id
----+--------------+------+---------+-------------
  1 | John Smith   |    1 | Movie 1 |           1
  1 | John Smith   |    2 | Movie 2 |           1
  2 | Jane Doe     |    3 | Movie 3 |           2
  5 | Bree Jensen  | NULL | NULL    |        NULL
  4 | Bev Scott    | NULL | NULL    |        NULL
  3 | Xavier Wills | NULL | NULL    |        NULL
(6 rows)

在我们的示例中，ID 为 3、4 和 5 的导演不属于任何一部电影。

要从结果集中过滤出这些行，我们可以加一个 WHERE 子句，只返回电影数据为 NULL 的行：

SELECT *
FROM directors
LEFT JOIN movies
  ON movies.director_id = directors.id
WHERE movies.id IS NULL;

 id |     name     |  id  | name | director_id
----+--------------+------+------+-------------
  5 | Bree Jensen  | NULL | NULL |        NULL
  4 | Bev Scott    | NULL | NULL |        NULL
  3 | Xavier Wills | NULL | NULL |        NULL
(3 rows)

有三部电影没有导演！

使用表的 id 列进行过滤（WHERE movies.id IS NULL）是很普遍的。但是，因为 movies 表的所有列都是 NULL，所以使用其中任何一个都能达到目的。

（由于我们知道 movies 表中的所有列都会是 NULL，所以在上面的那个查询中，我们可以将 SELECT * 替换成 SELECT directors.*，从而只返回所有的导演信息）。

使用左连接查找匹配

在我们之前的查询中，我们找到了那些 不 属于任何电影的导演。

使用同样的结构，我们可以找到那些 肯定 属于电影的导演。只需要将 WHERE 条件改成寻找电影数据 不是 NULL 的电影数据即可：

SELECT *
FROM directors
LEFT JOIN movies
  ON movies.director_id = directors.id
WHERE movies.id IS NOT NULL;

 id |    name    | id |  name   | director_id
----+------------+----+---------+-------------
  1 | John Smith |  1 | Movie 1 |           1
  1 | John Smith |  2 | Movie 2 |           1
  2 | Jane Doe   |  3 | Movie 3 |           2
(3 rows)

这可能看起来很方便，但我们实际上只是在重新实现 INNER JOIN 而已。

多表连接

我们已经看到如何将两张表连接在一起了，但对于多表连接会怎么样呢？

实际上很简单，但是我们需要第三个表（tickets）来进行举例：

这个表将代表已经售出的电影票：

CREATE TABLE tickets(
  id SERIAL PRIMARY KEY,
  movie_id INTEGER REFERENCES movies NOT NULL
);

INSERT INTO tickets(movie_id) VALUES (1), (1), (3);

tickets 表只有一个 id 和一个电影的引用：movie_id。

我们也为 ID 为 1 的电影插入了两张票，为 ID 为 3 的电影插入了一张票。

现在，让我们连接 directors 和 movies，然后再连接 movies 和 tickets！

SELECT *
FROM directors
INNER JOIN movies
  ON movies.director_id = directors.id
INNER JOIN tickets
  ON tickets.movie_id = movies.id;

因为这些是内连接，所以连接的顺序并不重要。我们可以从 tickets 开始，连接 movies，再连接 directors。

它的顺序也取决于你想要查询的什么以及什么让查询最易于理解。

在结果集中，我们将会注意到返回行的范围已经被进一步缩小了：

 id |    name    | id |  name   | director_id | id | movie_id
----+------------+----+---------+-------------+----+----------
  1 | John Smith |  1 | Movie 1 |           1 |  1 |        1
  1 | John Smith |  1 | Movie 1 |           1 |  2 |        1
  2 | Jane Doe   |  3 | Movie 3 |           2 |  3 |        3
(3 rows)

这是因为我们加了另一个 INNER JOIN，实际上它给我们的查询添加了另一个 AND 条件。

我们的查询本质上是在说：“返回所有属于电影的导演，这些电影 也有 电影票售出”。

如果我们想找出属于 可能还没有电影票售出 的电影的导演，我们可以将最后一个 INNER JOIN 替换成 LEFT JOIN：

SELECT *
FROM directors
JOIN movies
  ON movies.director_id = directors.id
LEFT JOIN tickets
  ON tickets.movie_id = movies.id;

我们可以看到 Movie 2 现在又回到结果集中来了：

 id |    name    | id |  name   | director_id |  id  | movie_id
----+------------+----+---------+-------------+------+----------
  1 | John Smith |  1 | Movie 1 |           1 |    1 |        1
  1 | John Smith |  1 | Movie 1 |           1 |    2 |        1
  2 | Jane Doe   |  3 | Movie 3 |           2 |    3 |        3
  1 | John Smith |  2 | Movie 2 |           1 | NULL |     NULL
(4 rows)

这部电影一张票也没有卖出去，所以它因 INNER JOIN 被之前的结果集中排除掉了。

我将 给读者留一个练习，你如何能找出那些属于一张票也 没有 卖出去的电影的导演呢？

连接的执行顺序

最后，我们并不关心连接是以何种顺序执行的。

SQL 和其它现代编程语言之间的一个关键区别就是 SQL 是一门 声明式 语言。

这意味着我们声明期望的结果，但并不声明执行细节——这些细节留给了给数据库查询规划器（database query planner）。我们只管声明我们想要的连接和条件，查询规划器会处理剩余部分。

但是，现实中的数据库并不会同时连接三张表。相反，它会先连接前两张表得到一个中间结果，然后把这个中间结果集与第三张表连接。

（注意： 这个解释有点简单。）

因此，当我们在查询中遇到多表连接时，我们可以将它们看成一连串的两表连接——尽管其中的一个表会变得非常大。

带额外条件的连接

我们将要介绍的最后一个主题是带额外条件的连接。

和 WHERE 字句类似，我们可以添加任意多的条件到连接中。

例如，如果我们想找出电影和导演的信息，但导演的 名字 不能是 “John Smith”。我们可以用 AND 添加一个额外的条件到我们的连接中：

SELECT *
FROM movies
INNER JOIN directors
  ON directors.id = movies.director_id
  AND directors.name <> 'John Smith';

我们可以在这个连接条件中使用任何放在 WHERE 子句中的运算符。

如果我们将条件放到 WHERE 子句中，也能得到同样的结果：

SELECT *
FROM movies
INNER JOIN directors
  ON directors.id = movies.director_id
WHERE directors.name <> 'John Smith';

这里背后发生的事情有一些细微的差异，但是就本文而言，结果集是一样的。

（如果你不太熟悉过滤 SQL 查询的所有方式，你可以在这里查看之前提到的文章。）

现实中的连接查询

事实上，我发现我自己只通过三种方式使用连接：

内连接

第一个用例是两表之间的关系 肯定 存在的记录，通过 INNER JOIN 实现。

条件如查找 “具有导演的电影” 或 “具有帖子的用户”。

左连接

第二个用例是来自一个表的记录，以及关系存在时来自第二个表的记录，通过 LEFT JOIN 实现。

条件如 “具有导演的电影（如果有的话）” 或 “具有文章的用户（如果有的话）”。

左连接排除数据

第三个常见的用例是 LEFT JOIN 的第二个用例：查找一个表中的记录，但这些记录在另一个表中 没有 关系。

条件如 “没有导演的电影” 或 “没有文章的用户”。

两种非常有用的连接类型

我认为我不曾在生产应用中用过 FULL OUTER JOIN 或 RIGHT JOIN，相关用例要么很少，要么查询可以被写成更加清晰的形式（RIGHT JOIN 的情况）。

我偶尔会为一些东西使用 CROSS JOIN，比如分散在某个时间范围内的记录（像我们一开始看到的那样），但是那种场景也不多。

所以，好消息来了！对于你将遇到的 99.9% 的用例，只需要理解 INNER JOIN 和 LEFT JOIN 这两种类型的连接就可以解决了。

如果你喜欢这篇文章，可以在 twitter 上关注我，我在那里谈论数据库和所有其它开发相关的话题。

感谢阅读！

John

P.S. 文末小技巧：大多数数据库系统允许你用 JOIN 代替 INNER JOIN——可以让你少打几个字。:)

原文：SQL Joins Tutorial: Cross Join, Full Outer Join, Inner Join, Left Join, and Right Join，作者：John Mosesman