极客笔记常用SQL 查询
如果你的目标是成为数据管理员、数据库开发人员或数据分析师，那么精通 SQL 查询非常重要。如果你想处理结构化数据，那么必须知道如何从关系数据库中提取、处理和分析数据。
在本文中，我们将学习几个 SQL 查询，这些查询将帮助您提高查询能力。
以下是 SQL 查询：
1. 编写查询以创建新表。
CREATE TABLE tableName (
columnName datatype,
columnName datatype,
...
);
2. 编写查询语句以将新记录插入表中:
INSERT INTO tableName (Column1, Column2, ?)
VALUES (Value1, Value2, ?);
3. 编写查询来删除表中的记录：
DELETE FROM tableName WHERE condition;
4. 编写用于更新表中记录的查询：
UPDATE tableName
SET columnName = newValue
WHERE condition;
5. 编写查询语句来删除数据库中的表格：
DROP TABLE tableName;
6. 编写查询以选择从表中检索数据的所有记录：
SELECT * FROM tableName;
7. 写一个查询来选择表中的特定列:
SELECT Column1, Column2 FROM tableName;
8. 编写查询以从列中选择不同的值：
SELECT DISTINCT columnName FROM tableName;
9. 写一个使用WHERE子句来过滤记录的查询：
SELECT * FROM tableName WHERE condition;
10.编写查询以按降序排序记录：
SELECT * FROM tableName
ORDER BY columnName DESC;
11. 编写查询以按升序排序记录：
SELECT * FROM tableName
ORDER BY columnName ASC;
12. 编写查询语句，根据一个共同的列将两个表连接起来：
SELECT * FROM Table1 JOIN Table2
ON Table1.columnName = Table2.columnName;
13. 编写查询语句以计算表中的行数。
我们将使用COUNT()函数来计算行数。语句如下所示：
SELECT COUNT(*) FROM tableName;
14. 编写查询来分组记录并计算聚合函数：
SELECT columnName, COUNT(*), AVG(columnName)
FROM tableName GROUP BY columnName;
15. 编写查询以限制返回结果集中的行数。
我们将使用LIMIT子句来限制行数。下面是语句：
SELECT columnName FROM tableName LIMIT 10;
16. 编写查询语句来找到一列中数值的总和：
SELECT SUM(columnName) FROM tableName;
17.编写查询以找到列的平均值：
SELECT AVG(columnName) FROM tableName;
18. 编写查询以获取列中的最小值：
SELECT MIN(columnName) FROM tableName;
19. 编写查询来检索列中的最大值：
SELECT MAX(columnName) FROM tableName;
20. 编写查询以检索具有指定范围内值的行：
SELECT columnName FROM tableName
WHERE columnName
BETWEEN Value1 AND Value2;
21. 编写查询以检索具有与指定值列表相匹配的行：
SELECT columnName FROM tableName
WHERE columnName
IN (Value1, Value2, Value3);
22. 编写查询以使用通配符字符在列中搜索模式：
SELECT columnName FROM tableName WHERE columnName LIKE 'abc%';
23. 编写用于基于聚合函数过滤数据的GROUP BY查询的查询：
SELECT Column1, COUNT(Column2)
FROM tableName
GROUP BY Column1 HAVING COUNT(Column2) > 5;
24. 编写查询以检索指定范围内的日期行：
SELECT columnName FROM tableName
WHERE columnName
BETWEEN '2023-01-01' AND '2023-07-30';
25. 编写查询语句以结合两个或多个SELECT语句的结果集：
SELECT * FROM Table1
UNION SELECT columnName FROM Table2;
26. 编写查询以在查询中执行条件逻辑：
SELECT columnNamse, CASE WHEN Condition1 THEN 'Value1'
WHEN Condition2 THEN 'Value2'
ELSE 'Value3'
END AS newColumn FROM tableName;
27. 编写查询语句以删除表中的所有行，但保留表结构：
TRUNCATE TABLE tableName;
28. 写一个查询语句，在表的一个或多个列上创建一个索引：
CREATE INDEX indexName ON tableName (Column1, Column2);
29. 编写查询以修改现有表的结构：
ALTER TABLE tableName ADD columnName datatype;
30. 编写查询来返回表达式列表中的第一个非空值:
SELECT COALESCE(Column1, Column2, … , ColumnN) AS Result
FROM tableName;
31. 编写查询语句，如果两个表达式相等，则返回空值，否则返回第一个表达式。
我们将使用NULLIF()函数来完成，语句如下所示：
SELECT NULLIF(Column1, 0) AS result FROM tableName;
模拟实际生活中的问题以练习SQL查询：
让我们来看一些模拟实际生活中的问题，以练习上述讨论的SQL查询：
1. 编写查询以创建一个名为’employees’的表，其中包含empId、empName、empAge、empAddress和empSalary等字段。
查询语句：
CREATE TABLE employees (
empId INT,
empName VARCHAR(40),
empAge INT,
empAddress VARCHAR(40),
empSalary INT
);
结果: ’employees’表看起来如下所示。
| empId | empName | empAge | empAddress | empSalary |
|---|---|---|---|---|
2. 编写查询语句将值插入上面的’employees’表。
查询语句:
INSERT INTO employees
VALUES(1, 'Daksh', 25, 'Jaipur', 32000),
(2, 'Ananya', 30, 'Bhopal', 37000),
(3, 'Aarush', 32, 'Jaipur', 35000),
(4, 'Reyansh', 30, 'Bhopal', 40000)
(5, 'Jhalak', 28, 'Jaipur', 39000);
结果： 在向’employees’表中插入值之后，它将如下所示。
| empId | empName | empAge | empAddress | empSalary |
|---|---|---|---|---|
| 1 | Daksh | 25 | Jaipur | 32000 |
| 2 | Ananya | 30 | Bhopal | 37000 |
| 3 | Aarush | 32 | Jaipur | 35000 |
| 4 | Reyansh | 30 | Bhopal | 40000 |
| 5 | Jhalak | 28 | Jaipur | 39000 |
3. 考虑’employees’表，并编写查询以从’employees’表中删除’empId=1’的记录：
查询：
DELETE FROM employees WHERE empId=1;
结果： 上述语句将从“employees”表中删除记录’empId=1’。
| empId | empName | empAge | empAddress | empSalary |
|---|---|---|---|---|
| 2 | Ananya | 30 | Bhopal | 37000 |
| 3 | Aarush | 32 | Jaipur | 35000 |
| 4 | Reyansh | 30 | Bhopal | 40000 |
| 5 | Jhalak | 28 | Jaipur | 39000 |
4. 考虑“employees”表并编写查询语句以更新“employees”表中’empId=5’的年龄：
查询语句：
UPDATE employees SET empAge = 29 WHERE empId=5;
结果: 上述语句将在 ’employees’ 表中更新 ’empId=5′ 的年龄。
| empId | empName | empAge | empAddress | empSalary |
|---|---|---|---|---|
| 1 | Daksh | 25 | Jaipur | 32000 |
| 2 | Ananya | 30 | Bhopal | 37000 |
| 3 | Aarush | 32 | Jaipur | 35000 |
| 4 | Reyansh | 30 | Bhopal | 40000 |
| 5 | Jhalak | 28 | Jaipur | 39000 |
5. 考虑 ’employees’ 表并编写查询以选择 ’employees’ 表中的所有记录：
查询:
SELECT * FROM employees;
结果: 如下所示，上述语句将选择 ’employees’ 表中的所有记录。
| empId | empName | empAge | empAddress | empSalary |
|---|---|---|---|---|
| 1 | Daksh | 25 | Jaipur | 32000 |
| 2 | Ananya | 30 | Bhopal | 37000 |
| 3 | Aarush | 32 | Jaipur | 35000 |
| 4 | Reyansh | 30 | Bhopal | 40000 |
| 5 | Jhalak | 28 | Jaipur | 39000 |
6. 考虑 ’employees’ 表并编写查询以选择 ’employees’ 表中的 ’empName’ 和 ’empSalary’ 列:
查询:
SELECT empName, empSalary FROM employees;
结果: 上述语句将从’employees’表中选择’empName’和’empSalary’列。
| empName | empSalary |
|---|---|
| Daksh | 32000 |
| Ananya | 37000 |
| Aarush | 35000 |
| Reyansh | 40000 |
| Jhalak | 39000 |
7. 考虑’employees’表并编写查询以从’employees’表中选择’empAddress’列的不同值：
查询:
SELECT DISTINCT empAddress FROM employees;
结果: 上述语句将从’employees’表中的’empAddress’列中选择唯一的值。
empAddress
Jaipur
Bhopal
8. 考虑’employees’表，编写查询语句，使用WHERE子句过滤和选择empAddress=’Jaipur’的记录:
查询语句:
SELECT * FROM employees
WHERE empAddress='Jaipur';
结果： 上述语句将从“employees”表中过滤记录。
| empId | empName | empAge | empAddress | empSalary |
|---|---|---|---|---|
| 1 | Daksh | 25 | Jaipur | 32000 |
| 3 | Aarush | 32 | Jaipur | 35000 |
| 5 | Jhalak | 28 | Jaipur | 39000 |
9. 考虑“employees”表，编写查询以按降序对“employees”表的记录进行排序。
查询：
SELECT * FROM employees
ORDER BY empName DESC;
结果: 以上语句将按照降序对“employees”表的记录进行排序。
| empId | empName | empAge | empAddress | empSalary |
|---|---|---|---|---|
| 4 | Reyansh | 30 | Bhopal | 40000 |
| 5 | Jhalak | 28 | Jaipur | 39000 |
| 1 | Daksh | 25 | Jaipur | 32000 |
| 2 | Ananya | 30 | Bhopal | 37000 |
| 3 | Aarush | 32 | Jaipur | 35000 |
10. 考虑“employees”表，并写出对“employees”表的记录进行升序排序的查询。
查询:
SELECT * FROM employees
ORDER BY empName ASC;
结果: 上述语句将按升序对“员工”表的记录进行排序。
| 员工编号 | 员工姓名 | 员工年龄 | 员工地址 | 员工工资 |
|---|---|---|---|---|
| 3 | Aarush | 32 | Jaipur | 35000 |
| 2 | Ananya | 30 | Bhopal | 37000 |
| 1 | Daksh | 25 | Jaipur | 32000 |
| 5 | Jhalak | 28 | Jaipur | 39000 |
| 4 | Reyansh | 30 | Bhopal | 40000 |
11. 考虑“员工”表并编写查询以计算“员工”表中的行数。
查询:
SELECT COUNT(*) FROM employees;
结果: 以上语句将计算’employees’表中的行数。
COUNT(*)
5
12. 考虑’employees’表，并编写查询以检索薪水在35000至40000之间的所有员工。
查询:
SELECT empSalary FROM employees
WHERE empSalary
BETWEEN 35000 AND 40000;
结果: 以上语句将检索出工资在35000和40000之间的“employees”表中的所有员工。
| empId | empName | empAge | empAddress | empSalary |
|---|---|---|---|---|
| 2 | Ananya | 30 | Bhopal | 37000 |
| 3 | Aarush | 32 | Jaipur | 35000 |
| 4 | Reyansh | 30 | Bhopal | 40000 |
| 5 | Jhalak | 28 | Jaipur | 39000 |
13. 考虑“employees”表，写出添加一个名为“Department”的新列的查询。
查询:
ALTER TABLE employees ADD Department VARCHAR(45);
结果: 由于在新的列’department’中没有插入任何值，因此默认情况下它包含NULL。
| empId | empName | empAge | empAddress | empSalary | Department |
|---|---|---|---|---|---|
| 1 | Daksh | 25 | Jaipur | 32000 | NULL |
| 2 | Ananya | 30 | Bhopal | 37000 | NULL |
| 3 | Aarush | 32 | Jaipur | 35000 | NULL |
| 4 | Reyansh | 30 | Bhopal | 40000 | NULL |
| 5 | Jhalak | 28 | Jaipur | 39000 | NULL |
14. 考虑一个名为’products’的表，其字段包括product_id、product_name、product_quantity和product_price。
| product_id | product_name | product_quantity | product_price |
|---|---|---|---|
| 1 | Speaker | 2 | 10000 |
| 2 | Printer | 1 | 21000 |
| 3 | Key Board | 5 | 2500 |
| 4 | Refill Cartridge | 6 | 1500 |
| 5 | CD Drive | 4 | 2000 |
i) 编写查询以计算’products’表中’product_price’列中值的总和。
查询:
SELECT SUM(product_price)
FROM products;
结果：
SUM(product_price)
37000
ii) 编写查询以计算“产品”表中“product_price”列的平均值。
查询：
SELECT AVG(product_price)
FROM products;
结果：
AVG(product_price)
7400
iii) 编写查询语句以从’products’表中检索 ‘product_price’ 列中的最小值。
查询：
SELECT MIN(product_price)
FROM products;
结果：
MIN(product_price)
1500
iv）编写查询以从“products”表的“product_price”列中检索最大值。
查询：
SELECT MAX(product_price)
FROM products;
结果：
MAX(product_price)
21000
V) 编写查询以对“产品表”中的“product_price”列进行分组记录和计算聚合函数。
查询：
SELECT product_price, COUNT(product_price), AVG(product_price)
FROM products GROUP BY product_price;
结果：
| 产品价格 | COUNT(产品价格) | 过程（产品价格） |
|---|---|---|
| 10000 | 1 | 10000 |
| 21000 | 1 | 21000 |
| 2500 | 1 | 2500 |
| 1500 | 1 | 1500 |
| 2000 | 1 | 2000 |
15. 考虑一个名为’mobilephones’的表，其中有字段如Id，Name，Company，Quantity和Price。
| Id | Name | Company | 颜色 | 数量 | 价格 |
|---|---|---|---|---|---|
| 1 | 三星Galaxy A23 | 三星 | 蓝色 | 1 | 20000 |
| 2 | iPhone 13 迷你版 | 苹果 | 粉色 | 2 | 65000 |
| 3 | iPhone 12 | 苹果 | 黑色 | 1 | 54000 |
| 4 | 摩托罗拉Edge 30 Fusion | 摩托罗拉 | 活力洋红色 | 2 | 38000 |
| 5 | 三星Galaxy Z Flip3 5G | 三星 | 黑色 | 4 | 48000 |
i) 写一个查询，选取’mobilephones’表中以”bl”开头的’Colour’列中的所有顾客。
查询：
SELECT * FROM mobilephones
WHERE Colour LIKE 'bl%';
结果：
| product_price | COUNT(product_price) | Age(product_price) |
|---|---|---|
| 10000 | 1 | 10000 |
| 21000 | 1 | 21000 |
| 2500 | 1 | 2500 |
| 1500 | 1 | 1500 |
| 2000 | 1 | 2000 |
15. 考虑一个名为’mobilephones’的表，其包含字段Id、Name、Company、Quantity和Price。
| Id | Name | Company | Colour | Quantity | Price |
|---|---|---|---|---|---|
| 1 | Samsung Galaxy A23 | Samsung | Blue | 1 | 20000 |
| 3 | iPhone 12 | Apple | Black | 1 | 54000 |
| 5 | Samsung Galaxy Z Flip3 5G | Samsung | Black | 4 | 48000 |
ii) 编写查询语句，选择’mobilephones’表中’Price’列均值大于45000的所有手机名称。
查询语句：
SELECT Name, AVG(Price)
FROM mobilephones
GROUP BY Name HAVING AVG(Price) > 45000;
结果：
| 名称 | 平均价格 |
|---|---|
| iPhone 13 mini | 65000 |
| iPhone 12 | 54000 |
| 三星 Galaxy Z Flip3 5G | 48000 |
iii) 编写查询以选择所有移动电话名称，其价格列中的总和小于45000。
查询：
SELECT Name, SUM(Price)
FROM mobilephones
GROUP BY Name HAVING SUM(Price) < 45000;
结果：
| 名称 | SUM(价格) |
|---|---|
| 三星 Galaxy A23 | 20000 |
| 摩托罗拉 Edge 30 Fusion | 38000 |
16. 考虑具有Id，firstName，middleName，lastName和Address的“customers”表。
| Id | firstName | middleName | lastName | Address |
|---|---|---|---|---|
| 1 | Shruti | NULL | Bansal | 印度 |
| 2 | NULL | Raj | Singh | 印度 |
| 3 | Aadi | Kumar | NULL | 印度 |
| 4 | Nishtha | NULL | NULL | 孟买 |
| 5 | NULL | NULL | Kapoor | 孟买 |
i) 编写查询以从firstName，middleName和lastName列中返回第一个非空值。
查询：
SELECT Id, Address COALESCE(firstName, middleName, lastName) AS NAME
FROM customers;
结果:
| Id | 地址 | 姓名 |
|---|---|---|
| 1 | 高 | Shruti |
| 2 | 高 | Raj |
| 3 | 高 | Aadi |
| 4 | 孟买 | Nishtha |
| 5 | 孟买 | 卡普尔 |
ii) 写出删除“customers”表中所有行但保持表结构的查询语句。
查询语句:
TRUNCATE TABLE customers;
结果： 如您所见，上述语句已删除了所有行，只保留了表格结构。
| Id | firstName | middleName | lastName | Address |
|---|---|---|---|---|
17. 考虑以下两个表：一个是具有字段如teachers_id、Name、teachers_age和teachers_address的“teachers”表。另一个是具有字段如students_id、Name、students_age和students_address的“students”表。
以下是 “teachers”表：
| teachers_id | Name | teachers_age | teachers_address |
|---|---|---|---|
| 100 | Karishma | 35 | Noida |
| 101 | Yasha | 29 | Meerut |
| 102 | Kartik | 40 | Noida |
| 103 | Milan | 36 | Lucknow |
以下是 “students”表：
| students_id | Name | students_age | students_address |
|---|---|---|---|
| 200 | Harsh | 19 | Noida |
| 201 | Palak | 18 | Lucknow |
| 202 | Himanshi | 20 | Roorkee |
| 203 | Ansh | 19 | Roorkee |
i) 使用UNION运算符将“teachers”表中的“Name”列与“students”表中的“Name”列合并的查询。
查询：
SELECT Name FROM teachers
UNION SELECT Name FROM students;
结果:
Name
卡里什玛
雅莎
卡尔蒂克
米兰
哈什
帕拉克
希曼希
安什
ii) 查询在’teachers’表中年龄在34到41岁之间的教师名字。
查询:
SELECT * FROM teachers
WHERE teachers_age
BETWEEN '34' AND '41';
结果：
| teachers_id | 姓名 | teachers_age | teachers_address |
|---|---|---|---|
| 100 | Karishma | 35 | Noida |
| 102 | Kartik | 40 | Noida |
| 103 | Milan | 36 | Lucknow |
结论：
在本文中，您学习了几个用于练习的SQL查询。您已经阅读了一些基于实际生活的问题，并使用SQL查询来解决它们。如果您想熟练地管理和检索数据库中的数据，练习SQL查询是很重要的。
通过经常练习，您可以正确地理解SQL语法，并改进查询优化技术。您可以轻松地识别和纠正错误。如果您掌握了SQL查询，您将能够从数据库中提取有价值的见解，并做出基于数据的决策，这将有助于推动您的职业发展。