解决查询问题的子查询

笔记首页 >> sql_certificate >> 解决查询问题的子查询

1. 以下哪些是子查询的类型？

有序子查询
分组子查询
单行子查询
以上都不是

答案：C。子查询是嵌套在另一个查询的 SELECT、FROM、HAVING 或 WHERE 子句中的完整查询。子查询必须括在括号中，并且至少有一个 SELECT 和一个 FROM 子句。单行子查询和多行子查询是子查询的主要类型

2.下列关于子查询的说法正确的是？

它们在主查询执行后执行
它们与主查询并行执行
用户可以执行主查询，然后，如果需要，执行子查询
它们在主查询执行之前执行。

答案：D。子查询总是在主查询执行之前执行。子查询先完成，子查询的结果作为外层查询的输入。

3.关于子查询的结果，下列哪项是正确的？

子查询的结果在执行时通常会被忽略。
子查询的结果不会给出结果，它只是有助于加快主查询的执行速度
子查询的结果由主查询使用。
子查询的结果始终为 NULL

答案：C。先完成子查询，子查询的结果作为外层查询的输入。

4.子查询中必须使用以下哪个子句？

选择
在哪里
订购者
通过…分组

答案： A.子查询就像任何其他必须以 SELECT 子句开头的查询一样。它们包含在外部查询中。

5. 以下哪项是在主查询中编写子查询的方法？

通过使用连接
通过使用 WHERE 子句
通过使用 GROUP BY 子句
通过编写嵌入在另一个 SELECT 语句的子句中的 SELECT 语句

答案：D。子查询是嵌套在另一个查询的 SELECT、FROM、HAVING 或 WHERE 子句中的完整查询。子查询必须括在括号中，并且至少有一个 SELECT 和一个 FROM 子句。

6.在给定的场景中，哪一个会恰当地证明子查询的使用是合理的？

当我们需要总结价值时
当我们需要将字符值转换为日期或数字值时
当我们需要从一个表中选择行时，条件取决于来自同一个或不同表的数据。
以上都不是

答案：C。

7.在下列哪个子句中可以使用子查询？

有
在哪里
从
上述所有的

答案：D。子查询与普通查询没有区别。它可以使用 SELECT 语句的所有主子句。

8.以下哪些单行运算符可用于编写子查询？

>=
<
=
上述所有的

答案：D.单行运算符包括 =、>、<、>=、<= 和 <>。

9.以下哪些多行运算符可以与子查询一起使用？

在
任何
全部
上述所有的

答案：D.多行子查询返回不止一行结果。可用于多行子查询的运算符包括 IN、ALL、ANY 和 EXISTS。

10.从子查询中获得的输出正确的是什么？

它保留在缓冲区缓存中
它保留在子查询中，以后需要时可以使用
用于完成外（主）查询
A 和 C

答案：C。先完成子查询，子查询的结果作为外层查询的输入。

11.你需要找出所有薪水比公司“ABC”副总裁高的员工的薪水。以下哪个查询会给出你想要的结果？（考虑给定的表结构）

SQL> DESC employees
 Name			 Null?	  Type
 ----------------------- -------- ----------------
 EMPLOYEE_ID		 NOT NULL NUMBER(6)
 FIRST_NAME			  VARCHAR2(20)
 LAST_NAME		 NOT NULL VARCHAR2(25)
 EMAIL			 NOT NULL VARCHAR2(25)
 PHONE_NUMBER			  VARCHAR2(20)
 HIRE_DATE		 NOT NULL DATE
 JOB_ID 		 NOT NULL VARCHAR2(10)
 SALARY 			  NUMBER(8,2)
 COMMISSION_PCT 		  NUMBER(2,2)
 MANAGER_ID			  NUMBER(6)
 DEPARTMENT_ID			  NUMBER(4)

 SELECT first_name, last_name, salary
FROM employees 
WHERE salary > (SELECT salary
FROM employees 
WHERE job_id = 'VICE-PRESIDENT');

SELECT first_name, last_name, salary
FROM employees 
WHERE salary = (SELECT salary
FROM employees 
WHERE job_id = 'VICE-PRESIDENT');

SELECT first_name, last_name, salary
FROM employees 
WHERE job_id = 'VICE-PRESIDENT');

以上都不是

答案：A.在选项“A”中，内部子查询将 VP 的薪水作为结果提供给外部查询。

12.关于子查询，下列哪项是正确的？

子查询可以写在比较运算符的任一侧
子查询不需要括号
单行子查询可以使用多行运算符，反之亦然
上述所有的

答案： A.根据查询缩进和可用性，子查询可以放在比较运算符的左侧或右侧。

13. 以下查询的结果是什么？（考虑给定的表结构）

SQL> DESC employees
 Name			 Null?	  Type
 ----------------------- -------- ----------------
 EMPLOYEE_ID		 NOT NULL NUMBER(6)
 FIRST_NAME			  VARCHAR2(20)
 LAST_NAME		 NOT NULL VARCHAR2(25)
 EMAIL			 NOT NULL VARCHAR2(25)
 PHONE_NUMBER			  VARCHAR2(20)
 HIRE_DATE		 NOT NULL DATE
 JOB_ID 		 NOT NULL VARCHAR2(10)
 SALARY 			  NUMBER(8,2)
 COMMISSION_PCT 		  NUMBER(2,2)
 MANAGER_ID			  NUMBER(6)
 DEPARTMENT_ID			  NUMBER(4)

SELECT first_name, last_name, salary
FROM employees
WHERE salary ANY (SELECT salary FROM employees);

它成功执行并给出所需的结果
它成功执行但没有给出预期的结果
它抛出一个 ORA 错误
它执行成功并为结果集中获得的每一行给出两个值

答案：C.单行子查询不能使用多行运算符，反之亦然。

14.以下关于单行子查询的说法正确的是？

他们从主查询中给出一个结果
他们只给出结果集中的一行
它们只从内部 SELECT 语句返回一行
他们从主（外部）查询中给出多行

答案：C。单行子查询最多可以返回一个值。

15.关于多行子查询的说法正确的是？

他们可以返回多列作为内部查询的结果
它们在主查询中返回多行，但在内部查询中只返回一个结果集
它们在主查询中返回单行，但在内部子查询中返回多行
它们从内部 SELECT 语句返回多于一行

答案：D.多列子查询在其结果集中返回多于一列，多行子查询从内部查询返回多于一行。

16.关于单行子查询，下列哪项是正确的？

他们只返回一行
他们使用单行运算符
A 和 B
以上都不是

答案：C。

17.子查询中不能使用下列哪些运算符？

答案： A.单行运算符包括 =、>、<、>=、<= 和 <>。可用于多行子查询的多行运算符包括 IN、ALL、ANY 和 EXISTS。

检查展品并回答后面的问题 18 到 21。

表员工
表部门

18.您需要找出与员工“Jessica Butcher”属于同一部门的所有员工的姓名，该员工在部门 100 并且员工 ID 为 40。以下哪个查询是正确的？

SELECT first_name, last_name
FROM employees
WHERE last_name = 'Butcher'
And first_name = 'Jessica';

SELECT first_name, last_name
FROM employees
WHERE department =100;

SELECT first_name, last_name
FROM employees
WHERE department  = (SELECT department
FROM employees
WHERE first_name = 'Jessica'
AND last_name = 'Butcher');

SELECT first_name, last_name
FROM employees
WHERE department  = (SELECT department
FROM employees
WHERE first_name = 'Jessica'
AND last_name = 'Butcher'
AND department = 100
AND employee_id = 40);

答案：D。 ‘D’ 比 ‘C’ 更合适，因为它过滤唯一的员工 ID，并确保子查询仅返回单行。如果有多个员工的名字和姓氏相同，则“C”可能会失败。

19.您需要找出属于“杰西卡·布彻”部门且工资高于员工 ID 为 40 的“杰西卡·布彻”的工资的员工。以下哪个查询有效？

SELECT first_name, last_name
FROM employees
WHERE last_name = 'Butcher'
AND first_name = 'Jessica'
AND salary > 10000;

SELECT first_name, last_name
FROM employees
WHERE department = 100;

SELECT first_name, last_name
FROM employees
WHERE department = (SELECT department
			FROM employees
			WHERE first_name = 'Jessica'
			AND last_name = 'Butcher'
			AND employee_id = 40)
AND salary > (SELECT salary
			 FROM employees
			 WHERE first_name = 'Jessica'
			 AND last_name = 'Butcher'
			 AND employee_id = 40);

SELECT first_name, last_name
FROM employees
WHERE department  = (SELECT department
			FROM employees
			WHERE first_name = 'Jessica'
			AND last_name = 'Butcher'
			AND department = 100);

答案：C。一个SQL语句中可以写多个子查询，添加多个条件。

20.根据第18、19题的答案，他们使用的是什么类型的子查询？

单行子查询
多行子查询
A 和 B
内联子查询

答案： A.上面给出的第 18 和第 19 题演示了 SELECT 语句中的用法子查询。

21.考虑SQL子查询上下文中关于外查询和内查询的两条语句？

一世。内部查询只能从一张表中获取数据

ii. 内部查询可以从多个表中获取数据

以上哪些说法是正确的？

（一世）
(二)
(i) 和 (ii)
既不是 (i) 也不是 (ii)

答案：B.子查询可以从多个表中获取数据。

检查表结构如下，并回答下面的问题 22 到 27：

SQL> DESC employees
 Name			 Null?	  Type
 ----------------------- -------- ----------------
 EMPLOYEE_ID		 NOT NULL NUMBER(6)
 FIRST_NAME			  VARCHAR2(20)
 LAST_NAME		 NOT NULL VARCHAR2(25)
 EMAIL			 NOT NULL VARCHAR2(25)
 PHONE_NUMBER			  VARCHAR2(20)
 HIRE_DATE		 NOT NULL DATE
 JOB_ID 		 NOT NULL VARCHAR2(10)
 SALARY 			  NUMBER(8,2)
 COMMISSION_PCT 		  NUMBER(2,2)
 MANAGER_ID			  NUMBER(6)
 DEPARTMENT_ID			  NUMBER(4)

22.以下查询的结果是什么？（选择最合适的答案）

SQL> DESC employees
 Name			 Null?	  Type
 ----------------------- -------- ----------------
 EMPLOYEE_ID		 NOT NULL NUMBER(6)
 FIRST_NAME			  VARCHAR2(20)
 LAST_NAME		 NOT NULL VARCHAR2(25)
 EMAIL			 NOT NULL VARCHAR2(25)
 PHONE_NUMBER			  VARCHAR2(20)
 HIRE_DATE		 NOT NULL DATE
 JOB_ID 		 NOT NULL VARCHAR2(10)
 SALARY 			  NUMBER(8,2)
 COMMISSION_PCT 		  NUMBER(2,2)
 MANAGER_ID			  NUMBER(6)
 DEPARTMENT_ID			  NUMBER(4)

SELECT last_name, job_id, salary
FROM employees
WHERE salary = (SELECT max(salary)
FROM employees);

它成功执行并为工资等于最高工资的员工提供。
它成功执行但没有给出所需的结果
由于在子查询中使用了组函数，因此会引发错误
它引发错误，因为单行子查询应包含多行运算符

答案： A.可以在子查询中使用组函数。

23.接下来的查询结果是什么？

SELECT first_name, last_name, min(salary)
FROM employees
GROUP BY department_id 
HAVING MIN(salary) > 
		(SELECT min(salary)
		FROM employees
		WHERE department_id = 100);

它执行成功并给出所有员工的姓名和最低工资大于部门 100
它执行成功并给出部门 100 员工的工资
它成功执行并给出所有员工的姓名和最低工资。
它抛出一个错误。

答：A. HAVING 子句可以用在子查询中，如图

24.您需要找到平均工资最高的工作。以下哪个查询会给出您要求的结果？

SELECT job_id, avg(salary)
FROM employees
GROUP BY job_id;

SELECT job_id, avg(salary)
FROM employees
GROUP BY job_id
HAVING job_id in (SELECT max(avg(salary) FROM employees);

SELECT job_id, avg(salary)
FROM employees
GROUP BY job_id
HAVING max(avg(salary) in (SELECT max(avg(salary) FROM employees);

SELECT job_id, avg(salary)
FROM employees
GROUP BY job_id
HAVING avg(salary) in (SELECT max(avg(salary) FROM employees GROUP BY job_id);

答案：D.子查询可以利用组函数和 HAVING 子句来限制组。

25.以下查询抛出错误。选择选项中给出的正确错误原因。

SELECT first_name, last_name
FROM employees
WHERE commission_pct  = (SELECT min(commission_pct )
          FROM employees
          GROUP BY department_id);

子查询中不需要 GROUP BY 子句
不能在子查询 SELECT 语句中使用函数
单行子查询给出多条记录
使用“=”运算符无效；IN 运算符将正常工作

答案：C、D。 GROUP BY 子句为每个部门提供了最小的 Commission_pct，因此将多个结果提取到主查询并给出错误。

26.考虑下面给出的查询。上述查询的结果将返回多少条记录？（假设公司不存在job id为XX的员工）

SELECT first_name, last_name
FROM employees
WHERE salary = (SELECT salary
		FROM employees
		WHERE job_id = 'XX');

1
无效的
0
查询引发 ORA 错误，因为子查询无效。

答案：C。由于公司中没有job_id为“XX”的员工，子查询没有返回结果，当主查询中的job_id等于0时。

27.如果问题 26 中给出的查询中的 WHERE 条件被替换为一个新条件（WHERE job_id IS NOT NULL）会发生什么？（假设’employees’ 表中的记录数是14）。

1
14
0
ORA错误

答案：D . 查询执行引发异常“ORA-01427：单行子查询返回多于一行”。

28.以下哪些是用于子查询的有效多行运算符？

<=
任何 >=
!=
>=

答案：B.多行子查询返回的结果不止一行。可以和多行子查询一起使用的操作符包括IN、ALL、ANY和EXISTS。多行操作符IN、ANY、ALL必须和单行一起使用行运算符，如选项 B 所示。

检查给定的表结构。考虑下面给出的问题并回答后面的问题 29 到 33

SQL> DESC employees
 Name			 Null?	  Type
 ----------------------- -------- ----------------
 EMPLOYEE_ID		 NOT NULL NUMBER(6)
 FIRST_NAME			  VARCHAR2(20)
 LAST_NAME		 NOT NULL VARCHAR2(25)
 EMAIL			 NOT NULL VARCHAR2(25)
 PHONE_NUMBER			  VARCHAR2(20)
 HIRE_DATE		 NOT NULL DATE
 JOB_ID 		 NOT NULL VARCHAR2(10)
 SALARY 			  NUMBER(8,2)
 COMMISSION_PCT 		  NUMBER(2,2)
 MANAGER_ID			  NUMBER(6)
 DEPARTMENT_ID			  NUMBER(4)

SELECT first_name, last_name, salary, commission_pct 
FROM employees 
WHERE salary < ANY  (SELECT salary
		FROM employees
		WHERE department_id  = 100)
AND department_id  <> 101;

29.在上面的查询中，ANY 运算符的计算结果是什么？

真的
错误的
无效的
0

答案： A.多行运算符返回布尔结果。由于部门100中有salary的结果，所以返回TRUE。如果有 0 个结果，则评估为 FALSE。

30.如果我们假设部门 100 只有一名员工，那么查询的结果是什么？

它执行成功给出一个结果
成功执行给所有员工发工资
无效的
它抛出一个 ORA 错误

答案：D。如果部门 100 有一个结果（单行子查询），< ANY 运算符会给出错误，因为它是多行运算符。

31.如果将< ANY 运算符替换为= ANY 运算符，上面给出的查询的结果是什么？

Oracle 将处理从子查询返回的薪水的每个值，就像处理 IN 运算符一样
结果不会有什么不同
结果会有所不同
执行会抛出ORA错误

答案：A. = ANY 运算符等效于 IN 运算符。

32.关于上面给出的查询中的 < ANY 运算符，可以说些什么？

它给出了工资的最大值
它给出了工资的最小值
这意味着它给出的值小于最高值
以上都不是

答案：C。多行运算符 < ANY 的计算结果为子查询的语句“小于最大值”。‘> ALL’ 超过子查询返回的最高值。‘< ALL’ 小于子查询返回的最小值。‘< ANY’ 小于子查询返回的最高值。‘< ANY’ 大于子查询返回的最低值。‘= ANY’ 等于子查询返回的任何值（与 IN 相同）。‘[NOT] EXISTS’ 行必须与子查询中的值匹配

33. 假设 < ANY 运算符被替换为 > ANY。这个运营商的真实情况是什么？

它给出了最高工资
它只从子查询中找到最高工资
它提供的不仅仅是最低工资
它给出了最低工资

答案：C。多行运算符 > ANY 评估子查询的语句“大于最小值”。‘> ALL’ 超过子查询返回的最高值。‘< ALL’ 小于子查询返回的最小值。‘< ANY’ 小于子查询返回的最高值。‘> ANY’ 大于子查询返回的最低值。‘= ANY’ 等于子查询返回的任何值（与 IN 相同）。‘[NOT] EXISTS’ 行必须与子查询中的值匹配

34. 检查给定的表结构并考虑以下查询：

SQL> DESC employees
 Name			 Null?	  Type
 ----------------------- -------- ----------------
 EMPLOYEE_ID		 NOT NULL NUMBER(6)
 FIRST_NAME			  VARCHAR2(20)
 LAST_NAME		 NOT NULL VARCHAR2(25)
 EMAIL			 NOT NULL VARCHAR2(25)
 PHONE_NUMBER			  VARCHAR2(20)
 HIRE_DATE		 NOT NULL DATE
 JOB_ID 		 NOT NULL VARCHAR2(10)
 SALARY 			  NUMBER(8,2)
 COMMISSION_PCT 		  NUMBER(2,2)
 MANAGER_ID			  NUMBER(6)
 DEPARTMENT_ID			  NUMBER(4)

SELECT employee_id, first_name, last_name
FROM employees
WHERE salary IN (SELECT max(salary)
		FROM employees
		GROUP BY department_id );

以下哪个 WHERE 子句与上述查询中给出的相同？（假设工资是2500、3000、3500、4000）

WHERE salary < ANY (SELECT max(salary)
			FROM employees
			GROUP BY department_id );

WHERE salary < ALL (SELECT max(salary)
			FROM employees
			GROUP BY department_id );

WHERE salary = (SELECT max(salary)
			FROM employees
			GROUP BY department_id );

```
WHERE salary IN (2500,3000,3500,4000); 
```

答案：D。当使用 IN 运算符时，Oracle 会按照选项 D 中所示处理子查询的单个结果。

检查下面给出的 EMPLOYEES 表的结构，并回答后面的问题 35 到 37。

SQL> DESC employees
 Name			 Null?	  Type
 ----------------------- -------- ----------------
 EMPLOYEE_ID		 NOT NULL NUMBER(6)
 FIRST_NAME			  VARCHAR2(20)
 LAST_NAME		 NOT NULL VARCHAR2(25)
 EMAIL			 NOT NULL VARCHAR2(25)
 PHONE_NUMBER			  VARCHAR2(20)
 HIRE_DATE		 NOT NULL DATE
 JOB_ID 		 NOT NULL VARCHAR2(10)
 SALARY 			  NUMBER(8,2)
 COMMISSION_PCT 		  NUMBER(2,2)
 MANAGER_ID			  NUMBER(6)
 DEPARTMENT_ID			  NUMBER(4)

35. 您需要找出哪些员工的工资低于作业 ID ‘FIN_ACT’ 的工资。以下哪个查询将为您提供所需的输出？

SELECT employee_id, first_name, last_name
FROM employees
WHERE salary < ALL 
		(SELECT salary
		 FROM employees
		 WHERE job_id = 'FIN_ACT')
		 AND job_id <> 'FIN_ACT';

SELECT employee_id, first_name, last_name
FROM employees
WHERE salary > ALL 
		(SELECT salary
		FROM employees
		WHERE job_id = 'FIN_ACT')
		AND job_id <> 'FIN_ACT';

SELECT employee_id, first_name, last_name
FROM employees
WHERE salary < ANY 
		(SELECT salary
		FROM employees
		WHERE job_id = 'FIN_ACT')
		AND job_id <> 'FIN_ACT';

SELECT employee_id, first_name, last_name
FROM employees
WHERE salary = 	(SELECT salary
		FROM employees
		WHERE job_id = 'FIN_ACT')
		AND job_id <> 'FIN_ACT';

答案：A. < ALL 表示小于最小值。‘> ALL’ 超过子查询返回的最高值。‘< ALL’ 小于子查询返回的最小值。‘< ANY’ 小于子查询返回的最高值。‘> ANY’ 大于子查询返回的最低值。‘= ANY’ 等于子查询返回的任何值（与 IN 相同）。‘[NOT] EXISTS’ 行必须与子查询中的值匹配

36.如果将< ALL 替换为> ALL，上述查询（上述问题中的选项A）的结果是什么？

它将成功执行并给出相同的结果。
它会抛出一个 ORA 错误
它将成功执行，但会提供工资低于 job_id ‘FI_ACCOUNTANT’ 的所有员工的详细信息。
以上都不是

答案：C. >ALL 表示小于最小值。‘> ALL’ 超过子查询返回的最高值。‘< ALL’ 小于子查询返回的最小值。‘< ANY’ 小于子查询返回的最高值。‘> ANY’ 大于子查询返回的最低值。‘= ANY’ 等于子查询返回的任何值（与 IN 相同）。‘[NOT] EXISTS’ 行必须与子查询中的值匹配

37.您需要找到所有不在部门 100 中的员工的工资。以下哪个查询会给出所需的结果？

SELECT employee_id, first_name, last_name
FROM employees
WHERE salary !=ALL 
		(SELECT salary
		FROM employees
		WHERE department_id  = 100)
		AND department_id  <> 100;

SELECT employee_id, first_name, last_name
FROM employees
WHERE salary NOT IN 
		(SELECT salary
		FROM employees
		WHERE department_id  = 100)
		AND department_id  <> 100;

SELECT employee_id, first_name, last_name
FROM employees
WHERE salary NOT ALL 
		(SELECT salary
		FROM employees
		WHERE department_id  = 100)
		AND department_id  <> 100;

SELECT employee_id, first_name, last_name
FROM employees
WHERE salary != (SELECT salary
		FROM employees
		WHERE department_id  = 100)
		AND department_id  <> 100;

答案：C. NOT 可以与多行运算符 IN、ANY 和 ALL 一起使用。

检查给定的表结构。考虑以下问题并回答后面的问题 38 和 39。您需要找到没有下属向他们报告的员工。（假设有 0 个预期结果）

SQL> DESC employees
 Name			 Null?	  Type
 ----------------------- -------- ----------------
 EMPLOYEE_ID		 NOT NULL NUMBER(6)
 FIRST_NAME			  VARCHAR2(20)
 LAST_NAME		 NOT NULL VARCHAR2(25)
 EMAIL			 NOT NULL VARCHAR2(25)
 PHONE_NUMBER			  VARCHAR2(20)
 HIRE_DATE		 NOT NULL DATE
 JOB_ID 		 NOT NULL VARCHAR2(10)
 SALARY 			  NUMBER(8,2)
 COMMISSION_PCT 		  NUMBER(2,2)
 MANAGER_ID			  NUMBER(6)
 DEPARTMENT_ID			  NUMBER(4)

SELECT first_name, last_name 
FROM employees
WHERE employee_id NOT IN 
		(SELECT manager_id
		FROM employees);

38.上面给出的查询的结果是什么？

10
无效的
ORA错误
0

答案：D。内部子查询中的值之一是 NULL（所有员工都不是经理！）

39. 应在上述查询中添加/修改以下哪个 WHERE 子句以给出预期结果？

WHERE employee_id != (SELECT manager_id FROM employees);

WHERE employee_id IN (SELECT manager_id FROM employees);

WHERE employee_id <>ALL (SELECT manager_id FROM employees);

WHERE employee_id NOT IN (SELECT manager_id
			FROM employees
			WHERE manager_id is NOT NULL);

答案：B、D。如果子查询可能有 NULL 值，不要使用 NOT IN 运算符，或者如果使用，则使用附加的 WHERE 子句（选项 D）修改子查询

40.关于子查询的一般情况是什么？

子查询必须与主查询分开执行
子查询可以根据用户的意愿执行，它们与主查询的执行无关
子查询等于两个顺序查询，其中主查询使用内部查询的结果
上述所有的

答案：C。

41.以下关于子查询的说法正确的是？

子查询可以返回 0 行或更多行
子查询只能在 SELECT 子句中使用
子查询的嵌套限制为 2 级
子查询中不能使用组函数

答案： A.子查询是嵌套在另一个查询的 SELECT、FROM、HAVING 或 WHERE 子句中的完整查询。子查询必须括在括号中，并且至少有一个 SELECT 和一个 FROM 子句。单行子查询最多可以返回一个值。多列子查询向外部查询返回不止一列。

42. 检查给定的表结构。

SQL> DESC employees
 Name			 Null?	  Type
 ----------------------- -------- ----------------
 EMPLOYEE_ID		 NOT NULL NUMBER(6)
 FIRST_NAME			  VARCHAR2(20)
 LAST_NAME		 NOT NULL VARCHAR2(25)
 EMAIL			 NOT NULL VARCHAR2(25)
 PHONE_NUMBER			  VARCHAR2(20)
 HIRE_DATE		 NOT NULL DATE
 JOB_ID 		 NOT NULL VARCHAR2(10)
 SALARY 			  NUMBER(8,2)
 COMMISSION_PCT 		  NUMBER(2,2)
 MANAGER_ID			  NUMBER(6)
 DEPARTMENT_ID			  NUMBER(4)

考虑以下查询。

SELECT first_name, last_name 
FROM employees
WHERE employee_id NOT IN 
		(SELECT manager_id, hire_date
		FROM employees 
		WHERE manager_id is not null);

此查询返回错误。错误的原因是什么？

使用的 NOT IN 运算符无效
子查询中的WHERE子句写错了
当主查询中使用不等式时，子查询 SELECT 子句中的列应该只有一个
子查询使用与主查询相同的表

答案：C。子查询中选择的列应该与比较运算符的另一侧相同。任何数据类型或列数的不平等都会导致 ORA 错误。

43. 必须提取一份报告，其中显示分配有一名或多名员工的所有部门。以下哪个查询将提供所需的输出？（考虑给定的表结构）

SQL> DESC employees
 Name			 Null?	  Type
 ----------------------- -------- ----------------
 EMPLOYEE_ID		 NOT NULL NUMBER(6)
 FIRST_NAME			  VARCHAR2(20)
 LAST_NAME		 NOT NULL VARCHAR2(25)
 EMAIL			 NOT NULL VARCHAR2(25)
 PHONE_NUMBER			  VARCHAR2(20)
 HIRE_DATE		 NOT NULL DATE
 JOB_ID 		 NOT NULL VARCHAR2(10)
 SALARY 			  NUMBER(8,2)
 COMMISSION_PCT 		  NUMBER(2,2)
 MANAGER_ID			  NUMBER(6)
 DEPARTMENT_ID			  NUMBER(4)

SELECT department_name
FROM employees
WHERE department_id  IN (SELECT distinct (department_id )
			FROM employees);

SELECT department_name
FROM employees
WHERE department_id  ANY (SELECT distinct (department_id )
			FROM employees);

SELECT department_name
FROM employees
WHERE department_id  < ANY (SELECT distinct (department_id )
			FROM employees);

SELECT department_name
FROM employees
WHERE department_id  = ANY (SELECT distinct (department_id )
			FROM employees);

答案：A、D。

44.Oracle 中单个SQL 语句中允许的最大子查询级别是多少？

20
50
无限
255

答案：D。Oracle支持查询嵌套到 255 级。

45. 当我们知道需要将哪些值传递给 Oracle 查询中的主查询时，应该遵循的最佳实践是什么？

使用 GROUP BY
使用子查询
使用 HAVING
以上都不是

答案：D。有可能子查询给出 NULL 结果，导致主结果中有 0 行；因此，只有当我们知道我们需要什么值时才使用它们是一个很好的做法。

检查给定的表结构。考虑以下查询并回答后面的问题 46 和 47：

SQL> DESC employees
 Name			 Null?	  Type
 ----------------------- -------- ----------------
 EMPLOYEE_ID		 NOT NULL NUMBER(6)
 FIRST_NAME			  VARCHAR2(20)
 LAST_NAME		 NOT NULL VARCHAR2(25)
 EMAIL			 NOT NULL VARCHAR2(25)
 PHONE_NUMBER			  VARCHAR2(20)
 HIRE_DATE		 NOT NULL DATE
 JOB_ID 		 NOT NULL VARCHAR2(10)
 SALARY 			  NUMBER(8,2)
 COMMISSION_PCT 		  NUMBER(2,2)
 MANAGER_ID			  NUMBER(6)
 DEPARTMENT_ID			  NUMBER(4)

SELECT employee_id, first_name, last_name, job_id
FROM employees
WHERE job_id = (SELECT job_id FROM employees);

46.您需要找到所有工作 ID 与 ID 为 210 的员工相同的员工。您会添加/修改以下哪些 WHERE 子句以达到此结果？（考虑给定的表结构

WHERE job_id = (SELECT job_id FROM employees WHERE employee_id = 210);

WHERE job_id IN (SELECT job_id FROM employees WHERE employee_id = 210);

WHERE job_id > (SELECT job_id FROM employees WHERE employee_id = 210);

WHERE job_id >= (SELECT job_id FROM employees WHERE employee_id = 210);

答案：A。

47.假设您将问题 46 中选项 A 中给出的 WHERE 子句更改如下。

WHERE job_id = (SELECT job_id FROM employees WHERE employee_id < 210);

这种变化会带来什么结果？

结果将是相同的
执行时抛出 ORA 错误
结果会有所不同
查询将成功执行，给出 0 行。

答案：B . 子查询在给定的更改上给出不止一个结果，因此多行运算符应该替换上面给出的主查询中的“=”。

48.检查表结构，如下图所示。

表员工
表等级

您需要显示工资最高的员工的姓名。以下哪个 SQL 语句是正确的？

SELECT first_name, last_name, grade
FROM employees, grade
WHERE (SELECT max (salary) FROM employees) BETWEEN losal and hisal;

SELECT first_name, last_name, grade
FROM employees, grade
WHERE (SELECT max (salary) FROM employees) BETWEEN losal and hisal
AND salary BETWEEN losal and hisal;

SELECT first_name, last_name, grade
FROM employees, grade
WHERE salary = (SELECT max (salary) FROM employees) 
AND salary BETWEEN losal and hisal;

SELECT first_name, last_name, grade
FROM employees, grade
WHERE salary IN (SELECT max (salary) FROM employees) 
AND max(salary) BETWEEN losal and hisal;

答案：B，C。子查询可以写在运算符的任一侧

49.SQL语句的FROM子句中的子查询是什么？（选择最合适的答案）

单行子查询
多行子查询
内联视图
关联子查询

答案：C。如果子查询出现在 SELECT 语句的 FROM 子句中，它会形成一个内联视图。Oracle 在内部为查询执行创建一个临时视图。

50.内联视图类型子查询中允许的最大嵌套级别数是多少？

255
300
216
无限

答案：D。由于可以连接的表数量没有限制，因此查询中的内联视图数量没有限制。

51.关于相关的子查询，什么是正确的？

主查询中使用的表也用于相关子查询中
引用主查询中使用的列的子查询称为相关子查询
不带括号的子查询称为相关子查询
强制使用与主查询中使用的表不同的表的子查询称为相关子查询

答案：B.相关子查询引用外部查询中的一列，并对外部查询中的每一行执行一次子查询，而不相关子查询首先执行子查询并将值传递给外部查询。

52.以下哪个语句不能作为子查询的父语句？

选择
通过…分组
更新
删除

答案：B . 其余选项可以在子查询的主查询（父查询）中。

53. 什么是相关的子查询是真的？

它只为父查询评估一次
它只为父查询评估三次
它为父子查询处理的每一行评估一次
上述所有的

答案：C.关联子查询引用外层查询中的一列，对外层查询中的每一行都执行一次子查询；EXISTS 运算符用于测试是否存在关系或链接。

54.检查给定的表结构。您需要编写一个查询，该查询返回工资超过各自部门平均工资的员工姓名。以下哪项会起作用？（选择最合适的答案）

SQL> DESC employees
 Name			 Null?	  Type
 ----------------------- -------- ----------------
 EMPLOYEE_ID		 NOT NULL NUMBER(6)
 FIRST_NAME			  VARCHAR2(20)
 LAST_NAME		 NOT NULL VARCHAR2(25)
 EMAIL			 NOT NULL VARCHAR2(25)
 PHONE_NUMBER			  VARCHAR2(20)
 HIRE_DATE		 NOT NULL DATE
 JOB_ID 		 NOT NULL VARCHAR2(10)
 SALARY 			  NUMBER(8,2)
 COMMISSION_PCT 		  NUMBER(2,2)
 MANAGER_ID			  NUMBER(6)
 DEPARTMENT_ID			  NUMBER(4)

SELECT employee_id, first_name, last_name
FROM employees e
WHERE salary > (SELECT avg (salary)
		FROM employees
		WHERE e.department_id  = department_id )
		ORDER BY department_id ;

SELECT employee_id, first_name, last_name
FROM employees e
WHERE salary > ANY (SELECT avg(salary)
		FROM employees
		WHERE e.department_id  = department_id )
		ORDER BY department_id ;

SELECT employee_id, first_name, last_name
FROM employees e
WHERE salary = (SELECT avg(salary)
		FROM employees
		WHERE e.department_id  = department_id )
		ORDER BY department_id ;

SELECT employee_id, first_name, last_name
FROM employees e
WHERE salary < ANY  (SELECT avg(salary)
		FROM employees
		WHERE e.department_id  = department_id )
		ORDER BY department_id ;

答： A.这里获取部门ID，用于评估父查询，如果该行的工资大于该行部门的平均工资，则返回该结果。

55.检查给定的表结构。以下哪个查询将显示表 EMPLOYEES 中的重复记录？

SQL> DESC employees
 Name			 Null?	  Type
 ----------------------- -------- ----------------
 EMPLOYEE_ID		 NOT NULL NUMBER(6)
 FIRST_NAME			  VARCHAR2(20)
 LAST_NAME		 NOT NULL VARCHAR2(25)
 EMAIL			 NOT NULL VARCHAR2(25)
 PHONE_NUMBER			  VARCHAR2(20)
 HIRE_DATE		 NOT NULL DATE
 JOB_ID 		 NOT NULL VARCHAR2(10)
 SALARY 			  NUMBER(8,2)
 COMMISSION_PCT 		  NUMBER(2,2)
 MANAGER_ID			  NUMBER(6)
 DEPARTMENT_ID			  NUMBER(4)

SELECT *
FROM employees E
WHERE exists (SELECT 1 FROM employees E1
		WHERE E.employee_id = E1.employee_id);

SELECT *
FROM employees E
WHERE exists (SELECT 1 FROM employees E1
		WHERE E.employee_id = E1.employee_id
		AND E.ROWID < E1.ROWID);

SELECT *
FROM employees E
WHERE exists (SELECT 1 FROM employees E1
		WHERE E.ROWID < E1.ROWID);

SELECT *
FROM employees E
WHERE = ANY (SELECT 1 FROM employees E1
		WHERE E.employee_id = E1.employee_id
		And E.ROWID < E1.ROWID);

答： A.关联子查询引用外层查询中的一列，对外层查询中的每一行都执行一次子查询；EXISTS 运算符用于测试是否存在关系或链接。它可用于在表中查找重复行，其中重复性受一列或一组列的影响。

检查表 DEPARTMENTS 和 EMPLOYEES 的结构，并回答后面的问题 56 和 57。

SQL> DESC employees
 Name			 Null?	  Type
 ----------------------- -------- ----------------
 EMPLOYEE_ID		 NOT NULL NUMBER(6)
 FIRST_NAME			  VARCHAR2(20)
 LAST_NAME		 NOT NULL VARCHAR2(25)
 EMAIL			 NOT NULL VARCHAR2(25)
 PHONE_NUMBER			  VARCHAR2(20)
 HIRE_DATE		 NOT NULL DATE
 JOB_ID 		 NOT NULL VARCHAR2(10)
 SALARY 			  NUMBER(8,2)
 COMMISSION_PCT 		  NUMBER(2,2)
 MANAGER_ID			  NUMBER(6)
 DEPARTMENT_ID			  NUMBER(4)

SQL> DESC departments
 Name			 Null?	  Type
 ----------------------- -------- ----------------
 DEPARTMENT_ID		 NOT NULL NUMBER(4)
 DEPARTMENT_NAME	 NOT NULL VARCHAR2(30)
 MANAGER_ID			  NUMBER(6)
 LOCATION_ID			  NUMBER(4)

56.以下哪个查询会显示DEPARTMENTS和EMPLOYEES表中的系统日期和记录数？

SELECT sysdate,
		(SELECT * FROM departments) dept_count,
		(SELECT * FROM employees) emp_count
FROM DUAL;

SELECT sysdate,
		(SELECT count(*) FROM departments) dept_count,
		(SELECT count(*) FROM employees) emp_count
FROM DUAL
GROUP BY department_id ;

SELECT sysdate,
		(SELECT * FROM departments) dept_count,
		(SELECT * FROM employees) emp_count
FROM DUAL
GROUP BY employee_id;

SELECT sysdate,
		(SELECT count(*) FROM departments) dept_count,
		(SELECT count(*) FROM employees) emp_count
FROM DUAL;

答案：D . 单行子查询也可以嵌套在外部查询的 SELECT 子句中。在这种情况下，子查询返回的值可用于外部查询生成的每一行输出。通常，此技术用于使用从子查询生成的值执行计算。

57.以下哪个查询将说明给定员工是否是公司“XYZ”的经理？

SELECT employee_id, manager_id
FROM employees A
WHERE employee_id ANY (SELECT manager_id from employees B)
ORDER BY manager_id desc;

SELECT employee_id, manager_id
FROM employees A
WHERE employee_id < ALL (SELECT manager_id from employees B)

SELECT employee_id, manager_id
FROM employees A
WHERE employee_id IN (SELECT manager_id from employees B)
ORDER BY manager_id desc;

SELECT employee_id, manager_id
FROM employees A
WHERE employee_id in (SELECT manager_id from employees B)
GROUP BY department_id ;

答案：C。

检查展品并回答下面的问题 58：

表员工
表部门
餐桌位置

58.以下哪个查询会给出特定城市雇员的最高工资？

SELECT max (salary), city
FROM
(SELECT salary, department_id , loc, city
FROM employees natural join departments natural join locations);

SELECT salary, city
FROM
(SELECT salary, department_id , loc, city
FROM employees natural join departments natural join locations);

SELECT max (salary), city
FROM
(SELECT salary, department_id , loc, city
FROM employees natural join departments natural join locations)
GROUP BY city;

SELECT max (avg(salary)), city
FROM
(SELECT salary, department_id , loc, city
FROM employees natural join departments natural join locations);

答案：C。当外查询的FROM 子句中使用多列子查询时，它会创建一个临时表，可以被外查询的其他子句引用。这个临时表更正式地称为内联视图。子查询的结果被视为 FROM 子句中的任何其他表。如果临时表包含分组数据，则分组子集被视为表中单独的数据行。

检查下面给出的表结构。

SQL> DESC employees
 Name			 Null?	  Type
 ----------------------- -------- ----------------
 EMPLOYEE_ID		 NOT NULL NUMBER(6)
 FIRST_NAME			  VARCHAR2(20)
 LAST_NAME		 NOT NULL VARCHAR2(25)
 EMAIL			 NOT NULL VARCHAR2(25)
 PHONE_NUMBER			  VARCHAR2(20)
 HIRE_DATE		 NOT NULL DATE
 JOB_ID 		 NOT NULL VARCHAR2(10)
 SALARY 			  NUMBER(8,2)
 COMMISSION_PCT 		  NUMBER(2,2)
 MANAGER_ID			  NUMBER(6)
 DEPARTMENT_ID			  NUMBER(4)

SQL> DESC departments
 Name			 Null?	  Type
 ----------------------- -------- ----------------
 DEPARTMENT_ID		 NOT NULL NUMBER(4)
 DEPARTMENT_NAME	 NOT NULL VARCHAR2(30)
 MANAGER_ID			  NUMBER(6)
 LOCATION_ID			  NUMBER(4)

考虑以下查询并回答后面 59 到 62 的问题。

SELECT  department_name
FROM departments d INNER JOIN employees e
ON (d.employee_id = e.employee_id)
GROUP BY department_name;

59.以下哪个查询可以通过使用子查询给出相同的结果来代替上面的查询？

SELECT department_name
FROM departments
WHERE department_id  = ANY (SELECT department_id  FROM employees);

SELECT department_name
FROM departments
WHERE department_id  IN (SELECT distinct(department_id ) FROM employees);

SELECT department_name
FROM departments
WHERE department_id  = (SELECT distinct(department_id ) FROM employees);

SELECT department_name
FROM departments
WHERE department_id  ANY (SELECT distinct(department_id ) FROM employees);

答案：A、B。

60.假设上面给出的查询中所示的子查询修改为以下内容。

(SELECT distinct (department_id ) FROM employees ORDER BY department_id );

这种变化的结果是什么？（选择最合适的答案）

它将对从子查询中获取的 Department_id 进行排序并以升序显示它们
它会抛出一个 ORA 错误，因为 ORDER BY 子句应该伴随着 GROUP BY 子句
它会抛出 ORA 错误，因为 ORDER BY 子句不能在子查询中使用
它将成功执行。

答案：C。除了在 FROM 子句中的子查询之外，子查询不能有 ORDER BY 子句。如果您需要以特定顺序显示输出，请包括一个 ORDER BY 子句作为外部查询的最后一个子句。

61.假设上面给出的查询被修改为下面的查询。

SELECT department_name
FROM departments
WHERE department_id  = ANY (SELECT department_id  FROM employees)
ORDER BY department_id  desc;

这种变化的结果是什么？（选择最合适的答案）

它将对从子查询中获取的 Department_id 进行排序并以升序显示它们
它将对从子查询中获取的 Department_id 进行排序并按降序显示它们
它会抛出 ORA 错误，因为 ORDER BY 子句不能在子查询中使用
以上都不是

答案：D . 除了 FROM 子句中的一个子查询之外，子查询不能有 ORDER BY 子句。如果您需要以特定顺序显示输出，请包含一个 ORDER BY 子句作为外部查询的最后一个子句。

62.以下哪项可用于对子查询中的结果进行排序？

订购者
有
通过…分组
上述所有的

答案：C。默认情况下，GROUP BY 子句在子查询中执行排序。

检查下面的展览并回答下面的问题 63 到 65：

表审计

考虑以下查询：

SELECT au_id, au_title
FROM audit
WHERE au_details in (SELECT au_details
		  FROM audit
		  WHERE au_title like 'S%')
		  ORDER BY au_title;

63.上面给出的查询的结果是什么？

它给出了所有以字母“S%”开头的 AU_ID 和 AU_TITLE
它给出了所有 AU_ID 和 AU_TITLE，以字母“S%”开头，按标题升序排列
它抛出一个 ORA 错误
它返回一个 0 值

答案：C。不能在子查询中使用带有 CLOB、BLOB、NCLOB 或 ARRAY 的列。

64. 以下查询的结果是什么？

SELECT *
FROM employees
WHERE salary BETWEEN (SELECT max(salary)
			FROM employees
			WHERE department_id  = 100) 
AND (SELECT min(salary) FROM employees where department_id  = 100);

此查询返回错误。错误的原因是什么？

应使用 GROUP BY 子句作为函数 MAX
两个子查询不能在同一个外部查询中使用相同的部门 ID
BETWEEN 运算符不能与子查询一起使用
SELECT 子句应该提到列而不是星号 (*)

答案：C . BETWEEN 运算符可以在子查询中使用，但不能与子查询一起使用。

65. 在编写包含子查询的查询时使用 NOT IN 是什么意思？

NOT IN 忽略所有 NULL 值并只给出 NOT NULL 值
NOT IN 将所有 NULL 值放在最后，并首先显示 NOT NULL
如果结果集中预期为 NULL 值，则不应使用 NOT IN
NOT IN 只是对运算符 IN 的否定，可以在没有任何警告的情况下进行更改。

答案：C. SQL 以不同的方式处理 NULL 值，因此如果结果集可能包含 NULL，则避免 NOT IN 是一个好习惯。

考虑以下表格结构并回答后面的问题 66 到 72：

表员工
表部门

66. 您需要找出部门中最低工资大于最高工资的部门的名称和 ID 10. 以下哪个查询将给出所需的结果。

SELECT department_id , min(salary)
FROM employees
GROUP BY department_id 
HAVING min(salary) >
		(
		select max(salary)
		FROM employees
		where department_id  = 10
		)

SELECT department_id , min(salary)
FROM employees
GROUP BY department_id 
HAVING min(salary) > ANY
		(
		select max(salary)
		FROM employees
		)

SELECT department_id , min(salary)
FROM employees
HAVING max(salary) < ANY
		(
		select min(salary)
		FROM employees
		where department_id  = 10
		)

SELECT department_id , min(salary)
FROM employees
GROUP BY department_id 
HAVING min(salary) > ALL
		(
		select max(salary)
		FROM employees
		where department_id  = 10
		)

答案：A。

67. 写一个查询，找出工资等于 id 10 的部门中至少一名员工的工资的员工。（选择最佳答案）

SELECT employee_id, Salary
FROM employees
WHERE salary in
		(
		SELECT salary
		FROM employees
		where department_id  = 10
		)

SELECT employee_id, Salary
FROM employees
WHERE salary =ANY
		(
		SELECT salary
		FROM employees
		where department_id  = 10
		)

SELECT employee_id, Salary
FROM employees
WHERE salary ALL
		(
		SELECT salary
		FROM employees
		where department_id  = 10
		)

SELECT employee_id, Salary
FROM employees
WHERE salary  < ANY
		(
		SELECT salary
		FROM employees
		where department_id  = 10
		)

答案：A、B。

68.您需要找出部门中所有薪水至少高于一名员工的员工。 10. 以下哪个查询会为您提供所需的输出？

SELECT employee_id, Salary
FROM employees
WHERE salary >= ANY
		(
		SELECT salary
		FROM employees
		where department_id  = 10
		)

SELECT employee_id, Salary
FROM employees
WHERE salary > ANY
		(
		SELECT salary
		FROM employees
		where department_id  = 10
		)

SELECT employee_id, Salary
FROM employees
WHERE salary < ANY
		(
		SELECT salary
		FROM employees
		where department_id  = 10
		)

SELECT employee_id, Salary
FROM employees
WHERE salary = ALL
		(
		SELECT salary
		FROM employees
		where department_id  = 10
		)

答案：B。

69. 你需要找出所有工资低于部门所有员工工资的员工 10. 以下哪个查询会给出你需要的输出？

SELECT employee_id, Salary
FROM employees
WHERE salary > ALL
		(
		SELECT salary
		FROM employees
		where department_id  = 10
		)

SELECT employee_id, Salary
FROM employees
WHERE salary =ALL
		(
		SELECT salary
		FROM employees
		where department_id  = 10
		)

SELECT employee_id, Salary
FROM employees
WHERE salary < ALL
		(
		SELECT salary
		FROM employees
		where department_id  = 10
		)

SELECT employee_id, Salary
FROM employees
WHERE salary < ANY
		(
		SELECT salary
		FROM employees
		where department_id  = 10
		)

答案：C.多行子查询返回多于一行的结果。可用于多行子查询的运算符包括 IN、ALL、ANY 和 EXISTS。多列子查询向外部查询返回不止一列。数据列按照它们在子查询的 SELECT 子句中列出的相同顺序传递给外部查询。

70.您需要找出所有经理和部门与员工 ID 为 121 或 200 的员工相匹配的员工。以下哪个查询会为您提供所需的输出？

SELECT employee_id, manager_id,department_id 
FROM employees
WHERE (manager_id,department_id ) = ANY
		(
		select manager_id,
		department_id 
		FROM employees
		where employee_id in (121,200)
		)

SELECT employee_id, manager_id,department_id 
FROM employees
WHERE (manager_id,department_id ) < ANY
		(
		select manager_id,
		department_id 
		FROM employees
		where employee_id in (121,200)
		)

SELECT employee_id, manager_id,department_id 
FROM employees
WHERE (manager_id,department_id ) > ANY
		(
		select manager_id,
		department_id 
		FROM employees
		where employee_id in (121,200)
		)

SELECT employee_id, manager_id,department_id 
FROM employees
WHERE (manager_id,department_id ) in
		(
		select manager_id,
		department_id 
		FROM employees
		where employee_id in (121,200)
		)

答案：A、D。多行子查询返回多于一行的结果。可用于多行子查询的运算符包括 IN、ALL、ANY 和 EXISTS。多列子查询向外部查询返回不止一列。数据列按照它们在子查询的 SELECT 子句中列出的相同顺序传递给外部查询。

71.您需要查找员工 ID 为 200 的员工的部门名称。以下哪个查询是正确的？（选择最合适的答案）

SELECT employee_id, first_name, last_name,department_id ,
(SELECT department_name
FROM departments d, employees E
WHERE d.department_id  = e.department_id 
And employee_id = 200
)
FROM employees e

SELECT employee_id, first_name, last_name,department_id ,
(SELECT department_ID
FROM departments d
WHERE d.department_id  = department_id 
)
FROM employees e
WHERE employee_id = 200;

SELECT employee_id, first_name, last_name,department_id ,
(SELECT department_name
FROM departments d
WHERE d.department_id  = e.department_id 
And employee_id = 200
)
FROM employees e

SELECT employee_id, first_name, last_name,department_id ,
(SELECT department_name
FROM departments d,employee E 
WHERE d.department_id  = e.department_id 
)
FROM employees e

答案：C。

72.您需要找到工作 ID 为“SA_REP”的收入最高的员工。以下哪个查询是正确的？（选择最合适的答案）

SELECT job_id, employee_id, Salary
FROM employees e
WHERE job_id  =
(
SELECT  distinct salary
FROM employees E1
WHERE E.job_id  = E1.job_id 
AND E.salary <=  E1.salary
AND job_id  = 'SA_REP'

SELECT department_id , employee_id, Salary
FROM employees E
WHERE 1 =
(
SELECT  count(distinct salary)
FROM employees E1
WHERE E.job_id  = E1.job_id 
AND E.salary <=  E1.salary
AND job_id  = 'SA_REP'
)

SELECT department_id , employee_id, Salary
FROM employees E
WHERE 0 =
(
SELECT  count(distinct salary)
FROM employees E1
WHERE E.job_id  = E1.job_id 
AND E.salary =  E1.salary
AND job_id  = 'SA_REP'
)

SELECT department_id , employee_id, Salary
FROM employees E
WHERE 1 =
(
SELECT salary
FROM employees E1
WHERE E.job_id  < E1.job_id 
AND E.salary <=  E1.salary
AND job_id  = 'SA_REP'
)

答案：B。

考虑如图所示的 EMPLOYEES 表结构，并回答下面的问题 73 到 77：

表员工

73.你需要找到至少有一名员工的工作。以下哪个查询是正确的？（选择最合适的答案）

SELECT employee_id, Job_id
FROM employees E
WHERE exists
(
SELECT 1
FROM employees E1
WHERE E.job_id  = E1.job_id )

SELECT employee_id, Job_id 
FROM employees E
WHERE exists
(
SELECT *
FROM employees E1
WHERE E.job_id  = E1.job_id )

SELECT employee_id, Job_id 
FROM employees E
WHERE not exists
(
SELECT *
FROM employees E1
WHERE E.job_id  = E1.job_id )

SELECT employee_id, Job_id 
FROM employees E
WHERE exists
(
SELECT 1
FROM employees E1
WHERE E.job_id  < E1.job_id )

答案： A. EXISTS 运算符用于检查和匹配查询之间的记录。它返回一个 BOOLEAN 值。关联子查询引用外层查询中的一列，对外层查询中的每一行都执行一次子查询；EXISTS运算符用于测试是否存在关系或链接。不相关的子查询首先执行子查询并将值传递给外部查询。

74.你需要找到一份没有员工的工作。以下哪个查询是正确的？（选择最合适的答案）

SELECT employee_id, Job_id 
FROM employees E
WHERE exists
(
SELECT *
FROM employees E1
WHERE E.job_id  = E1.job_id )

SELECT employee_id, Job_id 
FROM employees E
WHERE not exists
(
SELECT 1
FROM employees E1
WHERE E.job_id  = E1.job_id )

SELECT employee_id, Job_id 
FROM employees E
WHERE not exists
(
SELECT *
FROM employees E1
WHERE E.job_id  = E1.job_id )

SELECT employee_id, Job_id 
FROM employees E
WHERE exists
(
SELECT 1
FROM employees E1
WHERE E.job_id  < E1.job_id )

答案：B . NOT EXISTS 是 EXISTS 的否定运算符。

75.您需要从 EMPLOYEES 表中找到第三个最高工资。以下哪个查询会为您提供所需的结果？（选择最合适的答案）

SELECT * 
FROM employees E
WHERE salary = (SELECT count(distinct salary ) 
		FROM employees 
		WHERE e.salary = salary 
		);

SELECT * 
FROM employees E
WHERE 1 = (SELECT count(distinct salary ) 
		FROM employees 
		WHERE e.salary < salary 
		);

SELECT * 
FROM employees E
WHERE 2 = (SELECT count(distinct salary ) 
		FROM employees 
		WHERE e.salary >salary 
		);

SELECT * 
FROM employees E
WHERE 3 = (SELECT count(distinct salary ) 
		FROM employees 
		WHERE e.salary <= salary 
		);

答案：D。

76. 您需要使用用户输入来查找最高工资以获取 N 的值。以下哪个查询会给出所需的结果？（选择最合适的答案）

SELECT salary FROM 
(
	SELECT rowid as user_sal 
	FROM (SELECT distinct salary  from employees ORDER BY salary  desc)
) 
WHERE user_sal=&N ;

SELECT salary FROM 
(	
	SELECT rownum as user_sal
	FROM (SELECT distinct salary  FROM employees   		GROUP BY salary )
) 
WHERE user_sal <= &N ;

SELECT salary FROM 
(
	SELECT rownum as user_sal, salary 	FROM (SELECT distinct salary  FROM employees 		 ORDER BY salary  desc)
) 
WHERE user_sal=&N ;

SELECT salary FROM 
(
	SELECT max(rownum) as user_sal, salary 	FROM (SELECT distinct salary  FROM employees 		ORDER BY salary  desc)
) 
WHERE user_sal=&N ;

答案：C. ROWNUM 是用于查找第 n 阶结果的伪列。

77.如果提供给上述查询中的 &N 变量的值（问题 76 中的选项 C）与任何行都不匹配，会发生什么情况？（选择最佳答案）

该语句将抛出 ORA 错误
该语句将返回表中的所有行
该语句将返回 NULL 作为输出结果。
该语句不会在结果中返回任何行。

答案：D。

78. 子查询可以嵌套的最高级别是多少？

答案：A。

79.关于子查询的 SQL 查询中的 EXISTS 操作符正确的是什么？

子查询中选择的列很重要
内部查询应该返回行，任何结果都是重要的，而不是什么是 SELECTED
A 和 B
既不是 A 也不是 B

答案：B。

80. 用于子查询的 ANY 操作符正确的是什么？

返回匹配列表/子查询中所有值的行
返回与列表/子查询中的前 5 个值匹配的行
返回与列表/子查询中的任何值匹配的行
当列表/子查询中的所有行都匹配时，返回值 0

答案：C。

81. 用于子查询的 ALL 操作符正确的是什么？（选择最合适的答案。）

返回匹配列表/子查询中所有值的行
返回仅匹配列表/子查询中某些值的行
仅当列表/子查询中的所有值都匹配时才返回行
上述所有的

答案：C. ‘> ALL’ 超过子查询返回的最高值。‘< ALL’ 小于子查询返回的最小值。‘< ANY’ 小于子查询返回的最高值。‘> ANY’ 大于子查询返回的最低值。‘= ANY’ 等于子查询返回的任何值（与 IN 相同）。‘[NOT] EXISTS’ 行必须与子查询中的值匹配。

82.Oracle 的 INSERT 语句中使用子查询的说法正确的是？

它们可以在 INSERT 子句中使用而不受任何限制
它们只能在 INSERT 子句中用于数值
子查询的 SELECT 列表应该与 INSERT 语句的列列表相同。
以上都不是

答案：C。

检查下面给出的表格结构，并回答后面的问题 83 到 86。

SQL> DESC employees
 Name			 Null?	  Type
 ----------------------- -------- ----------------
 EMPLOYEE_ID		 NOT NULL NUMBER(6)
 FIRST_NAME			  VARCHAR2(20)
 LAST_NAME		 NOT NULL VARCHAR2(25)
 EMAIL			 NOT NULL VARCHAR2(25)
 PHONE_NUMBER			  VARCHAR2(20)
 HIRE_DATE		 NOT NULL DATE
 JOB_ID 		 NOT NULL VARCHAR2(10)
 SALARY 			  NUMBER(8,2)
 COMMISSION_PCT 		  NUMBER(2,2)
 MANAGER_ID			  NUMBER(6)
 DEPARTMENT_ID			  NUMBER(4)

SQL> DESC departments
 Name			 Null?	  Type
 ----------------------- -------- ----------------
 DEPARTMENT_ID		 NOT NULL NUMBER(4)
 DEPARTMENT_NAME	 NOT NULL VARCHAR2(30)
 MANAGER_ID			  NUMBER(6)
 LOCATION_ID			  NUMBER(4)

83.您需要找到在 2013 年 6 月为工作 ID ‘SA_REP’ 雇用的所有员工的详细信息。以下哪个查询会给出所需的结果？（考虑给定的表结构）

SELECT first_name 
FROM employees 
WHERE employee_id  =
(	SELECT employee_id 
	FROM employees 
	WHERE to_char(hiredate, 'MM/YYYY')= '02/1981'
	AND job_id  = 'SA_REP'
);

SELECT first_name 
FROM employees 
WHERE employee_id  = ANY
(	SELECT employee_id 
	FROM employees 
	WHERE to_char(hiredate, 'MM/YYYY')= '02/1981'
	AND job_id  = 'SA_REP'
);

SELECT first_name 
FROM employees 
WHERE employee_id  ANY
(	SELECT employee_id 
	FROM employees 
	WHERE to_char(hiredate, 'MM/YYYY')= '02/1981'
	AND job_id  = 'SA_REP'
);

SELECT first_name 
FROM employees 
WHERE employee_id  exists
(	SELECT employee_id 
	FROM employees 
	WHERE to_char(hiredate, 'MM/YYYY')= '02/1981'
	AND job_id  = 'SA_REP'
);

答案：B。

84.以下哪些说法是等价的？

SELECT employee_id , salary
FROM employees 
WHERE salary < ALL (SELECT salary FROM employees WHERE department_id=100);

SELECT employee_id , salary
FROM employees WHERE salary < (SELECT min(salary) FROM employees WHERE department_id=100);

SELECT employee_id 
FROM employees 
WHERE salary not >= ANY (SELECT salary FROM employees WHERE department_id=100);

以上都不是

答案：A、B。

85. 考虑以下两个查询：

查询 1：

SELECT first_name 
FROM employees e join departments d
ON e.department_id  = d.department_id
WHERE department_name='ACCOUNTS';

查询 2：

SELECT first_name 
FROM employees  e 
WHERE department_id  = ANY (SELECT department_id 		FROM departments d 
		WHERE department_name='ACCOUNTS');

关于这两个声明可以说些什么？

两个查询都应生成相同的结果。
这两个查询都会抛出错误。
如果有两个同名的部门，两个查询都会失败。
即使有多个名为“ACCOUNTS”的部门，这两个查询也会成功运行。

答案：A、D。

86.您需要显示部门 100 中所有薪水最高的员工。您发出如下查询。

 
SELECT E.first_name, E.last_name , E.salary
FROM employees E
WHERE E.salary > ALL (SELECT E1.salary
      FROM employees E1
      WHERE E.department_id  =E1.department_id 
      AND E.department_id  = 100);

上述查询的结果是什么？

它成功执行并给出所需的结果
它成功执行但没有提供所需的输出
它在执行时抛出 ORA 错误
当 >ALL 替换为 >=ALL 时，它会成功执行并给出所需的结果

答案：B，D。 >ALL 不会给出要求的结果，因为可能有两个员工薪水相同，而且他们是部门 100 中收入最高的人

考虑如图所示的表格结构，并回答下面的问题 87 到 89：

表员工
表部门

87.您需要获取部门 ID = 100 中所有员工的名字（按字母倒序排列），并且在 JOB ID = ‘SA_REP’ 中拥有最高薪水。以下哪个查询将提供所需的输出？（选择最合适的输出）

SELECT E.first_name, job_id , salary
FROM employees E
WHERE salary =
		(SELECT max(salary)
		FROM employees E1
		WHERE E1.department_id  = 100
		GROUP BY job_id )
AND job_id  = 'SA_REP'
ORDER BY first_name;

SELECT E.first_name, job_id , salary
FROM employees E
WHERE salary in
		(SELECT max(salary)
		FROM employees E1
		where E1.department_id  = 100)
ORDER BY first_name;

SELECT E.first_name, job_id , salary
FROM employees E
WHERE salary IN
		(SELECT max(salary)
		FROM employees E1
		where job_id  = 'SA_REP'
		GROUP BY job_id )
AND WHERE E.department_id  = 100
ORDER BY first_name desc;

SELECT E.first_name, job_id , salary
FROM employees E
WHERE salary IN
		(SELECT max(salary)
		FROM employees E1
		WHERE E1.department_id  = 100
		GROUP BY job_id )
ORDER BY first_name ;

答案：C。

88.在上面给出的查询中（选项 C 是正确答案），您需要显示部门 100 中具有最高薪水的所有具有 JOB ID ‘SA_REP’ 的员工。以下哪个查询将给出所需的输出?

SELECT E.first_name, job_id , salary
FROM employees E
WHERE salary IN
		(SELECT max(salary)
		FROM employees E1
		WHERE E1.department_id  = 100
		GROUP BY job_id )
AND job_id  = 'SA_REP'
ORDER BY first_name;

SELECT E.first_name, job_id , salary
FROM employees E
WHERE salary in
		(SELECT max(salary)
		FROM employees E1
		WHERE E1.department_id  = 100)
ORDER BY first_name;

SELECT E.first_name, job_id , salary
FROM employees E
WHERE salary in
		(SELECT max(salary)
		FROM employees E1
		WHERE job_id  = 'SA_REP'
		GROUP BY job_id )
And WHERE E.department_id  = 100
ORDER BY first_name desc;

SELECT E.first_name, job_id , salary
FROM employees E
WHERE salary in
		(SELECT max(salary)
		FROM employees E1
		WHERE E1.department_id  = 100
		GROUP BY job_id )
ORDER BY first_name ;

答案：A。

89. 选择将提供最高薪水和最高通讯百分比的查询。如果薪水最高的员工获得最大通信百分比，则查询还应给出支付的最大通信百分比。

SELECT employee_id, max(salary), max(commission_pct )
FROM employees E
GROUP BY salary, commission_pct ;

SELECT employee_id, max(salary), max(commission_pct )
FROM employees E
GROUP BY salary;

SELECT employee_id, max(salary)
FROM employees E
GROUP BY salary, commission_pct 
HAVING max(commission_pct ) = 100;

SELECT employee_id,
(SELECT max(salary) FROM employees) * (SELECT max(commission_pct ) FROM employees)
FROM DUAL;

90.SQL 语句的 SELECT 子句中使用的子查询正确的是什么？

这些子查询在所有方面都与 FROM 或 WHERE 子句中使用的相同
这些子查询必须是单行子查询
在编写此类子查询时，我们可以使用多行运算符
以上都不是

答案：B。

91.以下查询的结果是什么？（考虑给定的表结构）

SQL> DESC employees
 Name			 Null?	  Type
 ----------------------- -------- ----------------
 EMPLOYEE_ID		 NOT NULL NUMBER(6)
 FIRST_NAME			  VARCHAR2(20)
 LAST_NAME		 NOT NULL VARCHAR2(25)
 EMAIL			 NOT NULL VARCHAR2(25)
 PHONE_NUMBER			  VARCHAR2(20)
 HIRE_DATE		 NOT NULL DATE
 JOB_ID 		 NOT NULL VARCHAR2(10)
 SALARY 			  NUMBER(8,2)
 COMMISSION_PCT 		  NUMBER(2,2)
 MANAGER_ID			  NUMBER(6)
 DEPARTMENT_ID			  NUMBER(4)

SELECT sysdate,
(SELECT max(salary) FROM employees GROUP BY department_id )
FROM DUAL;

它给出了每个部门的系统日期和最高工资
它给出了所有部门的最高工资
它抛出一个 ORA 错误
它以 0 行成功执行

答案：C . SQL 语句的 SELECT 子句中不能使用多行子查询。只有单行子查询可以嵌套在外部查询的 SELECT 子句中。

检查给定的表结构。考虑以下查询并回答后面的问题 92 到 95：

SQL> DESC employees
 Name			 Null?	  Type
 ----------------------- -------- ----------------
 EMPLOYEE_ID		 NOT NULL NUMBER(6)
 FIRST_NAME			  VARCHAR2(20)
 LAST_NAME		 NOT NULL VARCHAR2(25)
 EMAIL			 NOT NULL VARCHAR2(25)
 PHONE_NUMBER			  VARCHAR2(20)
 HIRE_DATE		 NOT NULL DATE
 JOB_ID 		 NOT NULL VARCHAR2(10)
 SALARY 			  NUMBER(8,2)
 COMMISSION_PCT 		  NUMBER(2,2)
 MANAGER_ID			  NUMBER(6)
 DEPARTMENT_ID			  NUMBER(4)

SELECT salary
FROM employees
WHERE salary > ALL (10, 20, 30);

92.以下哪个查询等价于上述查询？

SELECT salary
FROM employees
WHERE salary >10 or salary > 20 and salary >30;

SELECT salary
FROM employees
WHERE salary <10 and salary < 20 and salary <30;

SELECT salary
FROM employees
WHERE salary >10 and salary > 20 and salary >30;

SELECT salary
FROM employees
WHERE salary >10 and salary > 20 or salary < 30;

答案：C。当 ALL 子句后跟一个列表时，该问题以简化的方式显示了它。

93. 如果在上述查询中列表 (10,20,30) 被子查询替换，以下哪个查询将给出部门编号 100 所需的输出？

SELECT E.salary
FROM employees E
WHERE E.salary > (SELECT  E1.salary
FROM employees E1
WHERE E1.department_id  = 100);

SELECT E.salary
FROM employees E
WHERE E.salary >ALL (SELECT  E1.salary
FROM employees E1
WHERE E1.department_id  = 100);

SELECT E.salary
FROM employees E
WHERE E.salary = (SELECT  E1.salary
FROM employees E1
WHERE E1.department_id  = 100);

SELECT E.salary
FROM employees E
WHERE E.salary >= (SELECT  E1.salary
FROM employees E1
WHERE E1.department_id  = 100);

答案：B . 当 ALL 子句后跟子查询时，该问题以简化的方式显示了 ALL 子句

94.关于上面的问题 14，如果 ALL 必须替换为 ANY，以下哪个是等效的查询？

SELECT E.salary
FROM employees E
WHERE NOT EXISTS (E.salary =ANY (SELECT  E1.salary
FROM employees E1
WHERE E1.department_id  = 100);

SELECT E.salary
FROM employees E
WHERE E.salary >ANY (SELECT  E1.salary
FROM employees E1
WHERE E1.department_id  = 100);

SELECT E.salary
FROM employees E
WHERE E.salary =ANY (SELECT  E1.salary
FROM employees E1
WHERE E1.department_id  = 100);

SELECT E.salary
FROM employees E
WHERE NOT ( E.salary <= ANY (SELECT  E1.salary
FROM employees E1
WHERE E1.department_id  = 100));

答案：D . 使用 ‘<= ANY’ 时使用的 NOT 运算符用于否定子查询返回的结果

95.关于问题94，如果不使用运算符ANY，以下哪个查询是正确的？

SELECT E.salary
FROM employees E
WHERE NOT EXISTS (E.salary = ANY (SELECT  E1.salary
FROM employees E1
WHERE E1.department_id  = 100);

SELECT E.salary
FROM employees E
WHERE NOT EXISTS (SELECT  E1.salary
FROM employees E1
WHERE E1.department_id  = 100
And E.salary <= E1.salary);

A或B
以上都不是

答案：B.关联子查询引用外层查询中的一列，对外层查询中的每一行都执行一次子查询；EXISTS 运算符用于测试是否存在关系或链接。不相关的子查询首先执行子查询并将值传递给外部查询。

检查给定的表结构。考虑以下查询并回答后面的问题 96 到 98：

SQL> DESC employees
 Name			 Null?	  Type
 ----------------------- -------- ----------------
 EMPLOYEE_ID		 NOT NULL NUMBER(6)
 FIRST_NAME			  VARCHAR2(20)
 LAST_NAME		 NOT NULL VARCHAR2(25)
 EMAIL			 NOT NULL VARCHAR2(25)
 PHONE_NUMBER			  VARCHAR2(20)
 HIRE_DATE		 NOT NULL DATE
 JOB_ID 		 NOT NULL VARCHAR2(10)
 SALARY 			  NUMBER(8,2)
 COMMISSION_PCT 		  NUMBER(2,2)
 MANAGER_ID			  NUMBER(6)
 DEPARTMENT_ID			  NUMBER(4)

SELECT salary
FROM employees
WHERE salary > ANY (10, 20, 30);

96. 以下哪个查询与上述查询等效？

SELECT salary
FROM employees
WHERE salary >10 or salary > 20 and or >30;

SELECT salary
FROM employees
WHERE salary <10 and salary < 20 and salary <30;

SELECT salary
FROM employees
WHERE salary >10 and salary > 20 or salary >30;

SELECT salary
FROM employees
WHERE salary >10 and salary > 20 or salary < 30;

答案： A.当 ANY 子句后跟一个列表时，该问题以简化的方式显示了该子句。

97. 在上面的查询中，如果列表 (10, 20, 30) 被一个子查询替换，以下哪个查询会给出部门编号 100 所需的输出？

SELECT E.salary
FROM employees E
WHERE E.salary > (SELECT  E1.salary
FROM employees E1
WHERE E1.department_id  = 100);

SELECT E.salary
FROM employees E
WHERE E.salary >ANY (SELECT  E1.salary
FROM employees E1
WHERE E1.department_id  = 100);

SELECT E.salary
FROM employees E
WHERE E.salary = (SELECT  E1.salary
FROM employees E1
WHERE E1.department_id  = 100);

SELECT E.salary
FROM employees E
WHERE E.salary >= (SELECT  E1.salary
FROM employees E1
WHERE E1.department_id  = 100);

答案：B.该问题以简化的方式显示 ANY 子句后跟子查询时

98.关于上面的问题 97，如果删除 ANY，以下哪个是等效的查询？

SELECT E.salary
FROM employees E
WHERE NOT EXISTS (E.salary =ANY (SELECT  E1.salary
FROM employees E1
WHERE E1.department_id  = 100);

SELECT E.salary
FROM employees E
WHERE EXISTS (SELECT  E1.salary
FROM employees E1
WHERE E1.department_id  = 100
And E.salary >E1.salary);

SELECT E.salary
FROM employees E
WHERE EXISTS (SELECT  E1.salary
FROM employees E1
WHERE E1.department_id  = 100
);

SELECT E.salary
FROM employees E
WHERE IN (SELECT  E1.salary
FROM employees E1
WHERE E1.department_id  = 100);

答案：B . EXISTS 运算符可以替代 ANY 运算符。关联子查询引用外层查询中的一列，对外层查询中的每一行都执行一次子查询；EXISTS运算符用于测试是否存在关系或链接。

99. 检查给定的表结构。如果提到的子查询返回 0 行，将生成多少行？

SQL> DESC employees
 Name			 Null?	  Type
 ----------------------- -------- ----------------
 EMPLOYEE_ID		 NOT NULL NUMBER(6)
 FIRST_NAME			  VARCHAR2(20)
 LAST_NAME		 NOT NULL VARCHAR2(25)
 EMAIL			 NOT NULL VARCHAR2(25)
 PHONE_NUMBER			  VARCHAR2(20)
 HIRE_DATE		 NOT NULL DATE
 JOB_ID 		 NOT NULL VARCHAR2(10)
 SALARY 			  NUMBER(8,2)
 COMMISSION_PCT 		  NUMBER(2,2)
 MANAGER_ID			  NUMBER(6)
 DEPARTMENT_ID			  NUMBER(4)

SELECT E.salary
FROM employees E
WHERE E.salary > ANY ( select E1.salary FROM employees E1 where E1.department_id  = 100);

1 排
没有行
A或B
以上都不是

答案：B.如果子查询返回零行，则 ‘> ANY’ 条件的计算结果为 FALSE，因此返回“无行”。

100. 子查询必须放置在外部查询的 HAVING 子句中，如果：

内部查询需要引用返回给外部查询的值。
内部查询返回的值将与外部查询中的分组数据进行比较。
子查询向外部查询返回多个值。
以上都不是。不能在外部查询的 HAVING 子句中使用子查询。

答案：B。当需要根据某些条件限制查询的分组结果时，使用 HAVING 子句。如果必须将子查询的结果与组函数进行比较，则必须将内部查询嵌套在外部查询的 HAVING 子句中。