最新国产好看的视频,伊人天堂AV在线,国产Aaaaaa视频,蜜臀视频在线观看一区,人妻av色图,密臀久久久精品影片,青青视频免费观看毛片,久草在线观看视,国产三级精品色情在线

MySQL 多表聯(lián)合查詢與數(shù)據備份恢復全攻略

 更新時間：2025年09月18日 09:16:38   作者：Sadsvit  
本文系統(tǒng)講解MySQL多表聯(lián)合查詢的五種核心方式（交叉連接、內連接、外連接、分組查詢、子查詢）,并涵蓋數(shù)據備份與恢復的完整流程,結合實戰(zhàn)案例與效果驗證,保障數(shù)據安全與高效查詢,感興趣的朋友跟隨小編一起看看吧

MySQL 多表聯(lián)合查詢與數(shù)據備份恢復全指南

在關系型數(shù)據庫中，表與表通過外鍵等關聯(lián)字段建立聯(lián)系，實際業(yè)務場景常需同時查詢多個表的關聯(lián)數(shù)據，這就需要多表聯(lián)合查詢。此外，數(shù)據安全是數(shù)據庫管理的核心，定期備份與高效恢復是保障數(shù)據不丟失的關鍵。本文將系統(tǒng)講解 MySQL 多表聯(lián)合查詢的5種核心方式（交叉連接、內連接、外連接、分組查詢、子查詢），并詳細說明數(shù)據庫備份與恢復的完整流程，包含實戰(zhàn)案例與效果驗證。

一、多表聯(lián)合查詢基礎

1. 什么是多表聯(lián)合查詢

前面講解的查詢語句均針對單個表，但關系型數(shù)據庫中表與表存在業(yè)務關聯(lián)（如“學生表”與“課程表”通過“課程ID”關聯(lián)），多表聯(lián)合查詢即同時查詢兩個或兩個以上的表，通過關聯(lián)條件提取整合數(shù)據，滿足復雜業(yè)務需求（如“查詢學生姓名及對應課程名稱”）。

在 MySQL 中，多表查詢主要分為 交叉連接、內連接、外連接、分組查詢、子查詢 5種，核心是通過“關聯(lián)條件”消除無效數(shù)據，確保查詢結果的準確性與實用性。

二、多表聯(lián)合查詢的5種方式

1. 交叉連接（CROSS JOIN）——笛卡爾積查詢

交叉連接是最基礎的多表查詢方式，分為顯式交叉連接和隱式交叉連接，核心是返回兩張表的“笛卡爾積”，但實際應用中需謹慎使用（易產生大量無效數(shù)據）。

（1）核心概念：笛卡爾積

笛卡爾積（Cartesian product）是數(shù)學中兩個集合的乘積，表與表的交叉連接本質就是計算笛卡爾積：

  • 假設集合 A = {1,2}，集合 B = {3,4,5}；
  • 笛卡爾積 A×B = {(1,3), (1,4), (1,5), (2,3), (2,4), (2,5)}；
  • 表的笛卡爾積：結果行數(shù) = 表1行數(shù) × 表2行數(shù)，字段數(shù) = 表1字段數(shù) + 表2字段數(shù)。

注意：笛卡爾積不滿足交換律（A×B ≠ B×A），且包含大量無業(yè)務意義的數(shù)據（如“學生A對應所有課程”），需通過 WHERE 子句篩選有效數(shù)據。

（2）語法格式
-- 顯式交叉連接（官方推薦）
SELECT <字段名> FROM <表1> CROSS JOIN <表2> [WHERE 子句];
-- 隱式交叉連接（逗號分隔表名）
SELECT <字段名> FROM <表1>, <表2> [WHERE 子句];
  • 字段名：可指定表別名（如 表1.字段1 AS 別名），避免字段名重復；
  • WHERE 子句：可選，用于篩選笛卡爾積中的有效數(shù)據（無此子句則返回完整笛卡爾積）。
（3）實戰(zhàn)案例

以“學生信息表（tb_students_info）”和“課程表（tb_course）”為例，演示交叉連接的使用：

步驟1：創(chuàng)建并查看兩張表的原始數(shù)據：

mysql> create database xuexiao;
Query OK, 1 row affected (0.00 sec)
mysql> use xuexiao;
Database changed
mysql> show tables;
Empty set (0.00 sec)
mysql> CREATE TABLE IF NOT EXISTS tb_course (
    -> id INT PRIMARY KEY AUTO_INCREMENT,
    -> course_name VARCHAR(50) NOT NULL
    -> );
Query OK, 0 rows affected (0.00 sec)
mysql> CREATE TABLE IF NOT EXISTS tb_students_info(
    -> id INT PRIMARY KEY AUTO_INCREMENT,
    -> name VARCHAR(50)  NOT NULL,
    -> age INT,
    -> sex VARCHAR(10),
    -> height INT,
    -> course_id INT,
    -> FOREIGN KEY (course_id) REFERENCES tb_course(id)
    -> );
Query OK, 0 rows affected (0.00 sec)
mysql> INSERT INTO tb_course (course_name) VALUES 
    -> ('Java'),('MySQL'),('Python'),('Go'),('C++');
Query OK, 5 rows affected (0.00 sec)
Records: 5  Duplicates: 0  Warnings: 0
mysql> ALTER TABLE tb_students_info 
    -> MODIFY COLUMN sex VARCHAR(10) 
    -> CHARACTER SET utf8mb4 
    -> COLLATE utf8mb4_unicode_ci;
Query OK, 0 rows affected (0.01 sec)
Records: 0  Duplicates: 0  Warnings: 0
mysql> INSERT INTO tb_students_info (name, age, sex, height, course_id) VALUES
    -> ('Dany', 25, '男', 160, 1),
    -> ('Green', 23, '男', 158, 2),
    -> ('Henry', 23, '女', 185, 1),
    -> ('Jane', 22, '男', 162, 3),
    -> ('Jim', 24, '女', 175, 2),
    -> ('John', 21, '女', 172, 4),
    -> ('Lily', 22, '男', 165, 4),
    -> ('Susan', 23, '男', 170, 5),
    -> ('Thomas', 22, '女', 178, 5),
    -> ('Tom', 23, '女', 165, 5);
Query OK, 10 rows affected (0.00 sec)
Records: 10  Duplicates: 0  Warnings: 0
mysql> ALTER TABLE tb_students_info 
    -> MODIFY COLUMN sex VARCHAR(10) 
    -> CHARACTER SET utf8mb4 
    -> COLLATE utf8mb4_unicode_ci;
Query OK, 0 rows affected (0.01 sec)
Records: 0  Duplicates: 0  Warnings: 0
-- 查看學生信息表
mysql> SELECT * FROM tb_students_info;
+----+--------+------+------+--------+-----------+
| id | name   | age  | sex  | height | course_id |  -- course_id：關聯(lián)課程表的外鍵
+----+--------+------+------+--------+-----------+
|  1 | Dany   |   25 | 男   |    160 |         1 |
|  2 | Green  |   23 | 男   |    158 |         2 |
|  3 | Henry  |   23 | 女   |    185 |         1 |
|  4 | Jane   |   22 | 男   |    162 |         3 |
|  5 | Jim    |   24 | 女   |    175 |         2 |
|  6 | John   |   21 | 女   |    172 |         4 |
|  7 | Lily   |   22 | 男   |    165 |         4 |
|  8 | Susan  |   23 | 男   |    170 |         5 |
|  9 | Thomas |   22 | 女   |    178 |         5 |
| 10 | Tom    |   23 | 女   |    165 |         5 |
+----+--------+------+------+--------+-----------+
10 rows in set (0.00 sec)

-- 查看課程表
mysql> SELECT * FROM tb_course;
+----+-------------+
| id | course_name |  -- id：主鍵，與學生表的 course_id 關聯(lián)
+----+-------------+
|  1 | Java        |
|  2 | MySQL       |
|  3 | Python      |
|  4 | Go          |
|  5 | C++         |
+----+-------------+
5 rows in set (0.00 sec)

步驟2：查詢完整笛卡爾積（無 WHERE 子句）

mysql> SELECT * FROM tb_course CROSS JOIN tb_students_info;
+----+-------------+----+--------+------+------+--------+-----------+
| id | course_name | id | name   | age  | sex  | height | course_id |
+----+-------------+----+--------+------+------+--------+-----------+
|  1 | Java        |  1 | Dany   |   25 | 男   |    160 |         1 |
|  2 | MySQL       |  1 | Dany   |   25 | 男   |    160 |         1 |
|  3 | Python      |  1 | Dany   |   25 | 男   |    160 |         1 |
|  4 | Go          |  1 | Dany   |   25 | 男   |    160 |         1 |
|  5 | C++         |  1 | Dany   |   25 | 男   |    160 |         1 |
                      *****省略中間 40 行******
|  5 | C++         | 10 | Tom    |   23 | 女   |    165 |         5 |
+----+-------------+----+--------+------+------+--------+-----------+
50 rows in set (0.00 sec)

結果分析：返回 10×5=50 行數(shù)據，包含大量無效關聯(lián)（如“Dany 對應所有課程”），實際業(yè)務中幾乎不用此方式。

步驟3：帶 WHERE 子句的交叉連接（篩選有效數(shù)據）

通過 WHERE 子句匹配“課程表 id”與“學生表 course_id”，消除無效數(shù)據：

mysql> SELECT * FROM tb_course CROSS JOIN tb_students_info 
    -> WHERE tb_students_info.course_id = tb_course.id;
+----+-------------+----+--------+------+------+--------+-----------+
| id | course_name | id | name   | age  | sex  | height | course_id |
+----+-------------+----+--------+------+------+--------+-----------+
|  1 | Java        |  1 | Dany   |   25 | 男   |    160 |         1 |
|  1 | Java        |  3 | Henry  |   23 | 女   |    185 |         1 |
|  2 | MySQL       |  2 | Green  |   23 | 男   |    158 |         2 |
|  2 | MySQL       |  5 | Jim    |   24 | 女   |    175 |         2 |
|  3 | Python      |  4 | Jane   |   22 | 男   |    162 |         3 |
|  4 | Go          |  6 | John   |   21 | 女   |    172 |         4 |
|  4 | Go          |  7 | Lily   |   22 | 男   |    165 |         4 |
|  5 | C++         |  8 | Susan  |   23 | 男   |    170 |         5 |
|  5 | C++         |  9 | Thomas |   22 | 女   |    178 |         5 |
|  5 | C++         | 10 | Tom    |   23 | 女   |    165 |         5 |
+----+-------------+----+--------+------+------+--------+-----------+
10 rows in set (0.00 sec)

結果分析：僅返回 10 行有效數(shù)據，與學生表行數(shù)一致，實現(xiàn)“學生-課程”的正確關聯(lián)。

（4）注意事項
  • 交叉連接效率低：MySQL 會先生成完整笛卡爾積，再篩選有效數(shù)據，表數(shù)據量大時（如各1000行）會產生 100萬行臨時數(shù)據，嚴重影響性能；
  • 替代方案：實際多表查詢優(yōu)先使用“內連接”或“外連接”，效率更高且語法更清晰。

2. 內連接（INNER JOIN）——篩選匹配數(shù)據

內連接是最常用的多表查詢方式，通過 INNER JOIN 關鍵字和 ON 子句設置關聯(lián)條件，僅返回兩張表中滿足關聯(lián)條件的記錄，自動消除無效數(shù)據，無需手動篩選笛卡爾積。

（1）核心邏輯

內連接的本質是“交集查詢”：僅保留表1和表2中“關聯(lián)字段值相等”的記錄，不滿足條件的記錄（如“無對應課程的學生”“無學生的課程”）會被過濾。

（2）語法格式
SELECT <字段名> FROM <表1> INNER JOIN <表2> ON <關聯(lián)條件>;
-- 簡化寫法：INNER 可省略，直接用 JOIN
SELECT <字段名> FROM <表1> JOIN <表2> ON <關聯(lián)條件>;
  • ON 子句：必選，用于定義表間關聯(lián)條件（如 表1.外鍵 = 表2.主鍵），優(yōu)先級高于 WHERE 子句；
  • 多表內連接：連續(xù)使用 JOIN 即可，如 表1 JOIN 表2 ON 條件1 JOIN 表3 ON 條件2。
（3）實戰(zhàn)案例：查詢學生姓名及對應課程名稱

需求：從 tb_students_info 和 tb_course 中，查詢學生姓名（name）及對應課程名稱（course_name），關聯(lián)條件為“學生表 course_id = 課程表 id”。

-- 給表設置別名（s 代表學生表，c 代表課程表），簡化語法
mysql> SELECT s.name, c.course_name 
    -> FROM tb_students_info s 
    -> INNER JOIN tb_course c 
    -> ON s.course_id = c.id;
+--------+-------------+
| name   | course_name |
+--------+-------------+
| Dany   | Java        |
| Henry  | Java        |
| Green  | MySQL       |
| Jim    | MySQL       |
| Jane   | Python      |
| John   | Go          |
| Lily   | Go          |
| Susan  | C++         |
| Thomas | C++         |
| Tom    | C++         |
+--------+-------------+
10 rows in set (0.00 sec)
（4）關鍵說明
  • 表別名：當表名較長時，用 表名 別名 簡化寫法（如 tb_students_info s），后續(xù)通過“別名.字段”引用字段；
  • 字段唯一性：若兩張表有同名字段（如 id），需顯式指定表名或別名（如 s.id 或 c.id），避免歧義；
  • 效率優(yōu)勢：內連接直接按關聯(lián)條件匹配數(shù)據，無需生成完整笛卡爾積，效率遠高于交叉連接。

3. 外連接（LEFT/RIGHT JOIN）——保留部分表的全部數(shù)據

內連接僅返回“雙方匹配”的記錄，而外連接會以一張表為“基表”，保留基表的全部記錄，另一張表（參考表）匹配不到的記錄用 NULL 填充，適用于“需保留所有基表數(shù)據”的場景（如“查詢所有學生，包括無課程的學生”）。

外連接分為 左外連接（LEFT JOIN） 和 右外連接（RIGHT JOIN），核心區(qū)別是“基表的選擇”。

（1）左外連接（LEFT OUTER JOIN）
  • 定義：以 LEFT JOIN 左側的表為基表，保留基表的全部記錄，右側表（參考表）匹配到則顯示對應數(shù)據，匹配不到則字段值為 NULL；
  • 語法：SELECT 字段 FROM 基表 LEFT OUTER JOIN 參考表 ON 關聯(lián)條件;（OUTER 可省略，簡化為 LEFT JOIN）；
  • 核心場景：需保留左側表的所有數(shù)據（如“查詢所有學生，包括無課程的學生”）。

實戰(zhàn)案例：查詢所有學生及對應課程（含無課程的學生）

步驟1：先添加“無課程的學生”（course_id=7，課程表無 id=7 的課程）：

-- 臨時禁用外鍵約束
ysql> SET FOREIGN_KEY_CHECKS=0;  
Query OK, 0 rows affected (0.01 sec)
mysql> INSERT INTO tb_students_info (name, age, sex, height, course_id) 
    -> VALUES ('LiMing', 22, '男', 180, 7);
Query OK, 1 row affected (0.01 sec)
-- 恢復外鍵約束
mysql> SET FOREIGN_KEY_CHECKS=1;
Query OK, 0 rows affected (0.00 sec)

步驟2：執(zhí)行左外連接查詢：

mysql> SELECT s.name, c.course_name 
    -> FROM tb_students_info s
    -> LEFT JOIN tb_course c
    -> ON s.course_id = c.id;
+--------+-------------+
| name   | course_name |
+--------+-------------+
| Dany   | Java        |
| Henry  | Java        |
| Green  | MySQL       |
| Jim    | MySQL       |
| Jane   | Python      |
| John   | Go          |
| Lily   | Go          |
| Susan  | C++         |
| Thomas | C++         |
| Tom    | C++         |
| LiMing | C++         |
| LiMing | NULL        |  # 無對應課程，course_name 為null
+--------+-------------+
12 rows in set (0.00 sec)

結果分析：基表（學生表）的 11 條記錄全部保留，LiMing 因無對應課程，課程名稱顯示 NULL。

（2）右外連接（RIGHT OUTER JOIN）
  • 定義：以 RIGHT JOIN 右側的表為基表，保留基表的全部記錄，左側表（參考表）匹配不到則字段值為 NULL；
  • 語法：SELECT 字段 FROM 參考表 RIGHT OUTER JOIN 基表 ON 關聯(lián)條件;（OUTER 可省略，簡化為 RIGHT JOIN）；
  • 核心場景：需保留右側表的所有數(shù)據（如“查詢所有課程，包括無學生的課程”）。

實戰(zhàn)案例：查詢所有課程及對應學生（含無學生的課程）

步驟1：先添加“無學生的課程”（id=6，學生表無 course_id=6 的記錄）：

mysql> INSERT INTO tb_course (id, course_name) 
    -> VALUES (6, 'HTML');
Query OK, 1 row affected (0.00 sec)

步驟2：執(zhí)行右外連接查詢：

mysql> SELECT s.name, c.course_name 
    -> FROM tb_students_info s 
    -> RIGHT JOIN tb_course c 
    -> ON s.course_id = c.id;
+--------+-------------+
| name   | course_name |
+--------+-------------+
| Dany   | Java        |
| Henry  | Java        |
| Green  | MySQL       |
| Jim    | MySQL       |
| Jane   | Python      |
| John   | Go          |
| Lily   | Go          |
| Susan  | C++         |
| Thomas | C++         |
| Tom    | C++         |
| LiMing | C++         |
| NULL   | HTML        |
+--------+-------------+
12 rows in set (0.01 sec)

結果分析：基表（課程表）的 6 條記錄全部保留，HTML 課程因無學生，學生姓名顯示 NULL。

（3）外連接的關鍵區(qū)別
連接類型基表保留數(shù)據參考表匹配不到時適用場景
左外連接LEFT 左側表左側表全部記錄右側表字段為 NULL保留左側表所有數(shù)據
右外連接RIGHT 右側表右側表全部記錄左側表字段為 NULL保留右側表所有數(shù)據

4. 分組查詢（GROUP BY）——按字段分組統(tǒng)計

分組查詢通過 GROUP BY 關鍵字，按一個或多個字段對查詢結果分組，常與 聚合函數(shù)（如 COUNT()、SUM()）結合，實現(xiàn)數(shù)據統(tǒng)計（如“按性別統(tǒng)計學生人數(shù)”）。

（1）核心語法
SELECT <分組字段>, <聚合函數(shù)> 
FROM <表名> 
[JOIN <關聯(lián)表> ON <條件>] 
[WHERE <篩選條件>] 
GROUP BY <分組字段> [WITH ROLLUP];
  • 聚合函數(shù)：COUNT()（統(tǒng)計行數(shù)）、SUM()（求和）、AVG()（平均值）、MAX()（最大值）、MIN()（最小值）；
  • WITH ROLLUP：可選，在所有分組后追加一行“總計”記錄；
  • 執(zhí)行順序：WHERE（篩選行）→ GROUP BY（分組）→ 聚合函數(shù)（統(tǒng)計）。
（2）實戰(zhàn)案例

案例1：按性別分組，統(tǒng)計學生人數(shù)

mysql> SELECT sex, COUNT(*) AS student_count 
    -> FROM tb_students_info 
    -> GROUP BY sex;
+------+---------------+
| sex  | student_count |
+------+---------------+
| 女   |             5 |
| 男   |             6 |
+------+---------------+
2 rows in set (0.00 sec)

案例2：按性別分組，顯示每組學生姓名（GROUP_CONCAT()）

GROUP_CONCAT() 函數(shù)可將分組內的指定字段值拼接為字符串：

mysql> SELECT sex, GROUP_CONCAT(name) AS student_names 
    -> FROM tb_students_info 
    -> GROUP BY sex;
+------+----------------------------------------+
| sex  | student_names                           |
+------+----------------------------------------+
| 女   | Henry,Jim,John,Thomas,Tom               |
| 男   | Dany,Green,Jane,Lily,Susan,LiMing       |
+------+----------------------------------------+
2 rows in set (0.00 sec)

案例3：按“年齡+性別”多字段分組

多字段分組時，先按第一個字段分組，第一個字段值相同時再按第二個字段分組：

mysql> SELECT age, sex, GROUP_CONCAT(name) AS student_names 
    -> FROM tb_students_info 
    -> GROUP BY age, sex;
+------+------+------------------+
| age  | sex  | student_names    |
+------+------+------------------+
|   21 | 女   | John             |
|   22 | 女   | Thomas           |
|   22 | 男   | Jane,Lily,LiMing |
|   23 | 女   | Henry,Tom        |
|   23 | 男   | Green,Susan      |
|   24 | 女   | Jim              |
|   25 | 男   | Dany             |
+------+------+------------------+
7 rows in set (0.00 sec)

案例4：分組后添加總計（WITH ROLLUP）

mysql> SELECT sex, COUNT(*) AS student_count 
    -> FROM tb_students_info 
    -> GROUP BY sex WITH ROLLUP;
+------+---------------+
| sex  | student_count |
+------+---------------+
| 女   |             5 |
| 男   |             6 |
| NULL |            11 |  
+------+---------------+
3 rows in set (0.00 sec)

5. 子查詢——嵌套查詢實現(xiàn)復雜邏輯

子查詢（嵌套查詢）是將一個查詢語句（子查詢）嵌套在另一個查詢語句（父查詢）中，子查詢的結果作為父查詢的條件或數(shù)據源，適用于“需先獲取中間結果”的復雜場景（如“查詢學習 Java 課程的學生姓名”）。

（1）核心語法

子查詢常位于 WHERE 子句中，格式如下：

SELECT <父查詢字段> 
FROM <父查詢表> 
WHERE <表達式> <操作符> (子查詢);
  • 操作符：支持 IN/NOT IN（匹配子查詢結果集中的值）、EXISTS/NOT EXISTS（判斷子查詢結果集是否為空）、=/<>（等于/不等于子查詢結果，子查詢需返回單行單列）。
（2）實戰(zhàn)案例

案例1：查詢學習 Java 課程的學生姓名（IN 關鍵字）

需求：先查詢“Java 課程的 id”，再根據 id 查詢對應學生姓名。

-- 子查詢：獲取 Java 課程的 id
mysql> SELECT id FROM tb_course WHERE course_name = 'Java';
+----+
| id |
+----+
|  1 |
+----+
1 row in set (0.00 sec)

-- 父查詢：根據 id=1 查詢學生姓名
mysql> SELECT name 
    -> FROM tb_students_info 
    -> WHERE course_id IN (SELECT id FROM tb_course WHERE course_name = 'Java');
+-------+
| name  |
+-------+
| Dany  |
| Henry |
+-------+
2 rows in set (0.01 sec)

案例2：查詢沒有學習 Java 課程的學生姓名（NOT IN 關鍵字）

mysql> SELECT name 
    -> FROM tb_students_info 
    -> WHERE course_id NOT IN (SELECT id FROM tb_course WHERE course_name = 'Java');
+--------+
| name   |
+--------+
| Green  |
| Jane   |
| Jim    |
| John   |
| Lily   |
| Susan  |
| Thomas |
| Tom    |
| LiMing |
+--------+
9 rows in set (0.00 sec)

案例3：判斷課程是否存在，再查詢學生（EXISTS 關鍵字）

EXISTS 僅判斷子查詢結果集是否為空（不為空則返回 TRUE，為空則返回 FALSE），不關心具體值：

-- 若存在 id=1 的課程（Java），則查詢所有學生
mysql> SELECT * 
    -> FROM tb_students_info 
    -> WHERE EXISTS (SELECT course_name FROM tb_course WHERE id=1);
+----+--------+------+------+--------+-----------+
| id | name   | age  | sex  | height | course_id |
+----+--------+------+------+--------+-----------+
|  1 | Dany   |   25 | 男   |    160 |         1 |
|  2 | Green  |   23 | 男   |    158 |         2 |
|  3 | Henry  |   23 | 女   |    185 |         1 |
|  4 | Jane   |   22 | 男   |    162 |         3 |
|  5 | Jim    |   24 | 女   |    175 |         2 |
|  6 | John   |   21 | 女   |    172 |         4 |
|  7 | Lily   |   22 | 男   |    165 |         4 |
|  8 | Susan  |   23 | 男   |    170 |         5 |
|  9 | Thomas |   22 | 女   |    178 |         5 |
| 10 | Tom    |   23 | 女   |    165 |         5 |
| 15 | LiMing |   22 | 男   |    180 |         7 |
+----+--------+------+------+--------+-----------+
11 rows in set (0.00 sec)

案例4：多條件結合 EXISTS（查詢年齡>24 的學生）

mysql> SELECT * 
    -> FROM tb_students_info 
    -> WHERE age>24 AND EXISTS (SELECT course_name FROM tb_course WHERE id=1);
+----+------+------+------+--------+-----------+
| id | name | age  | sex  | height | course_id |
+----+------+------+------+--------+-----------+
|  1 | Dany |   25 | 男   |    160 |         1 |
+----+------+------+------+--------+-----------+
1 row in set (0.01 sec)
（3）子查詢 vs 表連接
  • 子查詢：語法更直觀，適合“先獲取中間結果”的場景（如先查課程 id 再查學生），但多層嵌套時效率可能較低；
  • 表連接：效率更高，適合“直接關聯(lián)表獲取數(shù)據”的場景（如學生表 join 課程表），但復雜邏輯時可讀性較差；
  • 選擇原則：簡單關聯(lián)用表連接，復雜中間邏輯用子查詢。

到此這篇關于MySQL 多表聯(lián)合查詢與數(shù)據備份恢復全攻略的文章就介紹到這了,更多相關mysql多表聯(lián)合查詢內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

相關文章

  • MySQL之范式的使用詳解

    MySQL之范式的使用詳解

    這篇文章主要介紹了MySQL之范式的使用詳解，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧
    2020-10-10
  • 如何設置mysql數(shù)據庫只讀權限用戶及全部權限

    如何設置mysql數(shù)據庫只讀權限用戶及全部權限

    MySQL數(shù)據庫所有用戶權限是指MySQL數(shù)據庫中可以對數(shù)據庫和表進行操作的權限,這篇文章主要介紹了如何設置mysql數(shù)據庫只讀權限用戶及全部權限的相關資料,文中通過代碼介紹的非常詳細,需要的朋友可以參考下
    2025-11-11
  • MySQL中的鎖和MVCC機制解讀

    MySQL中的鎖和MVCC機制解讀

    MySQL事務、鎖和MVCC機制是確保數(shù)據庫操作原子性、一致性和隔離性的關鍵,事務必須遵循ACID原則,鎖的類型包括表級鎖、行級鎖和意向鎖,MVCC通過非鎖定讀和鎖定讀實現(xiàn)并發(fā)控制,幻讀和死鎖是并發(fā)事務中常見的問題,可以通過預防策略和優(yōu)化技巧解決
    2025-01-01
  • MySQL的事務的基本要素和事務隔離級別詳解

    MySQL的事務的基本要素和事務隔離級別詳解

    這篇文章主要介紹了MySQL的事務的基本要素和事務隔離級別,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教
    2024-04-04
  • mysql的3種分表方案

    mysql的3種分表方案

    這篇文章主要介紹了mysql的3種分表方案,先從為什么要分表說起,然后分析了3種方法的優(yōu)劣勢,最后做了一個總結,需要的朋友可以參考下
    2014-05-05
  • 解決mysql數(shù)據庫導入sql文件不成功的問題

    解決mysql數(shù)據庫導入sql文件不成功的問題

    這篇文章主要介紹了解決mysql數(shù)據庫導入sql文件不成功的問題,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教
    2023-11-11
  • sysbench-0.4.12編譯安裝和CPU測試例子分享

    sysbench-0.4.12編譯安裝和CPU測試例子分享

    這篇文章主要介紹了sysbench-0.4.12編譯安裝和CPU測試例子分享,本文還包含安裝過程中的錯誤及解決方法,使用時的錯誤和解決方法,需要的朋友可以參考下
    2014-07-07
  • MYSQL中統(tǒng)計查詢結果總行數(shù)的便捷方法省去count(*)

    MYSQL中統(tǒng)計查詢結果總行數(shù)的便捷方法省去count(*)

    查看手冊后發(fā)現(xiàn)SQL_CALC_FOUND_ROWS關鍵詞的作用是在查詢時統(tǒng)計滿足過濾條件后的結果的總數(shù)（不受 Limit 的限制）具體使用如下，感興趣的朋友可以學習下
    2013-07-07
  • MySQL頁面訪問統(tǒng)計及排名情況

    MySQL頁面訪問統(tǒng)計及排名情況

    這篇文章主要介紹了MySQL頁面訪問統(tǒng)計及排名情況，涉及到mysql頁面訪問統(tǒng)計，mysql統(tǒng)計排名相關知識，感興趣的朋友一起學習吧
    2016-01-01
  • 解決Access denied for user root @ 192.168.120.1 (using password: YES)的問題

    解決Access denied for user root @&nbs

    這篇文章給大家介紹了解決：Access denied for user ‘root‘@‘192.168.120.1‘ (using password: YES)的問題,文中通過圖文和代碼給大家分析的非常詳細,具有一定的參考價值,需要的朋友可以參考下
    2024-01-01

最新評論

长沙县| 宜君县| 定襄县| 普宁市| 康平县| 内丘县| 芷江| 临汾市| 南涧| 六枝特区| 丹寨县| 五华县| 正阳县| 乌兰察布市| 景宁| 麻江县| 滨州市| 苗栗市| 鹰潭市| 阿瓦提县| 杂多县| 黄浦区| 永善县| 杨浦区| 雅安市| 治多县| 西乌珠穆沁旗| 阳东县| 邓州市| 清苑县| 如皋市| 昭平县| 盐津县| 历史| 鹿泉市| 洛宁县| 云浮市| 宾阳县| 库尔勒市| 迁安市| 台北县|