Oracle数据库之子查询(六)

用于查询：子查询（内查询）在主查询之前执行完成，并将结果返回给主查询（外查询）使用。子查询可以返回单行数据，也可以返回多行数据。如果返回多行数据，可以使用多行比较操作符（如IN、ALL、ANY）来处理。
创建表：你可以使用子查询的结果来创建一个新表。这个新表的列的数据类型、约束等都与子查询返回的结果相同。例如，你可以使用“CREATE TABLE 新表名 AS SELECT 列名 FROM 旧表名”这样的语句来创建新表。

在Oracle中，子查询可以嵌套在SELECT、INSERT、UPDATE和DELETE语句中。例如，你可以使用子查询来检索满足特定条件的记录，或者将子查询的结果作为另一个查询的搜索条件。

为了提高子查询的性能，特别是在处理大量数据时，你可以采取以下措施：

使用内连接（INNER JOIN）代替外连接（OUTER JOIN）：在某些情况下，内连接可以替代外连接来提高查询性能，因为内连接只会返回匹配的行，而外连接会返回所有匹配的行和未匹配的行。
使用索引来加速子查询：为子查询中的列创建索引可以显著提高查询性能。你可以使用CREATE INDEX语句来为表中的列创建索引。

请注意，虽然子查询在Oracle中非常有用，但它们也可能导致性能问题。因此，在使用子查询时，请确保你了解它们的性能影响，并考虑使用其他查询技术来优化性能。

子查询的语法

1. 在SELECT语句中使用子查询

子查询可以在SELECT语句的SELECT列表中作为列的一部分，或者在WHERE子句、HAVING子句中使用。

示例：

-- 在SELECT列表中使用子查询  
SELECT employee_id,   
       last_name,   
       (SELECT COUNT(*) FROM orders WHERE orders.employee_id = employees.employee_id) AS order_count  
FROM employees;  
  
-- 在WHERE子句中使用子查询  
SELECT employee_id, last_name  
FROM employees  
WHERE salary > (SELECT AVG(salary) FROM employees);

2. 在FROM子句中使用子查询（内联视图）

你可以在FROM子句中使用子查询，将其结果作为一个临时表（也称为内联视图）来处理。

示例：

SELECT t.avg_salary, e.employee_id, e.last_name  
FROM (SELECT department_id, AVG(salary) AS avg_salary FROM employees GROUP BY department_id) t  
JOIN employees e ON t.department_id = e.department_id  
WHERE e.salary > t.avg_salary;

3. 在INSERT语句中使用子查询

你可以使用子查询来插入从另一个表或查询中检索的数据。

示例：

INSERT INTO new_employees (employee_id, last_name, salary)  
SELECT employee_id, last_name, salary  
FROM employees  
WHERE department_id = 10;

4. 在UPDATE语句中使用子查询

你可以使用子查询来基于另一个查询的结果更新表中的数据。

示例：

UPDATE employees e  
SET e.salary = e.salary * 1.1  
WHERE e.employee_id IN (SELECT employee_id FROM bonus_recipients);

5. 在DELETE语句中使用子查询

与UPDATE类似，你也可以在DELETE语句中使用子查询来删除满足特定条件的记录。

示例：

DELETE FROM employees  
WHERE employee_id IN (SELECT employee_id FROM terminated_employees);

6. 注意事项：

子查询必须始终放在括号内。
子查询可以返回单行、单列数据，也可以返回多行、多列数据，具体取决于你的需求和主查询的上下文。
子查询的性能可能受到数据量和索引的影响。确保你的查询已经针对性能进行了优化。
在使用子查询时，请确保你的查询逻辑是正确的，以避免意外的结果或错误。

子查询的类型

在Oracle中，子查询可以根据其返回的结果和用途进行分类。以下是Oracle子查询的一些常见类型：

1. 单行子查询（Single-Row Subqueries）：

这种子查询返回单行数据，通常与比较运算符（如=、>、<等）一起使用。
示例：SELECT * FROM employees WHERE salary = (SELECT MAX(salary) FROM employees);

2. 多行子查询（Multi-Row Subqueries）：

这种子查询返回多行数据，通常与集合比较运算符（如IN、NOT IN、ANY、ALL等）一起使用。
示例：SELECT * FROM employees WHERE department_id IN (SELECT department_id FROM departments WHERE location = 'New York');

3. 关联子查询（Correlated Subqueries）：

关联子查询是依赖于外部查询的子查询，这意味着它的执行依赖于外部查询的每一行。
在关联子查询中，子查询引用了外部查询中的列。
示例：SELECT employee_id, last_name, salary FROM employees e1 WHERE salary > (SELECT AVG(salary) FROM employees e2 WHERE e2.department_id = e1.department_id);

4. 非关联子查询（Non-Correlated Subqueries）：

非关联子查询不依赖于外部查询，它可以单独执行。
在非关联子查询中，子查询不引用外部查询中的任何列。

5. 内联视图（Inline Views）：

内联视图也被称为子选择或派生表，它在FROM子句中定义，并作为一个临时表在查询中使用。
内联视图允许你在查询中创建一个临时的结果集，并对其进行操作，就像它是一个真正的表一样。
示例：SELECT * FROM (SELECT employee_id, last_name, salary FROM employees WHERE department_id = 10) WHERE salary > 5000;

6. EXISTS 和 NOT EXISTS 子查询：

这些子查询用于检查子查询是否返回任何结果。它们返回一个布尔值（TRUE或FALSE）。
示例：SELECT * FROM employees e1 WHERE EXISTS (SELECT 1 FROM orders o WHERE o.employee_id = e1.employee_id);

7. 多列子查询（Multiple-Column Subqueries）：

这种子查询返回多列数据，通常与多列的比较一起使用。
示例：假设我们有一个jobs表，其中包含job_id和min_salary列，我们可以使用多列子查询来查找满足特定条件的员工：SELECT * FROM employees WHERE (job_id, salary) IN (SELECT job_id, min_salary FROM jobs);

请注意，子查询可以嵌套在其他子查询中，形成复杂的查询结构。然而，过度嵌套可能会导致查询性能下降，因此应谨慎使用。

单行子查询

在Oracle中，单行子查询是返回单个值（即单行单列）的子查询。这种子查询通常与比较运算符（如=、<、>等）一起使用，用于在外部查询的WHERE子句或SELECT列表中设置条件或获取值。

以下是一些单行子查询的示例：

示例 1：在SELECT列表中使用单行子查询

假设我们有两个表：employees（员工表）和departments（部门表）。我们想要获取每个员工的部门名称（而不是部门ID）。为此，我们可以在SELECT列表中使用单行子查询。

SELECT employee_id, last_name,   
       (SELECT department_name FROM departments WHERE department_id = employees.department_id) AS department_name  
FROM employees;

示例 2：在WHERE子句中使用单行子查询

假设我们想要找到工资最高的员工。我们可以使用单行子查询来获取最高工资，然后在外部查询的WHERE子句中使用这个值。

SELECT employee_id, last_name, salary  
FROM employees  
WHERE salary = (SELECT MAX(salary) FROM employees);

注意：如果有多个员工具有相同的最高工资，这个查询只会返回其中一个。

示例 3：在HAVING子句中使用单行子查询（尽管不常见）

HAVING子句通常与GROUP BY一起使用，用于对聚合函数的结果进行过滤。虽然单行子查询在HAVING子句中不常见，但理论上仍然可以使用。

SELECT department_id, MAX(salary) AS max_salary  
FROM employees  
GROUP BY department_id  
HAVING MAX(salary) > (SELECT AVG(salary) FROM employees);

这个查询会返回那些部门中最高工资超过全体员工平均工资的部门ID和对应的最高工资。

注意事项：

单行子查询必须只返回一个值。如果返回多个值，将会导致错误。
为了提高性能，确保在子查询和主查询中涉及的表和列都已正确索引。
尽量避免在子查询中使用复杂的逻辑或大量的数据操作，因为这可能会影响查询的整体性能。

非法使用单行子查询

当在Oracle中非法使用单行子查询时，通常意味着子查询没有按预期返回单行单列的值，或者子查询的使用方式不正确。以下是一些非法使用单行子查询的示例：

示例 1：子查询返回多行

当子查询预期返回单行但实际上返回了多行时，会导致错误。

SELECT employee_id, last_name  
FROM employees  
WHERE salary = (SELECT salary FROM some_other_table); -- 如果some_other_table中有多个salary值，则错误

如果some_other_table中有多个salary值，上面的子查询将返回多行，而外部查询的WHERE子句期望一个单独的值进行比较。这会导致ORA-01427: single-row subquery returns more than one row错误。

示例 2：子查询没有返回任何行

虽然这不一定是非法的，但如果子查询没有返回任何行，并且外部查询依赖于这个值（例如，在=操作中），则可能无法得到预期的结果。

SELECT employee_id, last_name  
FROM employees  
WHERE salary = (SELECT salary FROM some_other_table WHERE non_existent_condition = 1); -- 没有行满足条件

如果WHERE non_existent_condition = 1永远为假，则子查询不返回任何行，外部查询的WHERE子句将不匹配任何行。这不会引发错误，但可能不是您想要的结果。

示例 3：在需要多行的地方使用单行子查询

如果您需要在外部查询中匹配多行（例如，在IN操作中），但错误地使用了单行子查询，则会导致问题。

SELECT employee_id, last_name  
FROM employees  
WHERE department_id = (SELECT department_id FROM departments WHERE location = 'New York'); -- 如果有多个部门在New York

如果departments表中有多个部门的location为'New York'，则子查询将返回多行，但外部查询的WHERE子句期望一个单独的值。这会导致ORA-01427错误。在这种情况下，您应该使用IN代替=，或者确保子查询只返回单行。

示例 4：在聚合函数外部使用单行子查询

虽然这不一定是非法的，但在某些情况下，将单行子查询与聚合函数混合使用可能会导致逻辑错误或性能问题。

SELECT department_id, MAX(salary)  
FROM employees  
WHERE salary = (SELECT AVG(salary) FROM employees); -- 逻辑上可能不正确或没有意义

在这个例子中，我们试图找到其工资等于全体员工平均工资的员工所在的部门ID和最高工资。这通常不是很有意义，因为很可能没有员工的工资恰好等于平均工资。此外，即使有这样的员工，这个查询也只会返回单个部门ID（如果有多个部门有符合条件的员工，则只会选择其中一个）。

总结

在使用单行子查询时，请确保子查询确实只返回单行单列的值，并且该值在外部查询的上下文中是有意义的。如果您需要匹配多行，请考虑使用IN、EXISTS或其他适当的构造。

多行子查询

在 Oracle 数据库中，当子查询返回多行结果时，我们通常称之为多行子查询。这种子查询不能直接用于需要单个值的上下文中，如 = 操作符，但可以用于其他可以接受多行输入的上下文中，如 IN、ANY、ALL、EXISTS 等。

以下是一些使用多行子查询的示例：

示例 1：使用 `IN`

假设我们想要查找在部门 ID 为 10、20 或 30 的员工：

SELECT employee_id, last_name, department_id  
FROM employees  
WHERE department_id IN (SELECT department_id FROM departments WHERE department_name IN ('Finance', 'HR', 'IT'));

在这个例子中，子查询 (SELECT department_id FROM departments WHERE department_name IN ('Finance', 'HR', 'IT')) 返回多个部门 ID，然后这些 ID 被外部查询的 IN 操作符使用来过滤员工。

示例 2：使用 `EXISTS`

假设我们想要查找有订单的客户：

SELECT customer_id, customer_name  
FROM customers c  
WHERE EXISTS (SELECT 1 FROM orders o WHERE o.customer_id = c.customer_id);

在这个例子中，子查询 (SELECT 1 FROM orders o WHERE o.customer_id = c.customer_id) 对于每个客户执行一次，如果找到了至少一个订单，EXISTS 返回 TRUE，然后外部查询就会选择这个客户。

示例 3：使用 `ANY` 或 `ALL`

假设我们想要查找工资高于所有销售部门员工工资的员工：

SELECT employee_id, last_name, salary  
FROM employees  
WHERE salary > ALL (SELECT salary FROM employees WHERE department_id = 30);  -- 假设销售部门的ID是30

或者，我们想要查找工资高于销售部门中任何一名员工工资的员工：

SELECT employee_id, last_name, salary  
FROM employees  
WHERE salary > ANY (SELECT salary FROM employees WHERE department_id = 30);  -- 假设销售部门的ID是30

在这两个例子中，子查询返回多行工资值，但 ALL 和 ANY 操作符允许我们与外部查询中的单个工资值进行比较。

注意事项：

当使用多行子查询时，请确保子查询的返回结果与外部查询的期望相匹配。
如果子查询可能不返回任何行（即没有匹配项），请考虑使用 NVL 或其他逻辑来处理这种情况，特别是当使用 = 替换为 IN、EXISTS、ANY 或 ALL 时。
多行子查询可能会影响性能，特别是在大数据集上。确保对查询进行了适当的优化，并考虑使用索引、分区等技术来提高性能。

关联子查询

在 Oracle 数据库中，关联子查询（也称为相关子查询或内联子查询）是一种特殊的子查询，其执行依赖于外部查询的每一行。关联子查询的 WHERE 子句可以引用外部查询的列，这使得子查询能够针对外部查询的每一行返回不同的结果。

关联子查询的典型应用场景是，当您需要根据外部查询的每一行来过滤或计算子查询的结果时。以下是一个使用关联子查询的示例：

假设我们有两个表：employees（员工表）和 departments（部门表）。我们想要查询那些薪水高于其所在部门平均薪水的员工。

SELECT e.employee_id, e.last_name, e.salary, d.department_name  
FROM employees e  
JOIN departments d ON e.department_id = d.department_id  
WHERE e.salary > (  
    SELECT AVG(salary)  
    FROM employees sub_e  
    WHERE sub_e.department_id = e.department_id  -- 这里是关联的部分  
);

在这个例子中，子查询 (SELECT AVG(salary) FROM employees sub_e WHERE sub_e.department_id = e.department_id) 是一个关联子查询。它计算了与外部查询当前行（即 e 表中的每一行）的 department_id 相匹配的员工的平均薪水。然后，外部查询使用这个结果来过滤那些薪水高于其所在部门平均薪水的员工。

关联子查询在处理数据时可能会比较慢，因为它们需要为外部查询的每一行都执行一次子查询。如果可能的话，您应该考虑使用其他方法来重写查询，例如使用窗口函数（如 AVG() OVER ()）或连接（JOIN）和分组（GROUP BY）操作。但是，在某些情况下，关联子查询可能是最简单或最直观的方法来表达您想要的查询逻辑。

非关联子查询

Oracle 中的非关联子查询（也称为独立子查询）是一种子查询，它可以独立于主查询执行，不依赖于主查询中的任何行。非关联子查询只执行一次，其返回的结果用于作为主查询的条件或数据源。

非关联子查询的一个典型特点是，子查询的 WHERE 子句不会引用主查询中的列。因此，子查询可以单独运行，而不必考虑主查询的任何数据。

以下是一个非关联子查询的示例：

假设我们有两个表：employees（员工表）和 departments（部门表）。我们想要找出每个部门中薪水最高的员工。

SELECT a.deptno, a.*  
FROM emp a  
WHERE (a.deptno, a.sal) IN (  
    SELECT deptno, MAX(sal)  
    FROM emp  
    GROUP BY deptno  
);

在这个例子中，子查询 (SELECT deptno, MAX(sal) FROM emp GROUP BY deptno) 是一个非关联子查询。它计算了每个部门的最高薪水，并将结果作为一个独立的临时表返回。然后，主查询使用这个临时表来过滤出每个部门中薪水最高的员工。

需要注意的是，非关联子查询只执行一次，并且其返回的结果通常是一个临时表或一组值，这些值用于在主查询中进行过滤或比较。由于非关联子查询不依赖于主查询的每一行，因此它们通常比关联子查询更容易优化和执行得更快。

内联视图

Oracle内联视图（Inline View）是一种在SQL查询中直接嵌入子查询的构造。它允许在FROM子句中定义一个临时的、只在当前查询上下文中存在的逻辑视图。这个“视图”实际上是子查询的结果集，它在查询执行期间被计算，但不会存储为持久的数据库对象。

主要特点：

临时性：内联视图只在当前查询的上下文中存在，查询结束后即消失，不会存储到数据字典中。
嵌入性：内联视图是直接在SQL查询中嵌入的子查询，不需要事先创建。
灵活性：由于内联视图是临时的，因此可以根据需要随时更改或调整其定义，而无需修改或删除现有的持久视图。

主要用途：

简化复杂查询：通过将复杂的查询逻辑封装在子查询中，可以简化主查询的编写和理解。
过滤和排序数据：使用内联视图可以方便地对数据进行过滤和排序，从而只返回满足特定条件或按特定顺序排列的数据。
作为中间结果集：在查询过程中，内联视图可以作为中间结果集，供后续查询使用。

内联视图的示例包括简单内联视图、嵌套内联视图与视图合并、分页查询等。在使用内联视图时，需要注意一些事项，如确保子查询的返回结果与主查询的期望相匹配、考虑子查询可能不返回任何行的情况等。

此外，内联视图也可以进行等价改写优化，包括将内联视图替换为临时表或物化视图、将内联视图展开到主查询中、使用CTE（Common Table Expression，公用表表达式）等方法。这些改写方法可以根据具体需求和性能考虑进行选择。

简单内联视图

在 Oracle 数据库中，当我们提到“内联视图”时，我们实际上是在引用在 SELECT 语句的 FROM 子句中嵌入的子查询。这种子查询的结果集就像一个临时的表或视图，但它并不是数据库中持久存在的对象。以下是一个简单的内联视图示例：

假设我们有一个 employees 表，其中包含员工的 ID、姓名和薪水。我们想要查询薪水高于 5000 的员工的姓名和薪水，但同时我们也想知道这些员工的薪水相对于所有员工薪水的百分比排名。

为了实现这个查询，我们可以使用内联视图来计算每个员工的薪水百分比排名。这里是一个简单的示例：

SELECT   
    e.employee_id,  
    e.last_name,  
    e.salary,  
    (SELECT COUNT(*) FROM employees e2 WHERE e2.salary > e.salary) + 1 AS salary_rank_percentage  
FROM   
    employees e  
WHERE   
    e.salary > 5000;

但是，这个查询并不是真正的内联视图示例，因为它没有为子查询指定别名。为了更清晰地展示内联视图的概念，我们可以将子查询作为一个内联视图，并为其指定一个别名：

SELECT   
    e.employee_id,  
    e.last_name,  
    e.salary,  
    r.salary_rank_percentage  
FROM   
    employees e,  
    (SELECT   
         employee_id,  
         (SELECT COUNT(*) FROM employees e2 WHERE e2.salary > e1.salary) + 1 AS salary_rank_percentage  
     FROM   
         employees e1) r  
WHERE   
    e.employee_id = r.employee_id AND  
    e.salary > 5000;

然而，请注意，上述查询在逻辑上可能不是最优的，因为它对于 employees 表中的每一行都执行了一个子查询。在实际应用中，我们可能会使用更高效的方法，如窗口函数（如 ROW_NUMBER()、RANK()、DENSE_RANK() 等）来实现类似的排名功能。

但是，这个示例展示了内联视图的基本概念：在 FROM 子句中嵌入一个子查询，并为该子查询指定一个别名，以便在主查询中引用它。

嵌套内联视图

嵌套内联视图（Nested Inline Views）指的是在查询的 FROM 子句中嵌套了一个或多个子查询，而这些子查询本身也包含了子查询。这些嵌套的子查询都作为临时的、只在当前查询上下文中存在的逻辑视图。

以下是一个嵌套内联视图的示例，假设我们有一个 employees 表，其中包含员工的 ID、姓名、部门和薪水，我们想要找出每个部门中薪水最高的员工，并列出他们的姓名、部门和薪水：

SELECT   
    max_salary_emp.department_id,  
    max_salary_emp.last_name,  
    max_salary_emp.salary  
FROM   
    (SELECT   
         e.department_id,  
         e.last_name,  
         e.salary,  
         RANK() OVER (PARTITION BY e.department_id ORDER BY e.salary DESC) AS salary_rank  
     FROM   
         employees e) max_salary_emp  
WHERE   
    max_salary_emp.salary_rank = 1;

在这个查询中，我们使用了两个嵌套的子查询：

第一个子查询（别名为 max_salary_emp）是一个内联视图，它包含了所有员工的姓名、部门和薪水，以及一个通过 RANK() 窗口函数计算出的薪水排名。这个排名是基于每个部门的薪水进行降序排列的。
主查询从 max_salary_emp 这个内联视图中选择数据，并通过 WHERE 子句筛选出薪水排名为 1 的员工，即每个部门中薪水最高的员工。

这样，我们就使用了嵌套内联视图来实现了复杂的查询逻辑，而无需创建额外的数据库对象。需要注意的是，虽然嵌套内联视图在某些情况下可以提高查询的灵活性和可读性，但过多的嵌套也可能会导致查询性能下降，因此在设计查询时需要权衡这些因素。

EXISTS 和 NOT EXISTS 子查询

EXISTS 和 NOT EXISTS 是用于子查询的条件运算符，它们用于检查子查询是否返回任何结果。这两个运算符通常用于在查询中进行条件筛选。

EXISTS

EXISTS 运算符用于检查子查询是否返回至少一条记录。如果子查询返回至少一条记录，则 EXISTS 条件为真，并执行主查询；如果子查询返回空结果集，则 EXISTS 条件为假，不执行主查询。

基本语法格式如下：

SELECT column_name(s)   
FROM table_name   
WHERE EXISTS (subquery);

其中，subquery 表示一个子查询语句，它可以是 SELECT 语句、FROM 子句、WHERE 子句等。主查询根据子查询的结果来判断是否满足条件。

NOT EXISTS

NOT EXISTS 运算符与 EXISTS 相反，它用于检查子查询是否返回空结果集。如果子查询返回空结果集，则 NOT EXISTS 条件为真，并执行主查询；如果子查询返回至少一条记录，则 NOT EXISTS 条件为假，不执行主查询。

基本语法格式如下：

SELECT column1, column2, …   
FROM table_name   
WHERE NOT EXISTS (subquery);

同样，subquery 表示一个子查询语句。

示例：假设我们有两个表：orders（订单表）和 customers（客户表）。我们想要找出没有订单的客户。这可以通过使用 NOT EXISTS 来实现：

SELECT c.*   
FROM customers c   
WHERE NOT EXISTS (  
    SELECT 1   
    FROM orders o   
    WHERE o.customer_id = c.customer_id  
);

这个查询将返回所有在 orders 表中没有对应订单记录的 customers 表中的客户。

总的来说，EXISTS 和 NOT EXISTS 是非常有用的条件运算符，它们可以帮助我们在查询中根据子查询的结果进行条件筛选。

多列子查询

多列子查询（Multiple-Column Subqueries）指的是在子查询中返回多列数据，并在主查询中根据这些多列数据进行条件筛选。多列子查询通常用于比较主查询中的多列与子查询返回的多列数据。

基本语法

多列子查询的基本语法结构如下：

SELECT column1, column2, ...  
FROM table_name  
WHERE (columnA, columnB, ...) IN (SELECT columnX, columnY, ... FROM another_table WHERE condition);

或者

SELECT column1, column2, ...  
FROM table_name  
WHERE (columnA, columnB, ...) = (SELECT columnX, columnY, ... FROM another_table WHERE condition);

示例

假设我们有两个表：employees（员工表）和 managers（经理表）。这两个表都有 emp_id（员工ID）、name（姓名）和 department（部门）列。我们想要找出与某个经理在同一部门的所有员工。这可以通过使用多列子查询来实现：

SELECT e.*  
FROM employees e  
WHERE (e.department, e.manager_id) IN (  
    SELECT m.department, m.emp_id  
    FROM managers m  
    WHERE m.name = 'John Doe'  -- 假设我们要找 John Doe 经理的员工  
);

在这个查询中，子查询返回了 managers 表中名为 'John Doe' 的经理所在的部门和其 emp_id。然后，主查询根据这些多列数据筛选出与 John Doe 经理在同一部门的所有员工。

注意事项

子查询中的列数必须与主查询中的列数匹配：在多列子查询中，子查询返回的列数必须与主查询中用于比较的列数完全匹配。
数据类型必须兼容：用于比较的列的数据类型必须兼容，否则查询将返回错误。
性能考虑：多列子查询可能会影响查询性能，特别是在处理大量数据时。因此，在使用多列子查询时，建议对查询进行优化和测试。
使用括号：多列子查询必须放在括号内，以便正确解析查询语句。
替代方案：在某些情况下，可以使用 JOIN 语句来替代多列子查询，以获得更好的性能和可读性。但是，具体选择哪种方法取决于查询的具体需求和上下文。

珩杰软件设计

关注

12
点赞
踩
13

收藏

觉得还不错? 一键收藏
0
评论
Oracle数据库之子查询(六)

Oracle子查询是一个SELECT语句，它是嵌入在另一个SELECT语句中的子句。子查询可以在主查询之前执行，并将结果提供给主查询使用。通过使用子查询，你可以将一个查询嵌套到另一个查询中，以便进行更复杂的查询操作。用于查询：子查询（内查询）在主查询之前执行完成，并将结果返回给主查询（外查询）使用。子查询可以返回单行数据，也可以返回多行数据。如果返回多行数据，可以使用多行比较操作符（如IN、ALL、ANY）来处理。创建表：你可以使用子查询的结果来创建一个新表。
复制链接

扫一扫