在 SQL 数据库中，重复数据可能是一个大问题，因为它们会降低查询性能并浪费宝贵的存储空间。

幸运的是，用 SQL 有几种方法删除重复数据。

在本文中，我们将探讨用 SQL 删除重复数据的一些最有效的方法，包括使用 DISTINCT 关键字、GROUP BY 子句和 INNER JOIN 语句。

如何在 SQL 中使用 DISTINCT 关键字删除重复数据

在 SQL 中删除重复数据的最简单方法之一是使用 DISTINCT 关键字。您可以在 SELECT 语句中使用 DISTINCT 关键字，只从特定列中检索唯一值。

下面是一个如何使用 DISTINCT 关键字删除表中重复数据的示例：

SELECT DISTINCT column_name
FROM table_name;

例如，如果我们有一个名为 “customers” 的表，其中有 “customer_id” 和 “customer_name” 列，我们可以使用下面的 SQL 查询删除 “customer_name” 列中的重复内容：

SELECT DISTINCT customer_name
FROM customers;

如何使用 SQL GROUP BY 子句删除重复数据

用 SQL 删除重复数据的另一种方法是使用 GROUP BY 子句。GROUP BY 子句根据特定列中的值对记录进行分组，每个唯一值只返回一条记录。

下面是一个如何使用 GROUP BY 子句删除表中重复数据的示例：

SELECT column_name
FROM table_name
GROUP BY column_name;

例如，如果我们有一个名为 “orders” 的表，其中有 “order_id”、“customer_id” 和 “order_date” 列，我们可以使用下面的 SQL 查询删除 “customer_id” 列中的重复内容：

SELECT customer_id
FROM orders
GROUP BY customer_id;

如何使用 SQL INNER JOIN 语句删除重复数据

在 SQL 中删除重复数据的另一种方法是使用 INNER JOIN 语句。INNER JOIN 语句根据两个或多个表之间的相关列，将它们的记录合并在一起。通过将表与表本身连接，我们可以比较行并删除重复数据。

下面是一个如何使用 INNER JOIN 语句从表中删除重复数据的示例：

SELECT a.column_name
FROM table_name a
INNER JOIN table_name b ON a.column_name = b.column_name
WHERE a.primary_key > b.primary_key;

例如，如果我们有一个名为 “employees” 的表，其中有 “employee_id”、“employee_name” 和 “department_id” 列，我们可以使用下面的 SQL 查询删除 “department_id” 列中的重复内容：

SELECT a.department_id
FROM employees a
INNER JOIN employees b ON a.department_id = b.department_id
WHERE a.employee_id > b.employee_id;

小结

用 SQL 删除重复数据有助于提升查询性能和节省存储空间。

通过使用 DISTINCT 关键字、GROUP BY 子句和 INNER JOIN 语句，我们可以删除 SQL 表中的重复数据。

请记住，在修改数据前一定要备份数据，以避免任何可能的数据丢失。

欢迎你在 Twitter 和 LinkedIn 联系我。

在 SQL 中，你可以进行数据库查询，并使用 COUNT 函数来获取表中某一组的行数。

在这篇文章中，我将通过一些代码实例向你展示如何使用 COUNT 函数。

SQL 中的 COUNT 函数是什么

这个 SQL 函数将返回给定组的行数的计数。

下面是基本语法：

SELECT COUNT(column_name) FROM table_name;

SQL 中的 SELECT 语句告诉计算机要从表中获取数据。

COUNT(column_name) 将不把 NULL 值作为计数的一部分。

SQL 中的 NULL 值指的是表中不存在的值。

有时你可以在 COUNT 函数括号内使用 *。

SELECT COUNT(*) FROM table_name;

COUNT(*) 函数将返回该组项目的总数，包括 NULL 值。

SQL 中的 FROM 子句指定了我们要列出哪个表。

你也可以在 COUNT 函数中使用 ALL 关键字。

SELECT COUNT(ALL column_name) FROM table_name;

ALL 关键字将计算表中的所有数值，包括重复的。你可以省略这个关键字，因为无论你是否写入，COUNT 函数都将 ALL 关键字作为默认值。

有时你会看到 DISTINCT 关键字与 COUNT 函数一起使用。

SELECT COUNT(DISTINCT column_name) FROM table_name;

DISTINCT 关键字将只计算 NOT NULL 的唯一值。计算机将忽略任何重复的值。

如何在 SQL 中使用 COUNT 函数

在这个例子中，我们有一个 campers 的表，有 id、name、age 和 counselor 这几列。

如果我们想选择表中的所有行，那么我们可以使用以下语法：

SELECT COUNT(*) FROM campers;

正如你所看到的，该查询返回的数字是 12，代表了我们的表中的总行数。

使用 WHERE 子句

我们可以使用 WHERE 子句来指定某个特定营地辅导员的名字的行数。

在这个例子中，我们想通过 Ashley 这个名字来计算营地辅导员的行数。

在 WHERE 子句中，我们需要指定 counselor 的值为 "Ashley"。

 WHERE counselor="Ashley";

这是完整的代码：

SELECT COUNT(*) FROM campers WHERE counselor="Ashley";

这是结果会返回的内容：

如果我们看一下前面的表格，可以看到，"Ashley" 只出现了 4 次。

我们可以修改我们的结果，计算 11 岁的营员有多行。

在 WHERE 子句中，我们需要指定 age 为 11。

WHERE age=11;

这是完整的代码：

SELECT COUNT(*) FROM campers WHERE age=11;

这是结果会返回的内容：

如果我们看一下刚才的表格，可以看到只有三个 11 岁的露营者。

如何使用 GROUP BY 子句

我们可以使用 GROUP BY 子句和 COUNT 函数来查看表中 11、12 和 13 岁的营员人数。

我们首先要选择 age 列并使用 COUNT 函数：

SELECT age, COUNT(*)

然后我们要指定 campers 并按 age 对结果进行分组：

FROM campers GROUP BY age;

这就是代码的全部内容：

SELECT age, COUNT(*) FROM campers GROUP BY age;

结果是这样的：

如何使用 ORDER BY 子句

我们可以修改年龄列表的例子，使用 ORDER BY 子句，将结果从小到大排列出来。

这就是 ORDER BY 子句的代码：

ORDER BY COUNT(*);

我们在 SELECT 语句的末尾添加该子句，像这样：

SELECT age, COUNT(*) FROM campers GROUP BY age ORDER BY COUNT(*);

这就是修改后的例子的样子：

如果我们希望计数结果从大到小排序，那么我们可以使用 DESC 关键字。

这就是使用 DESC 关键字的 ORDER BY 子句的代码：

ORDER BY COUNT(*) DESC;

这是完整的代码：

SELECT age, COUNT(*) FROM campers GROUP BY age ORDER BY COUNT(*) DESC;

这是新的结果：

如何使用 HAVING 子句

我们可以使用 HAVING 子句来为 COUNT 函数指定一个条件。

我们可以修改代码，只显示计数小于 5 的年龄段的结果。

这就是 HAVING 子句的代码：

HAVING COUNT(*)<5;

这就是完整代码：

SELECT age, COUNT(*) FROM campers GROUP BY age HAVING COUNT(*)<5;

这就是修改后的结果：

我们可以看到，12 岁的人被从这个结果中删除，因为计数大于 5。

总结

在 SQL 中，你可以做一个数据库查询，并使用 COUNT 函数来获取表中某个特定组的行数。

下面是基本的语法：

SELECT COUNT(column_name) FROM table_name;

COUNT(column_name) 将不把 NULL 值作为计数的一部分。

SQL 中的 NULL 值是指表中不存在的值。

有时，你可以在 COUNT 函数的括号内使用 *。

SELECT COUNT(*) FROM table_name;

COUNT(*) 函数将返回该组中项目的总数，包括 NULL 值。

我希望你喜欢这篇文章，并祝你在 SQL 之旅中好运。

SQL 注入是指你通过客户端向应用程序输入数据来插入或注入一个 SQL 查询。

成功的攻击使攻击者能够访问数据库中的敏感数据，修改数据库数据，可能关闭数据库或发出其他管理员命令，恢复文件内容，以及偶尔向操作系统发出命令。

这种类型的攻击相对容易检测和利用，因此迅速修复任何易受攻击的系统尤为重要。

SQL 注入如何工作

当数据从不可信任的来源进入程序，并被用于动态构建 SQL 查询时，就会发生 SQL 注入。

因为 SQL 无法区分控制平面和数据平面，攻击者可以在数据输入中插入元字符（一种不被解释为数据的字符，例如下划线 _，在 SQL 中，它会被解释为单个字符的通配符），然后在控制平面中输入 SQL 命令。

例如，在下面的漫画中，如果字符串 Robert'); DROP TABLE Students;–- 被输入到一个请求 studentName 的查询中，那么查询将变为以下内容：

AND studentName = 'Robert';
DROP TABLE Students;
--'

DROP TABLE 命令用于删除一个表及其所有行数据，而一对连字符（hyphens）告诉大多数数据库服务器，该语句的剩余部分应被视为注释（这使得服务器可以忽略修改后的查询中留下的尾部）。

https://xkcd.com/327/

许多数据库服务器允许一次执行多个查询，只要它们用分号隔开。如果允许这样做，这种攻击类型就允许攻击者对数据库执行多个命令（有些数据库服务器，包括 Oracle，不允许这种执行方式）。

防止 SQL 注入实际上相当简单 - 要么不允许动态查询，要么阻止包含恶意 SQL 的用户输入影响查询逻辑。

其他类型的 SQL 注入

还有一些其他类型的 SQL 注入需要注意：

基于错误的 SQL 注入

攻击者依赖于数据库的详细错误信息来了解数据库结构。为了防止这种情况，只应显示通用错误信息。

盲注 SQL 注入

当应用程序容易受到 SQL 注入攻击时，但只显示通用错误信息（而不是详细的错误信息或查询结果）。

一种访问信息的方法是使用 true/false 查询并一次提取一个问题的信息。另一种选择是发送一个命令，要求数据库在返回响应之前等待特定的时间。

根据数据库返回错误信息所需的时间长短，攻击者可以推断命令是返回 true 还是 false。

UNION SQL 注入

利用 UNION 操作符从数据库中的多个表中检索数据。

带外 SQL 注入

相对罕见，但当攻击者无法在提交命令的同一通道中接收到响应时会发生。

相反，它依赖于服务器使用另一种协议（如 HTTP 或 DNS）来向攻击者的查询传递响应的能力。

如何防止 SQL 注入攻击

预处理语句（带参数化查询）

参数化查询要求开发者定义所有 SQL 代码并稍后将每个参数传递给查询。然后，数据库可以区分代码和数据，而不受用户输入的影响。

例如，如果攻击者输入名字 Robert'); DROP TABLE Students;–- ，参数化查询将不再容易受到攻击，而是寻找一个与整个字符串 Robert'); DROP TABLE Students;–- 完全匹配的名字。

预处理语句的优点是 SQL 代码保留在应用程序内，使其（大部分）独立于数据库。

在极少数情况下，这可能会影响性能。如果确实如此，开发者需要验证所有数据，或者使用针对数据库的转义程序转义所有用户提供的输入。

存储过程

存储过程是带参数的预创建 SQL 语句，不包括任何动态 SQL 生成（可以做，但不应该做）。为了设置存储过程，开发者需要为所需的输入构建带参数的 SQL 语句。

存储过程和预处理语句之间的区别在于，存储过程是在数据库中定义和存储的，但是从应用程序中调用的。

此外，由于存储过程在某些 DBMS 中需要执行权限（默认情况下不可用），因此创建一个具有最少权限的单独帐户而不是授予所有者访问权限非常重要。

白名单输入验证

白名单输入验证将外部输入与一组已知的、批准的输入进行比较，对于不匹配的输入将失败。这只应用于不允许绑定变量的情况（SQL 语句中实际值的占位符）。

白名单输入验证还可以作为在将输入传递给查询之前检测输入的备选方案。

转义所有用户提供的输入

只有在前面的选项不可行时，才应使用此方法，因为它无法防止所有 SQL 注入。仅对无法重写以使用前面推荐方法的遗留代码使用它。遗憾的是，这是一个非常针对特定数据库的实现。

每个 DBMS 都支持字符转义方案。如果使用正确的方案转义所有用户输入，DBMS 将能够区分输入和开发者编写的 SQL 代码。

最小权限

最小权限不是防御 SQL 注入的手段，而是一种限制任何攻击可能造成的损害的方法。

确保应用程序帐户只拥有所需的权限，而不是更多，可能会令人沮丧（给予它们 DBA 或管理员权限肯定更容易，但会提供更多的攻击面）。

与其剥夺帐户的访问权限，不如从头开始，只授予确切需要的访问权限。

例如，如果一个帐户只需要只读访问权限，请确保它只对所需的表（甚至是表的一部分）具有只读访问权限。如果可以的话，避免授予数据库帐户创建或删除访问权限。每个用户/应用程序应该有一个单独的帐户。

此外，审查数据库管理系统（DBMS）运行所在的操作系统帐户的权限。默认情况下，许多帐户具有非常强大的权限 - 将其更改为更合适的权限。

来源/进一步阅读

• OWASP SQL Injection
• PortSwigger SQL Injection
• Netsparker SQL Injection

SQL 是 Structured Query Language（结构化查询语言）的缩写。SQL 命令是用于与数据库通信的指令，以执行任务、功能和对数据的查询。

SQL 命令可用于搜索数据库和执行其他功能，如创建表、向表添加数据、修改数据和删除表。

下面是一个基本的 SQL 命令（有时称为子句）的列表，如果你要使用 SQL，你应该知道这些命令。

SELECT 和 FROM

查询的 SELECT 部分决定了在结果中显示哪些列的数据。还有一些选项，你可以应用来显示不是表列的数据。

下面的例子显示了从 “student” 表中选取的三列和一个计算列。数据库存储了学生的 studentID、FirstName 和 LastName。我们可以结合 First 和 Last name 列来创建 FullName 计算列。

SELECT studentID, FirstName, LastName, FirstName + ' ' + LastName AS FullName
FROM student;

+-----------+-------------------+------------+------------------------+
| studentID | FirstName         | LastName   | FullName               |
+-----------+-------------------+------------+------------------------+
|         1 | Monique           | Davis      | Monique Davis          |
|         2 | Teri              | Gutierrez  | Teri Gutierrez         |
|         3 | Spencer           | Pautier    | Spencer Pautier        |
|         4 | Louis             | Ramsey     | Louis Ramsey           |
|         5 | Alvin             | Greene     | Alvin Greene           |
|         6 | Sophie            | Freeman    | Sophie Freeman         |
|         7 | Edgar Frank "Ted" | Codd       | Edgar Frank "Ted" Codd |
|         8 | Donald D.         | Chamberlin | Donald D. Chamberlin   |
|         9 | Raymond F.        | Boyce      | Raymond F. Boyce       |
+-----------+-------------------+------------+------------------------+
9 rows in set (0.00 sec)

CREATE TABLE

CREATE TABLE 就像它听起来那样：它在数据库中创建一个表。你可以指定表的名称和应该在表中出现的列。

CREATE TABLE table_name (
    column_1 datatype,
    column_2 datatype,
    column_3 datatype
);

ALTER TABLE

ALTER TABLE 改变一个表的结构。下面是你如何在数据库中增加一个列：

ALTER TABLE table_name
ADD column_name datatype;

CHECK

CHECK 约束是用来限制可以放在一列中的数值范围。

如果你在一个单列上定义 CHECK 约束，对于这个列它只允许某些值。如果你在一个表上定义一个 CHECK 约束，它可以根据行中其他列的值来限制某些列的值。

下面的 SQL 语句在创建 “Persons” 表时在 “Age” 列上创建了一个 CHECK 约束。这个 CHECK 约束确保不能有任何低于 18 岁的人。

CREATE TABLE Persons (
    ID int NOT NULL,
    LastName varchar(255) NOT NULL,
    FirstName varchar(255),
    Age int,
    CHECK (Age>=18)
);

为了允许 CHECK 约束的命名，以及在多个列上定义 CHECK 约束，请使用以下 SQL 语法：

CREATE TABLE Persons (
    ID int NOT NULL,
    LastName varchar(255) NOT NULL,
    FirstName varchar(255),
    Age int,
    City varchar(255),
    CONSTRAINT CHK_Person CHECK (Age>=18 AND City='Sandnes')
);

WHERE

（AND、OR、IN、BETWEEN 和 LIKE）

WHERE 子句是用来限制返回的行数的。

作为一个例子，首先我们将向你展示一个没有 WHERE 语句的 SELECT 语句和结果。然后我们将添加一个使用上述所有五个限定词的 WHERE 语句。

SELECT studentID, FullName, sat_score, rcd_updated FROM student;

+-----------+------------------------+-----------+---------------------+
| studentID | FullName               | sat_score | rcd_updated         |
+-----------+------------------------+-----------+---------------------+
|         1 | Monique Davis          |       400 | 2017-08-16 15:34:50 |
|         2 | Teri Gutierrez         |       800 | 2017-08-16 15:34:50 |
|         3 | Spencer Pautier        |      1000 | 2017-08-16 15:34:50 |
|         4 | Louis Ramsey           |      1200 | 2017-08-16 15:34:50 |
|         5 | Alvin Greene           |      1200 | 2017-08-16 15:34:50 |
|         6 | Sophie Freeman         |      1200 | 2017-08-16 15:34:50 |
|         7 | Edgar Frank "Ted" Codd |      2400 | 2017-08-16 15:35:33 |
|         8 | Donald D. Chamberlin   |      2400 | 2017-08-16 15:35:33 |
|         9 | Raymond F. Boyce       |      2400 | 2017-08-16 15:35:33 |
+-----------+------------------------+-----------+---------------------+
9 rows in set (0.00 sec)

现在，我们将重复 SELECT 查询，但我们将使用 WHERE 语句限制返回的行。

STUDENT studentID, FullName, sat_score, recordUpdated
FROM student
WHERE (studentID BETWEEN 1 AND 5 OR studentID = 8)
        AND
        sat_score NOT IN (1000, 1400);

+-----------+----------------------+-----------+---------------------+
| studentID | FullName             | sat_score | rcd_updated         |
+-----------+----------------------+-----------+---------------------+
|         1 | Monique Davis        |       400 | 2017-08-16 15:34:50 |
|         2 | Teri Gutierrez       |       800 | 2017-08-16 15:34:50 |
|         4 | Louis Ramsey         |      1200 | 2017-08-16 15:34:50 |
|         5 | Alvin Greene         |      1200 | 2017-08-16 15:34:50 |
|         8 | Donald D. Chamberlin |      2400 | 2017-08-16 15:35:33 |
+-----------+----------------------+-----------+---------------------+
5 rows in set (0.00 sec)

UPDATE

要更新一个表中的记录，你需要使用 UPDATE 语句。

使用 WHERE 条件来指定你要更新的记录，可以一次更新一个或多个列，语法是：

UPDATE table_name
SET column1 = value1, 
    column2 = value2, ...
WHERE condition;

下面的例子更新 Id 为 4 的记录的名称：

UPDATE Person
SET Name = “Elton John”
WHERE Id = 4;

你也可以通过使用其他表的值来更新表中的列。使用 JOIN 子句可以从多个表中获取数据，语法是：

UPDATE table_name1
SET table_name1.column1 = table_name2.columnA
    table_name1.column2 = table_name2.columnB
FROM table_name1
JOIN table_name2 ON table_name1.ForeignKey = table_name2.Key

下面的例子是更新所有记录的经理：

UPDATE Person
SET Person.Manager = Department.Manager
FROM Person
JOIN Department ON Person.DepartmentID = Department.ID

GROUP BY

GROUP BY 允许你合并行和汇总数据。

下面是 GROUP BY 的语法：

SELECT column_name, COUNT(*)
FROM table_name
GROUP BY column_name;

HAVING

HAVING 允许你过滤由 GROUP BY 子句聚合的数据，这样用户就可以得到有限的记录集来查看。

这是 HAVING 的语法：

SELECT column_name, COUNT(*)
FROM table_name
GROUP BY column_name
HAVING COUNT(*) > value;

AVG()

“Average” 用于计算由 SQL 语句返回的多行中的数字列的平均值。

下面是该函数的语法：

SELECT groupingField, AVG(num_field)
FROM table1
GROUP BY groupingField

下面是一个使用学生表的例子：

SELECT studentID, FullName, AVG(sat_score) 
FROM student 
GROUP BY studentID, FullName;

AS

AS 允许你使用别名重新命名一个列或表。

SELECT user_only_num1 AS AgeOfServer, (user_only_num1 - warranty_period) AS NonWarrantyPeriod FROM server_table

输出结果如下：

+-------------+------------------------+
| AgeOfServer | NonWarrantyPeriod      | 
+-------------+------------------------+
|         36  |                     24 |
|         24  |                     12 | 
|         61  |                     49 |
|         12  |                      0 | 
|          6  |                     -6 |
|          0  |                    -12 | 
|         36  |                     24 |
|         36  |                     24 | 
|         24  |                     12 | 
+-------------+------------------------+

你也可以使用 AS 为表指定一个名称，使其在连接中更容易引用。

SELECT ord.product, ord.ord_number, ord.price, cust.cust_name, cust.cust_number FROM customer_table AS cust

JOIN order_table AS ord ON cust.cust_number = ord.cust_number

输出结果如下：

+-------------+------------+-----------+-----------------+--------------+
| product     | ord_number | price     | cust_name       | cust_number  |
+-------------+------------+-----------+-----------------+--------------+
|     RAM     |   12345    |       124 | John Smith      |  20          |
|     CPU     |   12346    |       212 | Mia X           |  22          |
|     USB     |   12347    |        49 | Elise Beth      |  21          |
|     Cable   |   12348    |         0 | Paul Fort       |  19          |
|     Mouse   |   12349    |        66 | Nats Back       |  15          |
|     Laptop  |   12350    |       612 | Mel S           |  36          |
|     Keyboard|   12351    |        24 | George Z        |  95          |
|     Keyboard|   12352    |        24 | Ally B          |  55          |
|     Air     |   12353    |        12 | Maria Trust     |  11          |
+-------------+------------+-----------+-----------------+--------------+

ORDER BY

ORDER BY 为我们提供了一种方法，通过 SELECT 部分中的一个或多个项目对结果集进行排序。下面是一个按 FullName 对学生进行降序排序的 SQL。默认的排序顺序是升序（ASC），但如果要以相反的顺序（降序）排序，你可以使用 DESC。

SELECT studentID, FullName, sat_score
FROM student
ORDER BY FullName DESC;

COUNT

COUNT 将计算行数，并在结果集中以列的形式返回该计数。

下面是使用 COUNT 的例子：

• 计算一个表中的所有行数（不需要分组）
• 计算数据子集的总数（需要在语句中加入 Group By 部分）

这个 SQL 语句提供了一个所有行的计数。注意，你可以用 AS 给产生的 COUNT 列一个名称。

SELECT count(*) AS studentCount FROM student; 

DELETE

DELETE 是用来删除一个表中的记录。

请注意，你可以删除该表的所有记录，也可以只删除几条。使用 WHERE 条件来指定你要删除哪些记录，语法是：

DELETE FROM table_name
WHERE condition;

下面是一个从表 Person 中删除 Id 为 3 的记录的例子：

DELETE FROM Person
WHERE Id = 3;

INNER JOIN

JOIN，也叫 Inner Join，在两个表中选择具有匹配值的记录。

SELECT * FROM A x JOIN B y ON y.aId = x.Id

LEFT JOIN

LEFT JOIN 返回左表的所有记录，以及右表的匹配记录。即使右表中没有匹配的记录，左表中的记录也会被返回。左表中的行如果在右表中没有匹配，那么右表的值将为 null。

SELECT * FROM A x LEFT JOIN B y ON y.aId = x.Id

RIGHT JOIN

RIGHT JOIN 返回右表的所有记录，以及左表的匹配记录。与 LEFT JOIN 相反，这将返回右表的所有记录，即使在左表中没有匹配的记录。右表中的行如果在左表中没有匹配，那么左表的列就会有 null。

SELECT * FROM A x RIGHT JOIN B y ON y.aId = x.Id

FULL OUTER JOIN

FULL OUTER JOIN 返回所有在其中一个表中有匹配的记录。因此，如果左表中有一些记录在右表中没有匹配，这些记录将被包括在内。同时，如果右表中有一些记录在左表中没有匹配，这些记录也会被包括在内。

SELECT Customers.CustomerName, Orders.OrderID
FROM Customers
FULL OUTER JOIN Orders
ON Customers.CustomerID=Orders.CustomerID
ORDER BY Customers.CustomerName

INSERT

INSERT 是一种向表中插入数据的方法。

INSERT INTO table_name (column_1, column_2, column_3) 
VALUES (value_1, 'value_2', value_3);

LIKE

LIKE 在 WHERE 或 HAVING 中使用（作为 GROUP BY 的一部分），在包含某种模式的字符的列中选出行。

这个 SQL 语句将选择 FullName 以 “Monique” 开始或以 “Greene” 结束的学生。

SELECT studentID, FullName, sat_score, rcd_updated
FROM student 
WHERE 
    FullName LIKE 'Monique%' OR 
    FullName LIKE '%Greene'; 

+-----------+---------------+-----------+---------------------+
| studentID | FullName      | sat_score | rcd_updated         |
+-----------+---------------+-----------+---------------------+
|         1 | Monique Davis |       400 | 2017-08-16 15:34:50 |
|         5 | Alvin Greene  |      1200 | 2017-08-16 15:34:50 |
+-----------+---------------+-----------+---------------------+
2 rows in set (0.00 sec)

你可以在 LIKE 之前放置 NOT，以排除具有字符串模式的记录，而不是选择它们。这个 SQL 语句排除了 FullName 列中包含 “cer Pau” 和 “Ted” 的记录。

SELECT studentID, FullName, sat_score, rcd_updated
FROM student 
WHERE FullName NOT LIKE '%cer Pau%' AND FullName NOT LIKE '%"Ted"%';

+-----------+----------------------+-----------+---------------------+
| studentID | FullName             | sat_score | rcd_updated         |
+-----------+----------------------+-----------+---------------------+
|         1 | Monique Davis        |       400 | 2017-08-16 15:34:50 |
|         2 | Teri Gutierrez       |       800 | 2017-08-16 15:34:50 |
|         4 | Louis Ramsey         |      1200 | 2017-08-16 15:34:50 |
|         5 | Alvin Greene         |      1200 | 2017-08-16 15:34:50 |
|         6 | Sophie Freeman       |      1200 | 2017-08-16 15:34:50 |
|         8 | Donald D. Chamberlin |      2400 | 2017-08-16 15:35:33 |
|         9 | Raymond F. Boyce     |      2400 | 2017-08-16 15:35:33 |
+-----------+----------------------+-----------+---------------------+
7 rows in set (0.00 sec)

当你在使用数据库时，可能需要把几个不同的表的数据放在一起。这篇文章将告诉你如何做。

我已经写了两篇关于 SQL 连接的文章，第一篇和第二篇，但让我们花点时间先回顾一下连接是如何工作的，特别是 MySQL 特有的语法。

SQL Join 语句

Join 是一个语句，让你把两个表放在一起，匹配彼此相关的行，只保留可以匹配的行，不保留未配对的行。

SELECT * FROM table1 
  INNER JOIN table2
  ON table1.id = table2.id;

两个表之间通用的 INNER JOIN 语句

SELECT ... FROM 语句指出哪个是第一个表，然后第二个表的名字就写在 INNER JOIN 关键字的后面。

两个表如何连接是写在 ON 语句中。在这个例子中，两个表是使用 table1.id = table2.id 的关系连接的。

可以同时使用多个连接语句来连接多个表。

SELECT *
  FROM table1
  INNER JOIN table2
  ON table1.id = table2.id
  INNER JOIN table3
  ON table2.id = table3.id;

三个表之间通用的 INNER JOIN 语句

要做到这一点，你需要添加第二个 INNER JOIN 语句和第二个 ON 语句来表示第三个表和第二个表的关系。

让我们来讨论一下表之间的关系，以及为什么要把三个表连接在一起。

SQL 中表之间的关系

当你有相互关联的表时，它们之间的关系可以是以下类型之一。

一对多

在一对多的关系中，第一个表的一条记录可以与第二个表的多条记录相关。

在关系型数据库中，这可以通过第二张表有一个 first_table_id 列来实现，该列说明该行与第一张表的哪一行有关。

多对一

在多对一的关系中，第一张表的一条记录可以与第二张表的一条记录相关，而第二张表的一条记录可以与第一张表的多条记录相关。

在关系型数据库中，这可以通过第一张表有一个 second_table_id 列来实现，该列说明该行与第二张表的哪一行有关。

Many-to-one

多对多

在这种情况下，多条记录与多条记录相关。

Many-to-many

这种关系不能用 SQL 表来表示--你需要在两个表之间添加一个耦合表，这样表之间才会有多对一和一对多的关系。

中间的表的每一行都代表了左边表的行和右边表的行之间的一种关系。

在 MySQL 的实践中，该中间表将有一列 first_table_id 和一列 second_table_id，每个组合都是唯一的。

连接 SQL 表实践

让我们想象一下，我们有一个组织的数据库，其中有一个团队表（他们的名字，和其他识别信息），和一个项目表（名字、进度，等等）。

由于一个团队可以从事多个项目，而一个项目可以由多个团队从事，因此还有第三个表格，记录团队-项目的匹配情况。

当我们需要以人类可读的方式查看表的信息时，我们可以使用 JOIN 语句把所有的东西放在一起，就像这样：

SELECT
  teams.team_name AS team_name,
  projects.project_name AS project_name
FROM TABLE teams
INNER JOIN matches
  ON teams.id = matches.team_id
INNER JOIN matches
  ON matches.project_id = projects.id
ORDER BY teams.id;

我们用 SELECT 语句选择显示每个表的哪些列。

我们用 ON 语句指定表的行的组合方式。

我们用 ORDER BY 语句以我们喜欢的方式排列这些行。

ON 语句 teams.id = matches.team_id 和 matches.projects_id = projects.id 意味着使用 matches 表的行来组合。输出表的每一行都有项目名称和团队名称，并使用 matches 表中的项目 id 和团队 id 对进行组合。

输出表将如下所示。

没有直接来自 matches 表的列。在输出中没有显示 matches 表，但它被用于说明如何合并 teams 和 projects 表的行。

总结

语句 JOIN 允许你将一个或多个表连接起来。它必须和 ON 语句一起使用，以确定一个表的行和另一个表的行之间的关系。

在这篇文章中，你学习了如何使用 JOIN 语句来连接三个不同的表。

你已经创建了你的数据库和表，在所有这些工作之后，你注意到你需要添加或重命名一个列。那么，你可以使用 “ALTER TABLE” 语句来这样做。

请记住，当你这样做时，你需要非常小心。如果你的表有很多行，它可能会给你的数据库带来性能问题。

注意：如果这里介绍的语法不起作用，请检查你所使用的 SQL 的实现文档。大多数东西的工作原理都是一样的，但也有一些区别。

如何用 ALTER TABLE 添加一个新列

要添加一个新的列，首先需要用 ALTER TABLE table_name 选择表，然后用 ADD column_name datatype 写下新列的名称和数据类型。综合起来，代码看起来是这样的：

ALTER TABLE table_name
ADD column_name datatype;

使用 ALTER TABLE 添加新列的示例

我们有一个用户数据库，内容如下：

我们已经到了需要存储用户的身份证件号码的时候了，所以我们需要为此添加一个新的列。

为了给我们的 users 表添加一个新的列，我们需要用 ALTER TABLE users 选择该表，然后用 ADD id_number TEXT 指定新列的名称和数据类型，如下：

ALTER TABLE users
ADD id_number TEXT;

表格现在有了新的一列：

一旦提供了缺失的信息，你将需要使用 UPDATE 语句为已经存在的用户添加这些信息。

如何用默认值而不是 NULL 创建一个新的列

你也可以使用 default 关键字和要使用的值来创建一个带有默认值的列。然后，用户将看到默认值，而不是用 NULL 来填充缺失的值。

比方说，我们很快就会有国际用户，我们想添加一个 country 列。我们所有的现有用户都来自美国，所以我们可以用它作为默认值。

ALTER TABLE users
ADD country TEXT default "United States";

现在这个表格是这样的：

向表格添加新列时要谨慎

如果你的表已经有很多行了--比如你已经有很多用户，或者很多存储的数据--添加一个新的列可能真的很耗资源。所以一定要小心处理这个操作。

如何用 ALTER TABLE 重命名一个列

你可以用下面的代码来重命名一个列。你用 ALTER TABLE table table_name 选择表格，然后用 RENAME COLUMN old_name TO new_name 写出要重命名的列和要重命名的内容。

ALTER TABLE table_name
RENAME COLUMN old_name TO new_name;

重命名一个列的例子

让我们看一下我们在前面的例子中使用的同一个表：

为了避免 id 和 id_number 列之间的混淆，让我们把第一个列重命名为 user_id。

我们首先用 ALTER TABLE users 选择表，然后用 RENAME COLUMN id TO user_id 声明列名，使其变为我们需要的名字。

ALTER TABLE users
RENAME COLUMN id TO user_id;

使用查询后，表格将看起来像这样：

重命名表中的列时要小心

当你使用 ALTER TABLE 重命名列时，你有可能破坏数据库的依赖关系。

如果你使用数据库重构工具来改变一个列的名称，而不是使用 ALTER TABLE，它将管理所有的依赖关系，并用新的列名来更新它们。

如果你的数据库比较小，你可能不需要担心，但必须记住这一点。

总结

在这篇文章中，你已经学会了如何使用 ALTER TABLE 在表中增加一个列和重命名一个列。

请记住，这两种操作都有各自的风险。正如有人说的，“权力越大，责任越大”，ALTER TABLE 是一种大的权力，所以你要小心使用它！

日期是任何编程语言的一个组成部分，SQL 也不例外。当你在 SQL 数据库中插入数据时，你可以添加一个日期并根据该日期查询数据库。

在这篇文章中，你将了解到 SQL 中的 DATE 函数以及如何用日期查询数据库。我们还将了解一些时间函数。

我们将讨论的内容

• SQL 中的 Date 函数
• ADDDATE()
• CURRENT_DATE()
• CURRENT_TIME()
• CURRENT_TIMESTAMP()
• NOW()
• DATE
• DATE_SUB
• DATEDIFF
• DAY
• MONTH
• YEAR
• 如何根据日期查询数据库
• 总结

SQL 中的 Date 函数

ADDDATE()

ADDDATE() 函数就像它的名字所表示的那样——它为一个 date 或 datetime 添加一个间隔。

你可以以这种格式使用 ADDDATE() 函数：ADDDATE(date, INTERVAL value addunit)。

• date 是你要处理的日期。对于 MySQL，日期格式是 YYY-MM-DD，并且是必须的。
• INTERVAL 是一个必要的关键字。
• value 是一个整数，代表你要添加的间隔时间。
• addunit 是间隔应该代表什么。也就是年、月、日、小时、分钟、秒和其他相关单位。

例如，运行下面的查询返回 “2022-10-22”。这意味着 10 天被添加到 “2022-10-12”。

SELECT ADDDATE("2022-10-12", INTERVAL 10 DAY);

如果你愿意，你可以把它和月或年一起使用：

CURRENT_DATE()

CURRENT_DATE() 函数显示的正是它的名字表示的——当前日期。它以 YYY-MM-DD 的格式返回日期。

例如，SELECT CURRENT_DATE() 返回我开始写这篇文章的日期：

CURRENT_TIME();

CURRENT_TIME 函数显示当前时间。

SELECT CURRENT_TIME();

CURRENT_TIMESTAMP();

CURRENT_TIMESTAMP() 函数返回当前日期和时间。它是 CURRENT_DATE() 和 CURRENT_TIME() 的组合。

SELECT CURRENT_TIMESTAMP();

NOW()

NOW() 函数返回当前日期和时间。

SELECT NOW();

DATE

你可以使用 DATE 函数来提取一个时间戳的日期部分。

SELECT DATE("2022-11-14 12:00:00");

DATE_SUB

DATE_SUB() 函数从一个日期中减去一天、一月或一年。在下面的查询中，我从我开始写这篇文章的日期中减去了 10 天：

SELECT DATE_SUB("2022-11-14", INTERVAL 10 DAY);

DATEDIFF

DATEDIFF() 函数返回两个日期之间的天数。

SELECT DATEDIFF("2023-11-14", "2022-11-14");

DAY

该函数返回指定日期内的日期。

SELECT DAY("2022-11-14");

MONTH

MONTH 函数返回指定日期中的月份。

SELECT MONTH("2022-11-14");

YEAR

YEAR 函数返回指定日期中的年份。

SELECT YEAR("2022-11-14");

如何基于日期查询数据库

为了告诉你如何使用日期查询数据库，我将使用下面的表格：

要选择一个日期和另一个日期之间的某些特定日期，你可以在指定日期时使用 BETWEEN 和 AND 关键字。

在下面的查询中，我选择了 2021 年添加到数据库中的所有项目：

SELECT *
FROM brands
WHERE date_added BETWEEN "2021-01-01" AND "2021-12-31";

结合 DATE_SUB() 和 NOW() 函数，我能够得到过去 3 个月内添加到数据库的项目：

SELECT *
FROM brands
WHERE date_added > DATE_SUB(NOW(), INTERVAL 3 MONTH);

总结

这篇文章向你展示了一些重要的函数，你可以用它来处理日期和在 SQL 中查询数据库。

如果你觉得这篇文章有用，不要犹豫，与朋友和家人分享它。

谢谢你阅读本文。

当你在使用 SQL 时，你需要学习如何正确格式化日期。

这是因为日期是任何 SQL 和其他软件相关活动的一个重要方面。例如，你需要能够使用日期来为条目添加时间戳，并跟踪事情发生的时间。几乎所有的事情都与一个日期相关联。

在这篇文章中，我想告诉你如何用 CONVERT() 和 STR_TO_DATE() 函数在 SQL 中把日期和日期时间转换为字符串。

我们将讨论的内容

• 如何用 CONVERT() 函数将日期转换为字符串
• 如何用 STR_TO_DATE() 函数将日期转换为字符串
• 如何用 DATE_FORMAT() 改变时间格式
• 小结

如何用 CONVERT() 函数将日期转换为字符串

CONVERT() 函数有两个参数：

• 日期 - 必须是一个字符串，或者使用内置的日期获取函数，如 NOW() 或 SYSDATE()
• 数据类型 - 你想将日期转换成的数据类型

下面是 CONVERT() 函数的用法：

SELECT CONVERT(NOW(), CHAR);

上面的查询使用 NOW() 函数来获取当前的日期和时间。第二个参数是 CHAR，是日期被转换为的数据类型。

如果你愿意，也可以使用 SYSDATE() 来代替它：

SELECT CONVERT(SYSDATE(), CHAR);

还有许多其他的函数可以用来处理日期问题。如果你想阅读更多内容，我在本教程中写过它们。

你不仅可以用函数作为 CONVERT() 函数的第一个参数。你可以使用一个写成字符串的日期，然后指定 DATE 作为你要转换的数据类型：

SELECT CONVERT("2023-01-10", DATE)

如何用 STR_TO_DATE() 函数将日期转换成字符串

STR_TO_DATE() 函数是另一个转换日期或日期时间的有用函数。它接受两个参数：

• 日期 - 它必须是一个字符串，例如，“09-01-2023”。
• 格式 - 你希望日期被转换为的格式，例如，mm-dd-yyyy。你可以像这样指定格式：%d-%m-%Y。

下面是 STR_TO_DATE() 函数的用法：

SELECT STR_TO_DATE('09-01-2023', '%d-%m-%Y')

你也可以用斜线（/）来分隔日期和格式：

SELECT STR_TO_DATE('09/01/2023', '%d/%m/%Y')

注意：如果你没有为日期和格式使用相同的分隔符，你会得到返回值为 null。

如果你输入的日期是第 N 天，你必须将格式中的 d 改为大写字母：

SELECT STR_TO_DATE('9th-01-2023', '%D-%m-%Y')

而如果你将月份写成缩写，你必须将格式中的 m 改为大写字母：

SELECT STR_TO_DATE('9th-JAN-2023', '%D-%M-%Y')

接下来，我们将看看如何用 DATE_FORMAT() 函数来处理日期格式。

如何使用 DATE_FORMAT() 改变时间格式

如果你想将月份写成全称，就把格式中的 m 改为大写字母，并使用 DATE_FORMAT() 函数：

SELECT DATE_FORMAT('2023-01-09', '%d-%M-%y')

如果你想将日期写成第几天，就把格式中的 d 改为大写字母：

SELECT DATE_FORMAT('2023-01-09', '%D-%M-%y')

如果你想写年份的全称，就把 y 改成大写字母：

SELECT DATE_FORMAT('2023-01-09', '%D-%M-%Y')

小结

这篇文章向你展示了如何用 CONVERT() 和 STR_TO_DATE() 函数将日期转换为字符串。我们还研究了如何用 DATE_FORMAT() 函数来改变日期格式。

如果你觉得这篇文章对你有帮助，请不要犹豫，与你在社交媒体上的朋友分享它。

在 SQL 中，你可以在 GROUP BY 之后使用 HAVING 关键字根据指定条件查询数据库。与其他关键字一样，它返回满足条件的数据并过滤掉其余的数据。

引入 HAVING 关键字是因为 WHERE 子句无法与聚合函数一起使用。因此，你必须将 HAVING 子句与聚合函数一起使用，而不是 WHERE。

将 HAVING 子句与 GROUP BY 关键字一起使用，你可以将数据库中的数据排列为多个组。因此，你可以在大型数据库中使用它。

如何使用 HAVING 关键字

假设我在 student_scores 数据库中有一个名为 students 的表。SELECT * FROM students 返回以下内容：

你可以通过运行 SELECT name, score FROM students 仅获取姓名和分数。

然后，你可以使用 HAVING 关键字根据条件过滤掉一些学生，例如，那些得分大于 70 的人。

但在此之前，你必须像这样使用 GROUP BY 子句：

GROUP BY name, score

这不会返回任何东西。所以你需要引入 HAVING 关键字：

HAVING score > 70

现在，我可以找到分数高于 70 的学生：

完整的查询如下所示：

SELECT name, score 
FROM students 
GROUP BY name, score
HAVING score > 70

我也可以通过这种方式获得分数超过 90 的学生：

SELECT name, score 
FROM students 
GROUP BY name, score 
HAVING score > 90

该表还有一个年龄（age）列，因此我可以通过这种方式获取 14 岁以上的学生：

SELECT name, age 
FROM students 
GROUP BY name, age 
HAVING age > 14

如果将 WHERE 与聚合函数一起使用，则会发生错误

SELECT name, count(*)
FROM students
GROUP BY name
WHERE COUNT(*) > 0

如果你使用 HAVING，错误就会消失：

SELECT name, count(*)
FROM students
GROUP BY name
HAVING COUNT(*) > 0

你可以使用任何你想要的运算符！

并不是只能使用比较操作符。因此，我可以通过将 HAVING 语句更改为 HAVING age = 13 来获得 13 岁的学生：

我以这种方式得到了 90 分的学生：

SELECT name, score 
FROM students 
GROUP BY name, score 
HAVING score = 90

如果未满足有关语句中的条件，则不会返回行：

SELECT name, score 
FROM students 
GROUP BY name, score 
HAVING score = 100

如果你使用 HAVING 而不使用 GROUP BY，则会发生错误

SELECT COUNT(*)
FROM students 
HAVING score > 80

在这种情况下，你必须使用 WHERE 子句：

SELECT COUNT(*)
FROM students 
WHERE score > 80

小结

在本文中，你学习了如何使用 HAVING 关键字查询数据库。

请记住，你必须将 HAVING 子句与 GROUP BY 一起使用，这样你才能获得所需的数据，就像你在本文中看到的那样。

在不能使用 HAVING 子句的情况下，你可能需要使用 WHERE。

感谢你阅读本文。

在本文中，我将向你展示一些代码示例，说明如何使用 SQL 中的 ORDER BY 子句按升序对数据进行排序。

ORDER BY 语法

这是按升序对数据进行排序的基本语法：

SELECT columns FROM table
ORDER BY column;

如果要按降序排序，则必须使用 DESC 关键字。

SELECT columns FROM table
ORDER BY column DESC;

SQL 中的 SELECT 语句告诉计算机从表中获取数据。

SQL 中的 FROM 子句指定我们要列出的表。

在这个例子中，我们有一个音乐家表，列有 id、name、age、instrument 和 city：

现在，此表按 id 按升序自动排序。

如果我们想按升序对 name 列进行排序，则必须使用以下语法：

SELECT * FROM musicians
ORDER BY name;

* 字符告诉计算机选择表中的所有列。

你可以看到 names 现在按字母顺序排序，并且 id 不再按正确的升序排列。

如果我们想按 city 对数据进行排序，那么我们可以使用这种语法。

SELECT * FROM musicians
ORDER BY city;

你还可以在同一命令中按升序对多个列进行排序。

在这个新的音乐家示例中，我们可以按升序对 age 和 city 列进行排序。

SELECT * FROM musicians
ORDER BY age, city;

我们可以看到表中按字母顺序排列了三个 19 岁的音乐家。我们还可以看到两个 38 岁的音乐家，他们的城市按字母顺序正确排序。

如果我们想按升序对某些数据进行排序，而按降序对其他数据进行排序，则必须使用 ASC 和 DESC 关键字。

在这个新的音乐家示例中，我们希望按降序对 age 列进行排序，按升序对 instrument 列进行排序。

语法如下：

SELECT * FROM musicians
ORDER BY age DESC, instrument ASC;

我们必须在列名旁边使用 ASC 和 DESC 关键字来告诉计算机如何对数据进行排序。

结果如下所示：

我们可以在我们的表中看到 Oscar 和 Jenny 是最年长的。但 Oscar 排在最上面，因为 drums 按字母顺序排在 trombone 之前。

我们在 Jess 和 Dave 身上看到了同样的情况。尽管他们年龄相同，但 Jess 在表格上的位置更靠前，因为按字母顺序，flute 排在 trumpet 之前。

总结

你可以使用 SQL 中的 ORDER BY 子句按升序对表数据进行排序。

SELECT columns FROM table
ORDER BY column;

如果要按降序排序，则还必须使用 DESC 关键字。

SELECT columns FROM table
ORDER BY column DESC;

* 字符告诉计算机选择表中的所有列。

SELECT * FROM table
ORDER BY column;

如果要按升序对多个列进行排序，则可以在 ORDER BY 子句旁边列出要排序的列。

SELECT * FROM table
ORDER BY column1, column2;

如果要按升序对某些数据进行排序，而按降序对其他数据进行排序，则必须使用 ASC 和 DESC 关键字。

SELECT * FROM table
ORDER BY column1 ASC, column2 DESC;

以上就是使用 SQL 中的 ORDER BY 子句按升序对数据进行排序的方法。

在本文中，我将向你展示如何使用 INSERT 语句添加单行、多行以及将行从一个 SQL 表格复制到另一个。

基本语法

以下是在 SQL 中向表格中添加行的基本语法：

INSERT INTO table_name (column1, column2, column3,etc)
VALUES (value1, value2, value3, etc);

第一行代码使用 INSERT 语句，后跟要添加数据的表格的名称。在表名之后，你应该指定列名。

第二行代码是你添加行值的地方。值的数量与指定的列数匹配很重要，否则你将收到报错消息。

如何在 SQL 表格中添加行

在这个例子中，我们有一个名为 dogs 的表格，其中包含 id、name 和 gender 列。我们想添加一只名为 AXEL 的狗。

这是将 AXEL 添加到表格中的代码：

INSERT INTO dogs(id, name, gender) VALUES (1, 'AXEL', 'M');

表格显示如下：

如果值的数量与列不匹配会发生什么

如前所述，列数必须与值的数量相匹配。

如果我更改代码以删除一个值，那么我会收到一条报错消息。

INSERT INTO dogs(id, name, gender) VALUES (1, 'AXEL');

由于我们指定了 3 列，因此我们需要为添加到表格中的每一行提供三个值。

如果忽略列约束会发生什么

创建 SQL 表格时，你将添加用作列规则的列约束。

在我们的 dogs 表格中，name 和 gender 列的约束为 NOT NULL。此规则意味着行中不能缺少值。

当我尝试为性别添加 NULL 时，我返回一条错误消息。

INSERT INTO dogs(id, name, gender) VALUES (1, 'AXEL', NULL);

添加行时，需要遵守你在创建 SQL 表格时指定的任何约束。

如何在 SQL 中向表格添加多行

如果要一次向表格添加多行，则可以使用以下语法：

INSERT INTO table_name (column1, column2, column3,etc)
VALUES 
	(value1, value2, value3, etc),
    (value1, value2, value3, etc),
    (value1, value2, value3, etc);
	

记住每一行之间的逗号很重要，否则你将收到报错消息。

这是一次将八只狗添加到表格中的代码：

INSERT INTO dogs(id, name, gender) 
VALUES 
    (1, 'AXEL', 'M'),
    (2, 'Annie', 'F'),
    (3, 'Ace', 'M'),
    (4, 'Zelda', 'F'),
    (5, 'Diesel', 'M'),
    (6, 'Tilly', 'F'),
    (7, 'Leroy', 'M'),
    (8, 'Olivia', 'F');

表格现在如下所示：

如何从一个表格复制行并将它们插入到另一个表格

你可以使用 SELECT 和 INSERT 语句将行从一个 SQL 表格复制到另一个。

这是基本语法：

INSERT INTO table_name1 (columns) 
SELECT columns FROM table_name2;

在这个例子中，我创建了一个包含三行的 cats 表格，列名与 dogs 表格相同。

我们可以使用以下代码将所有 cats 数据添加到 dogs 表格中：

INSERT INTO dogs SELECT * FROM  cats;

这是带有额外 cats 数据的新的 dogs 表格的样子：

总结

如果要将数据添加到 SQL 表格，可以使用 INSERT 语句。

以下是向 SQL 表格添加行的基本语法：

INSERT INTO table_name (column1, column2, column3,etc)
VALUES (value1, value2, value3, etc);

第二行代码是你添加行值的地方。值的数量与指定的列数匹配很重要，否则你将收到报错消息。

当你尝试在向表格中添加行时忽略列约束时，你将收到一条报错消息。

如果要一次向表格中添加多行，则可以使用以下语法：

INSERT INTO table_name (column1, column2, column3,etc)
VALUES 
	(value1, value2, value3, etc),
    (value1, value2, value3, etc),
    (value1, value2, value3, etc);

你可以使用 SELECT 和 INSERT 语句将行从一个 SQL 表格复制到另一个。

这是基本语法：

INSERT INTO table_name1 (columns) 
SELECT columns FROM table_name2;

我希望你喜欢这篇文章，并祝你在 SQL 之旅中好运。

原文：Insert Into SQL – How to Insert Into a Table Query [Example Statement]，作者：Jessica Wilkins

在本文中，我将通过代码示例向你展示如何在 SQL 中使用 SUM 和 AVG 函数。

如何在 SQL 中使用 SUM 函数

如果需要在表中添加一组数字，可以使用 SQL 中的 SUM 函数。

这是基本语法：

SELECT SUM(column_name) FROM table_name;

SQL 中的 SELECT 语句告诉计算机从表中获取数据。

SQL 中的 FROM 子句指定我们要列出的表。

在此示例中，我们有一个名为 students 的表，其中包含 id、name、date 和 total 列。我们想把所有学生售出的糖果总数加起来。

我们可以使用此语法来获取销售的糖果总数：

SELECT SUM(total) FROM students;

结果将是 41。

我们还可以使用 GROUP BY 子句获取每个学生的糖果数。

第一部分是为销售的糖果总数选择名称和总和，如下所示：

SELECT name, SUM(total)

第二部分是按名称对总和进行分组：

FROM students GROUP BY name;

这是按学生姓名对销售的糖果总数进行分组的完整代码。

SELECT name, SUM(total) FROM students GROUP BY name;

这就是我们表格中的结果：

现在，结果按学生姓名的字母顺序分组。

我们可以修改代码，使用 ORDER BY 子句将结果列表从最大总数到最小排序。

SELECT name, SUM(total) FROM students GROUP BY name ORDER BY total DESC;

DESC 关键字告诉计算机按总数从最大到最小排序。

如果我们想从最小到最大排序总数，那么我们将省略 DESC 关键字。

SELECT name, SUM(total) FROM students GROUP BY name ORDER BY total;

如何在 SQL 中使用 AVG 函数

AVG 函数查找 SQL 表中一组记录的算术平均值。平均值或算术平均值是一组数字的总和除以该组的计数。

例如，2+4+4+6+6+8 是 30 除以 6，结果平均值为 5。

这是 AVG 函数的基本语法：

SELECT AVG(column_name) FROM table_name;
   

在此示例中，我们有一个名为 students 的表，其中包含 id、name、date 和 scores 的列。我们想在表格中找到所有学生考试成绩的平均值。

我们必须使用此语法来获得测试分数的平均值：

SELECT AVG(scores) FROM students; 

平均值是 85.333。

我们还可以使用 ROUND 函数将结果四舍五入到最接近的整数。

SELECT ROUND(AVG(scores)) FROM students; 

我们还可以使用 GROUP BY 子句获得每个学生的平均值。

第一部分是选择分数的名称和平均值，如下所示：

SELECT name, ROUND(AVG(scores))

第二部分是按名称对平均分数进行分组：

FROM students GROUP BY name;

代码如下所示：

SELECT name, ROUND(AVG(scores)) FROM students GROUP BY name;

表格中结果如下所示：

总结

有时你可能需要计算表中记录的总和或平均值。

如果需要在表中添加一组数字，可以使用 SQL 中的 SUM 函数。

这是基本语法：

SELECT SUM(column_name) FROM table_name;

如果需要将数据分组，则可以使用 GROUP BY 子句。

AVG 函数计算 SQL 表中一组记录的算术平均值。平均值或算术平均值是一组数字的总和除以该组的计数。

这是基本语法。

SELECT AVG(column_name) FROM table_name;

我希望你喜欢这篇教程，并祝你在 SQL 之旅中好运。

原文：SQL Count – How to Select, Sum, and Average Rows in SQL，作者：Jessica Wilkins

在本文中，我将向你介绍如何使用 DELETE 查询和 WHERE 子句删除行。我还将向你展示如何一次从表中删除多行。

如何在 SQL 中使用 DELETE 查询

这是使用 DELETE 查询的基本语法：

DELETE FROM table_name
WHERE condition of which row(s) to delete;

在本例中，我们有一个名为 cats 的表，目前有10 行，列将是 id、name 和 gender。

我们要删除 id 为 8 的行，即 Loki 的行。

DELETE 查询的第一行如下所示：

DELETE FROM cats

在第二行中，我们将通过在 WHERE 子句后使用 id=8 来指定哪一行。

WHERE id=8;

以下是删除 Loki 行的完整语法：

DELETE FROM cats
WHERE id=8;

这是新的 cats 表的样子：

我们可以看到我们的 DELETE 查询生效了，因为 Loki 的信息不再存在。

如何在 SQL 中从一个表删除多行

我们可以从 cats 表中删除多行的一种方法是将条件从 id 更改为 gender。

如果我们只想删除包含公猫的行，那么我们可以使用 gender="M" 条件。

DELETE FROM cats
WHERE gender="M";

我们的新 cats 表看起来像这样：

现在，cats 表只显示雌性猫。

如何在 SQL 中使用 BETWEEN 运算符和 AND 运算符删除多行

如果我们想删除一个范围内的多行，我们可以使用 AND 运算符和 BETWEEN 运算符。

在这个例子中，我们想要删除 id 为 4-7 的行。

这是语法：

DELETE FROM cats
WHERE id BETWEEN 4 AND 7;

这是 DELETE 查询的结果：

我们可以看到第 1-3 行和第 8-10 行留在表中，已成功删除 4-7 的 id。

如何在 SQL 中使用 IN 运算符删除多行

我们可以使用 IN 运算符指定要从 cats 表中删除哪些名称。

在这个例子中，我想从我们原来的 cat 表中删除 Lucy、Stella、Max 和 Tiger 的名字：

我们需要指定列并使用 IN 运算符列出我们要删除的名称。

DELETE FROM cats
WHERE name IN ("Lucy","Stella","Max","Tiger");

这就是新的结果：

我们的 DELETE 查询成功了，因为那四只猫不再出现在表中。

SQL 如何删除表中的所有记录

如果要从表中删除所有信息，则可以使用以下语法：

DELETE FROM table_name;

为了从我们的 cats 表中删除所有的猫，我们将使用这个代码。

DELETE FROM cats;

总结

在本文中，我们了解了从 SQL 表中删除信息的不同方法。

这是使用 DELETE 查询的基本语法：

DELETE FROM table_name
WHERE condition of which row(s) to delete;

如果要从表中删除一行，则必须指定一个条件。

WHERE id=8;

有几种方法可以删除表中的多行。

如果要删除某个范围内的多行，可以将 AND 运算符与 BETWEEN 运算符一起使用。

DELETE FROM table_name
WHERE column_name BETWEEN value 1 AND value 2;

删除多行的另一种方法是使用 IN 运算符。

DELETE FROM table_name
WHERE column_name IN (value 1, value 2, value 3, etc...);

如果要从表中删除所有记录，则可以使用此语法。

DELETE FROM table_name;

我希望你喜欢这篇文章，并祝你在 SQL 之旅中好运。

原文：How to Delete a Row in SQL – Example Query，作者：Jessica Wilkins

请记住，如果此处提供的语法不起作用，你可以查看你正在使用的 SQL 文档。

SQL INSERT 语句语法

INSERT 语句指定要将记录添加到哪个表中。编写命令 INSERT INTO table_name，然后是关键字 VALUES，后跟要在括号内的每一列中添加的值，并用逗号分隔，如下所示：

INSERT INTO table_name
VALUES (value1, value2, value3...);

这些值将按照在表中定义列的顺序被添加到列中。

如何为选定的列赋值

假设你只想为几列提供值 - 例如，如果你想避免手动设置 id，而是自动完成，你将使用以下语法：

INSERT INTO table_name(column1, column2...)
VALUES (value1, value2...);

这些值将按照它们在括号中的写入顺序被分配给列。

SQL INSERT 语句示例

让我们创建一个表，然后我们将使用 INSERT 向其中添加前几条记录。

下面的代码将创建一个名为 users 的表，它有 5 列。我们将有一个 id 列作为 PRIMARY KEY（该列将始终具有唯一值，并允许我们唯一标识一行），然后是 name 、age、state 和 email 列。

CREATE TABLE users (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT,  age INTEGER, state TEXT, email TEXT);

让我们使用第一个语法将第一条记录添加到该表中。

我们将使用以下查询添加用户 Paul，其 id 为 1，年龄为 24，state 是 Michigan，电子邮件地址为 paul@example.com：

INSERT INTO users
VALUES (1, "Paul", 24, "Michigan", "paul@example.com");

这将使表格看起来像这样：

使用此语法，你必须为每一列指定一个值，否则它将引发错误，并且不能运行。

现在让我们使用上面看到的第二种语法添加一些其他记录。

INSERT INTO users (name, state)
VALUES ("Molly", "New Jersey");

INSERT INTO users (name, state, age)
VALUES ("Robert", "New York", 19);

在这种情况下，第一个值被分配给第一个提到的列，因此 “Molly” 被分配给 name 列，“New Jersey” 被分配给 state 列。然后对于另一条记录，name 列的值为 “Robert”，state 列为 “New York”，age 列为 19。

未分配值的列会发生什么情况？类型为 INTEGER PRIMARY KEY AUTOINCREMENT 的列会自动更新，确保每一行都具有唯一值。当没有为其他列指定值时，它们被分配一个 NULL 值。

现在表格如下所示。请注意， id 列已更新为在每一行中具有唯一值，即使我们没有明确地为其分配值。尚未分配值的其他列的值为 NULL。

小结

当你刚在数据库中创建表时，它是空的。本文介绍了如何向表中添加记录，开始创建数据库。

原文：Insert Into SQL – SQL Insert Statement Example，作者：Ilenia Magoni

有一个声明 UPDATE 很有用，你可以在需要修改记录的时候使用它。

注意：如果这里介绍的语法不能运行，请查看相关 SQL 文档。大多数内容是相通的，但也有一些差异。

SQL UPDATE 语法

要使用 UPDATE 方法，首先要确定需要使用 UPDATE table_name 更新哪个表。然后确定你要使用 SET 语句对记录进行什么更改。最后，使用 WHERE 子句来选择要更改的记录。

使用 WHERE 子句非常重要，否则你将对整个表进行相同的更改。

UPDATE table_name
SET change to make
WHERE clause to select which records to change;

SQL UPDATE 示例

我们有一个名为 users 的表，如下所示：

这张表中有一些不完整的记录。当用户向我们提供缺少的信息时，我们可以使用 UPDATE 语句添加它。

用户 Robert 缺少电子邮件地址。WHERE 子句选择的所有行都将被更新，因此我们需要小心：我们可以使用 name 列选择要更新的记录，但名称不是唯一的——我们的表中可以有多个 Robert。

选择一行来更新它（以确保只更新要更新的行）的最佳方法是使用 PRIMARY KEY 列，其中的值始终是唯一的。在这种情况下，这是名为 id 的列。

让我们使用此查询更新电子邮件地址：

UPDATE users
SET email="robert@example.com"
WHERE id=3;

现在表格是这样的：

如何同时更新多个列

Molly 在两个不同的列中缺少一个值。我们可以使用单个 UPDATE 语句，用逗号分隔赋值，如下所示：

UPDATE users
SET age=22, email="molly@example.com"
WHERE id=2;

现在表格是这样的：

确保只更改你要更改的记录

这是一个安全问题。我们的示例只有几行，但在现实生活中，它可能是拥有数百、数千甚至数百万用户的应用程序或网站的数据库，你不想给这么多人带来麻烦。

因此，在发出 UPDATE 查询之前，请使用相同的 WHERE 子句发送 SELECT 查询。如果它返回你要更新的记录，请继续。否则，你需要更改 WHERE 子句。

例如，在为用户 Molly 发送更新之前，我们可以发送一个 SELECT 语句来检查我们使用的子句 WHERE id=2 是否正确：

SELECT * FROM users
WHERE id=2;

此查询返回下面的记录，因此你可以使用 UPDATE 查询来完成数据。

小结

创建表格并向其中添加记录后，有时候需要更新其中的行。本文介绍了如何使用 SQL UPDATE 语句执行此操作。

谢谢阅读本文！

原文：SQL Update Statement – Update Query in SQL，作者：Ilenia Magoni