SQL - 子查询解决查询问题

上一页
下一页

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

  1. 有序子查询
  2. 分组子查询
  3. 单行子查询
  4. 以上都不是

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

2. 关于子查询，以下哪一项是正确的？

  1. 它们在主查询执行后执行
  2. 它们与主查询并行执行
  3. 用户可以先执行主查询，然后根据需要执行子查询
  4. 它们在主查询执行前执行。

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

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

  1. 执行时通常会忽略子查询的结果。
  2. 子查询的结果不会产生结果，它只是有助于加快主查询的执行速度
  3. 子查询的结果被主查询使用。
  4. 子查询的结果始终为 NULL

答案：C. 子查询先完成。子查询的结果用作外部查询的输入。

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

  1. SELECT
  2. WHERE
  3. ORDER BY
  4. GROUP BY

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

5. 在主查询中编写子查询的方法是什么？

  1. 使用 JOIN
  2. 使用 WHERE 子句
  3. 使用 GROUP BY 子句
  4. 在另一个 SELECT 语句的子句中嵌入 SELECT 语句

答案：D. 子查询是嵌套在另一个查询的 SELECT、FROM、HAVING 或 WHERE 子句中的完整查询。子查询必须用括号括起来，至少包含 SELECT 和 FROM 子句。

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

  1. 当我们需要对值求和时
  2. 当我们需要将字符值转换为日期或数值时
  3. 当我们需要从表中选择行，而条件取决于相同表或不同表中的数据时。
  4. 以上都不是

答案：C.

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

  1. HAVING
  2. WHERE
  3. FROM
  4. 以上所有

答案：D. 子查询与普通查询没有什么不同。它可以使用 SELECT 语句的所有主要子句。

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

  1. >=
  2. <
  3. =
  4. 以上所有

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

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

  1. IN
  2. ANY
  3. ALL
  4. 以上所有

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

10. 关于从子查询获得的输出，哪一项是正确的？

  1. 它保留在缓冲区缓存中
  2. 它保留在子查询中，以后需要时可以使用
  3. 它用于完成外部（主）查询
  4. 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)
  1.  SELECT first_name, last_name, salary
FROM employees 
WHERE salary > (SELECT salary
FROM employees 
WHERE job_id = 'VICE-PRESIDENT'); 
  2. SELECT first_name, last_name, salary
FROM employees 
WHERE salary = (SELECT salary
FROM employees 
WHERE job_id = 'VICE-PRESIDENT'); 
  3. SELECT first_name, last_name, salary
FROM employees 
WHERE job_id = 'VICE-PRESIDENT');
  4. 以上都不是

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

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

  1. 子查询可以写在比较运算符的两侧
  2. 子查询不需要括号
  3. 单行子查询可以使用多行运算符，反之则不行
  4. 以上所有

答案：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);
  1. 它成功执行并给出所需的结果
  2. 它成功执行，但没有给出所需的结果
  3. 它抛出 ORA 错误
  4. 它成功执行并为结果集中的每一行给出两个值

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

14. 关于单行子查询，以下哪一项是正确的？

  1. 它们从主查询中给出一个结果
  2. 它们在结果集中只给出一行
  3. 它们只从内部 SELECT 语句返回一行
  4. 它们从主（外部）查询中给出多行

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

15. 关于多行子查询，哪一项是正确的？

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

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

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

  1. 它们只返回一行
  2. 它们使用单行运算符
  3. A 和 B
  4. 以上都不是

答案：C.

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

  1. AND
  2. <
  3. >
  4. <>

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

查看图表并回答接下来的第 18 至 21 题。

Table EMPLOYEES Table DEPARTMENTS

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

  1. SELECT first_name, last_name
FROM employees
WHERE last_name = 'Butcher'
And first_name = 'Jessica'; 
  2. SELECT first_name, last_name
FROM employees
WHERE department =100; 
  3. SELECT first_name, last_name
FROM employees
WHERE department  = (SELECT department
FROM employees
WHERE first_name = 'Jessica'
AND last_name = 'Butcher'); 
  4. 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. 您需要找出属于“Jessica Butcher”部门且薪水高于员工 ID 为 40 的“Jessica Butcher”薪水的员工。以下哪个查询有效？

  1. SELECT first_name, last_name
FROM employees
WHERE last_name = 'Butcher'
AND first_name = 'Jessica'
AND salary > 10000; 
  2. SELECT first_name, last_name
FROM employees
WHERE department = 100; 
  3. 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); 
  4. 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 题的答案，它们使用了哪种类型的子查询？

  1. 单行子查询
  2. 多行子查询
  3. A 和 B
  4. 内联子查询

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

21. 考虑关于 SQL 子查询中外部查询和内部查询的两个陈述？

i. 内部查询只能从一个表获取数据

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

以上哪些陈述是正确的？

  1. (i)
  2. (ii)
  3. (i) 和 (ii)
  4. (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);
  1. 它成功执行并给出薪水等于最高薪水的员工。
  2. 它成功执行，但没有给出所需的结果
  3. 它抛出一个错误，因为在子查询中使用了组函数
  4. 它抛出一个错误，因为单行子查询应该包含多行运算符

答案：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);
  1. 它成功执行并给出所有员工的姓名和大于 100 部门的最低薪水
  2. 它成功执行并给出 100 部门员工的薪水
  3. 它成功执行并给出所有员工的姓名和最低薪水。
  4. 它抛出一个错误。

答案：A. 如所示，HAVING 子句可在子查询中使用

24. 您需要找到平均薪水最高的职位。以下哪个查询将为您提供所需的结果？

  1. SELECT job_id, avg(salary)
FROM employees
GROUP BY job_id; 
  2. SELECT job_id, avg(salary)
FROM employees
GROUP BY job_id
HAVING job_id in (SELECT max(avg(salary) FROM employees); 
  3. SELECT job_id, avg(salary)
FROM employees
GROUP BY job_id
HAVING max(avg(salary) in (SELECT max(avg(salary) FROM employees); 
  4. 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);
  1. 子查询不需要 GROUP BY 子句
  2. 子查询 SELECT 语句中不能使用函数
  3. 单行子查询给出多条记录
  4. “=”运算符的使用无效；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. 1
  2. NULL
  3. 0
  4. 该查询引发 ORA 错误，因为子查询无效。

答案：C。由于公司中没有 job_id 为“XX”的员工，因此子查询不返回任何结果，当与主查询中的 job_id 比较时，结果为 0。

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

  1. 1
  2. 14
  3. 0
  4. ORA 错误

答案：D。查询执行引发异常“ORA-01427: single-row subquery returns more than one row”。

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

  1. <=
  2. ANY >=
  3. !=
  4. >=

答案：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 运算符计算结果是什么？

  1. TRUE
  2. FALSE
  3. NULL
  4. 0

答案：A。多行运算符返回布尔值结果。由于部门 100 中存在 salary 的结果，因此返回 TRUE。如果结果为 0，则计算结果为 FALSE。

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

  1. 它成功执行并返回一个结果
  2. 它成功执行并返回所有员工的工资
  3. NULL
  4. 它抛出 ORA 错误

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

31.如果将上述查询中的 < ANY 运算符替换为 = ANY 运算符，结果将会怎样？

  1. Oracle 将像使用 IN 运算符一样处理子查询返回的每个 salary 值
  2. 结果将没有区别
  3. 结果将有所不同
  4. 执行将抛出一个 ORA 错误

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

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

  1. 它给出工资的最大值
  2. 它给出工资的最小值
  3. 这意味着它给出小于最高值的值
  4. 以上都不是

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

<

33.假设将 < ANY 运算符替换为 > ANY。关于此运算符，哪个说法是正确的？

  1. 它给出最高工资
  2. 它只查找子查询中的最高工资
  3. 它给出大于最低工资的值
  4. 它给出最低工资

答案：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 子句等效于上述查询中的 WHERE 子句？（假设工资为 2500、3000、3500、4000）

  1. WHERE salary < ANY (SELECT max(salary)
			FROM employees
			GROUP BY department_id ); 
  2. WHERE salary < ALL (SELECT max(salary)
			FROM employees
			GROUP BY department_id ); 
  3. WHERE salary = (SELECT max(salary)
			FROM employees
			GROUP BY department_id ); 
  4. 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.您需要找出哪些员工的工资低于 job ID 为 'FIN_ACT' 的员工的工资。以下哪个查询将为您提供所需的结果？

  1. 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'; 
  2. 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'; 
  3. 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'; 
  4. 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.如果将上述查询（上题中的选项 A）中的 < ALL 替换为 >ALL，结果将会怎样？

  1. 它将成功执行并返回相同的结果。
  2. 它将抛出一个 ORA 错误
  3. 它将成功执行，但会给出工资低于所有 job_id 为 'FI_ACCOUNTANT' 的员工的员工的详细信息。
  4. 以上都不是

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

37.您需要查找不在部门 100 的所有员工的工资。以下哪个查询将为您提供所需的结果？

  1. SELECT employee_id, first_name, last_name
FROM employees
WHERE salary !=ALL 
		(SELECT salary
		FROM employees
		WHERE department_id  = 100)
		AND department_id  <> 100; 
  2. 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; 
  3. 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; 
  4. 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.上述查询的结果是什么？

  1. 10
  2. NULL
  3. ORA 错误
  4. 0

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

39.应向上述查询添加/修改以下哪个 WHERE 子句才能得到预期的结果？

  1. WHERE employee_id != (SELECT manager_id FROM employees); 
  2. WHERE employee_id IN (SELECT manager_id FROM employees);  
  3. WHERE employee_id <>ALL (SELECT manager_id FROM employees); 
  4. WHERE employee_id NOT IN (SELECT manager_id
			FROM employees
			WHERE manager_id is NOT NULL);

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

40.一般来说，关于子查询，哪个说法是正确的？

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

答案：C.

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

  1. 子查询可以返回 0 行或多行
  2. 子查询只能用于 SELECT 子句
  3. 子查询的嵌套限制为 2 层
  4. 分组函数不能用于子查询

答案：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);

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

  1. 使用的 NOT IN 运算符无效
  2. 子查询中的 WHERE 子句编写不正确
  3. 当主查询中使用不等式时，子查询 SELECT 子句中的列应只有一个
  4. 子查询使用与主查询相同的表

答案：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)
  1. SELECT department_name
FROM employees
WHERE department_id  IN (SELECT distinct (department_id )
			FROM employees); 
  2. SELECT department_name
FROM employees
WHERE department_id  ANY (SELECT distinct (department_id )
			FROM employees); 
  3. SELECT department_name
FROM employees
WHERE department_id  < ANY (SELECT distinct (department_id )
			FROM employees); 
  4. SELECT department_name
FROM employees
WHERE department_id  = ANY (SELECT distinct (department_id )
			FROM employees);

答案：A、D。

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

  1. 20
  2. 50
  3. 无限制
  4. 255

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

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

  1. 使用 GROUP BY
  2. 使用子查询
  3. 使用 HAVING
  4. 以上都不是

答案：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.您需要查找所有 job ID 与 ID 为 210 的员工的 job ID 相同的员工。为了实现此结果，您将添加/修改以下哪个 WHERE 子句？（考虑给定的表结构

  1. WHERE job_id = (SELECT job_id FROM employees WHERE employee_id = 210); 
  2. WHERE job_id IN (SELECT job_id FROM employees WHERE employee_id = 210); 
  3. WHERE job_id > (SELECT job_id FROM employees WHERE employee_id = 210); 
  4. 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);

此更改的结果是什么？

  1. 结果将相同
  2. 执行时抛出 ORA 错误
  3. 结果将有所不同
  4. 查询将成功执行并返回 0 行。

答案：B。给定更改后，子查询返回多个结果，因此应将主查询中给出的“=”替换为多行运算符。

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

Table EMPLOYEES Table GRADE

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

  1. SELECT first_name, last_name, grade
FROM employees, grade
WHERE (SELECT max (salary) FROM employees) BETWEEN losal and hisal; 
  2. 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; 
  3. SELECT first_name, last_name, grade
FROM employees, grade
WHERE salary = (SELECT max (salary) FROM employees) 
AND salary BETWEEN losal and hisal; 
  4. 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 子句中的子查询是什么？（选择最合适的答案）

  1. 单行子查询
  2. 多行子查询
  3. 内联视图
  4. 相关子查询

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

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

  1. 255
  2. 300
  3. 216
  4. 无限制

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

51.关于相关子查询，哪个说法是正确的？

  1. 主查询中使用的表也用于相关子查询
  2. 引用主查询中使用的列的子查询称为相关子查询。
  3. 不带括号编写的子查询称为相关子查询。
  4. 强制使用与主查询中使用的表不同的表的子查询称为相关子查询。

答案：B。相关子查询引用外部查询中的列，并为外部查询中的每一行执行一次子查询，而非相关子查询先执行子查询，然后将值传递给外部查询。

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

  1. SELECT
  2. GROUP BY
  3. UPDATE
  4. DELETE

答案：B。其余选项可以作为子查询的主查询（父查询）。

53.关于相关子查询，哪个说法是正确的？

  1. 它只为父查询评估一次。
  2. 它只为父查询评估三次。
  3. 它为父查询处理的每一行评估一次。
  4. 以上所有

答案：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)
  1. 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 ; 
  2. 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 ; 
  3. 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 ; 
  4. 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)
  1. SELECT *
FROM employees E
WHERE exists (SELECT 1 FROM employees E1
		WHERE E.employee_id = E1.employee_id); 
  2. SELECT *
FROM employees E
WHERE exists (SELECT 1 FROM employees E1
		WHERE E.employee_id = E1.employee_id
		AND E.ROWID < E1.ROWID); 
  3. SELECT *
FROM employees E
WHERE exists (SELECT 1 FROM employees E1
		WHERE E.ROWID < E1.ROWID); 
  4. 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 表中的记录计数？

  1. SELECT sysdate,
		(SELECT * FROM departments) dept_count,
		(SELECT * FROM employees) emp_count
FROM DUAL; 
  2. SELECT sysdate,
		(SELECT count(*) FROM departments) dept_count,
		(SELECT count(*) FROM employees) emp_count
FROM DUAL
GROUP BY department_id ; 
  3. SELECT sysdate,
		(SELECT * FROM departments) dept_count,
		(SELECT * FROM employees) emp_count
FROM DUAL
GROUP BY employee_id; 
  4. SELECT sysdate,
		(SELECT count(*) FROM departments) dept_count,
		(SELECT count(*) FROM employees) emp_count
FROM DUAL;

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

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

  1. SELECT employee_id, manager_id
FROM employees A
WHERE employee_id ANY (SELECT manager_id from employees B)
ORDER BY manager_id desc; 
  2. SELECT employee_id, manager_id
FROM employees A
WHERE employee_id < ALL (SELECT manager_id from employees B)
  3. SELECT employee_id, manager_id
FROM employees A
WHERE employee_id IN (SELECT manager_id from employees B)
ORDER BY manager_id desc; 
  4. SELECT employee_id, manager_id
FROM employees A
WHERE employee_id in (SELECT manager_id from employees B)
GROUP BY department_id ;

答案：C.

检查图表并回答接下来的问题 58。

Table EMPLOYEES Table DEPARTMENTS Table LOCATIONS

58.以下哪个查询将提供特定城市中员工的最高薪水？

  1. SELECT max (salary), city
FROM
(SELECT salary, department_id , loc, city
FROM employees natural join departments natural join locations); 
  2. SELECT salary, city
FROM
(SELECT salary, department_id , loc, city
FROM employees natural join departments natural join locations); 
  3. SELECT max (salary), city
FROM
(SELECT salary, department_id , loc, city
FROM employees natural join departments natural join locations)
GROUP BY city; 
  4. 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.以下哪个查询可以使用子查询替换上面的查询，并得到相同的结果？

  1. SELECT department_name
FROM departments
WHERE department_id  = ANY (SELECT department_id  FROM employees); 
  2. SELECT department_name
FROM departments
WHERE department_id  IN (SELECT distinct(department_id ) FROM employees); 
  3. SELECT department_name
FROM departments
WHERE department_id  = (SELECT distinct(department_id ) FROM employees); 
  4. 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 );

此更改的结果是什么？（选择最合适的答案）

  1. 它将对从子查询获取的 department_id 进行排序，并按升序显示它们。
  2. 由于 ORDER BY 子句应与 GROUP BY 子句一起使用，因此它将抛出 ORA 错误。
  3. 它将抛出 ORA 错误，因为在子查询中不能使用 ORDER BY 子句。
  4. 它将成功执行。

答案：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;

此更改的结果是什么？（选择最合适的答案）

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

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

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

  1. ORDER BY
  2. HAVING
  3. GROUP BY
  4. 以上所有

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

检查下面的图表，并回答接下来的问题 63 到 65。

Table AUDIT

考虑以下查询

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.上面给出的查询的结果是什么？

  1. 它提供所有以字母“S%”开头的 AU_ID 和 AU_TITLE。
  2. 它提供所有以字母“S%”开头的 AU_ID 和 AU_TITLE，并按标题升序排序。
  3. 它抛出 ORA 错误
  4. 它返回 0 值。

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

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);

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

  1. 由于使用了 MAX 函数，因此应使用 GROUP BY 子句。
  2. 两个子查询不能在同一个外层查询中使用相同的 department ID。
  3. BETWEEN 运算符不能与子查询一起使用。
  4. SELECT 子句应该提到列，而不是星号 (*)。

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

65.关于在查询中使用 NOT IN 与子查询一起编写时，哪个说法是正确的？

  1. NOT IN 忽略所有 NULL 值，只给出非 NULL 值。
  2. NOT IN 将所有 NULL 值放在最后，并首先显示非 NULL 值。
  3. 如果结果集预期为 NULL 值，则不应使用 NOT IN。
  4. NOT IN 只是 IN 运算符的否定，可以随意更改。

答案：C。SQL 以不同的方式处理 NULL 值，因此如果结果集可能包含 NULL 值，最好避免使用 NOT IN。

考虑以下表结构，并回答接下来的问题 66 到 72。

Table EMPLOYEES Table DEPARTMENTS

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

  1. SELECT department_id , min(salary)
FROM employees
GROUP BY department_id 
HAVING min(salary) >
		(
		select max(salary)
		FROM employees
		where department_id  = 10
		)
  2. SELECT department_id , min(salary)
FROM employees
GROUP BY department_id 
HAVING min(salary) > ANY
		(
		select max(salary)
		FROM employees
		)
  3. SELECT department_id , min(salary)
FROM employees
HAVING max(salary) < ANY
		(
		select min(salary)
		FROM employees
		where department_id  = 10
		)
  4. 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 的至少一名员工薪水的员工。（选择最佳答案）

  1. SELECT employee_id, Salary
FROM employees
WHERE salary in
		(
		SELECT salary
		FROM employees
		where department_id  = 10
		)
  2. SELECT employee_id, Salary
FROM employees
WHERE salary =ANY
		(
		SELECT salary
		FROM employees
		where department_id  = 10
		)
  3. SELECT employee_id, Salary
FROM employees
WHERE salary ALL
		(
		SELECT salary
		FROM employees
		where department_id  = 10
		)
  4. SELECT employee_id, Salary
FROM employees
WHERE salary  < ANY
		(
		SELECT salary
		FROM employees
		where department_id  = 10
		)

答案：A，B。

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

  1. SELECT employee_id, Salary
FROM employees
WHERE salary >= ANY
		(
		SELECT salary
		FROM employees
		where department_id  = 10
		)
  2. SELECT employee_id, Salary
FROM employees
WHERE salary > ANY
		(
		SELECT salary
		FROM employees
		where department_id  = 10
		)
  3. SELECT employee_id, Salary
FROM employees
WHERE salary < ANY
		(
		SELECT salary
		FROM employees
		where department_id  = 10
		)
  4. SELECT employee_id, Salary
FROM employees
WHERE salary = ALL
		(
		SELECT salary
		FROM employees
		where department_id  = 10
		)

答案：B。

69.你需要找出所有薪水低于部门 10 中所有员工薪水的员工。以下哪个查询将给出所需的输出？

  1. SELECT employee_id, Salary
FROM employees
WHERE salary > ALL
		(
		SELECT salary
		FROM employees
		where department_id  = 10
		)
  2. SELECT employee_id, Salary
FROM employees
WHERE salary =ALL
		(
		SELECT salary
		FROM employees
		where department_id  = 10
		)
  3. SELECT employee_id, Salary
FROM employees
WHERE salary < ALL
		(
		SELECT salary
		FROM employees
		where department_id  = 10
		)
  4. 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 的员工匹配的员工。以下哪个查询将给出所需的输出？

  1. 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)
		)
  2. 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)
		)
  3. 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)
		)
  4. 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 的员工的部门名称。以下哪个查询是正确的？（选择最合适的答案）

  1. 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
  2. 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; 
  3. 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
  4. 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”的收入最高的员工。以下哪个查询是正确的？（选择最合适的答案）

  1. 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' 

  2. 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'
)
  3. 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'
)
  4. 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。

Table EMPLOYEES

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

  1. SELECT employee_id, Job_id
FROM employees E
WHERE exists
(
SELECT 1
FROM employees E1
WHERE E.job_id  = E1.job_id )
  2. SELECT employee_id, Job_id 
FROM employees E
WHERE exists
(
SELECT *
FROM employees E1
WHERE E.job_id  = E1.job_id )
  3. SELECT employee_id, Job_id 
FROM employees E
WHERE not exists
(
SELECT *
FROM employees E1
WHERE E.job_id  = E1.job_id )
  4. SELECT employee_id, Job_id 
FROM employees E
WHERE exists
(
SELECT 1
FROM employees E1
WHERE E.job_id  < E1.job_id )

答案：A。EXISTS 运算符用于检查和匹配查询之间的记录。它返回布尔值。相关子查询引用外部查询中的列，并为外部查询中的每一行执行一次子查询；EXISTS 运算符用于测试是否存在关系或链接。非相关子查询先执行子查询，然后将值传递给外部查询。

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

  1. SELECT employee_id, Job_id 
FROM employees E
WHERE exists
(
SELECT *
FROM employees E1
WHERE E.job_id  = E1.job_id )
  2. SELECT employee_id, Job_id 
FROM employees E
WHERE not exists
(
SELECT 1
FROM employees E1
WHERE E.job_id  = E1.job_id )
  3. SELECT employee_id, Job_id 
FROM employees E
WHERE not exists
(
SELECT *
FROM employees E1
WHERE E.job_id  = E1.job_id )
  4. 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 表中找到第三高的薪水。以下哪个查询将给出所需的结果？（选择最合适的答案）

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

答案：D。

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

  1. SELECT salary FROM 
(
	SELECT rowid as user_sal 
	FROM (SELECT distinct salary  from employees ORDER BY salary  desc)
) 
WHERE user_sal=&N ; 
  2. SELECT salary FROM 
(	
	SELECT rownum as user_sal
	FROM (SELECT distinct salary  FROM employees   		GROUP BY salary )
) 
WHERE user_sal <= &N ; 
  3. SELECT salary FROM 
(
	SELECT rownum as user_sal, salary 	FROM (SELECT distinct salary  FROM employees 		 ORDER BY salary  desc)
) 
WHERE user_sal=&N ; 
  4. 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.如果在上述查询（第76题的选项C）中提供给&N变量的值与任何行都不匹配，将会发生什么？（选择最佳答案）

  1. 语句将抛出一个ORA错误
  2. 语句将返回表中的所有行
  3. 语句将返回NULL作为输出结果。
  4. 语句将不返回任何结果行。

答案：D。

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

  1. 255
  2. 100
  3. 2
  4. 16

答案：A。

79.关于SQL查询中EXISTS运算符与子查询的关系，哪个说法是正确的？

  1. 子查询中选择的列很重要
  2. 内部查询应该返回行，任何结果都很重要，而不是选择的列。
  3. A 和 B
  4. A和B都不对

答案：B。

80.关于用于子查询的ANY运算符，哪个说法是正确的？

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

答案：C.

81.关于用于子查询的ALL运算符，哪个说法最准确？（选择最合适的答案。）

  1. 返回与列表/子查询中所有值匹配的行
  2. 返回仅与列表/子查询中某些值匹配的行
  3. 仅当所有值都与列表/子查询中匹配时才返回行
  4. 以上所有

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

82.关于在Oracle的INSERT语句中使用子查询，哪个说法是正确的？

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

答案：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'的员工的详细信息。以下哪个查询将给出所需的结果？（考虑给出的表结构）

  1. 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'
); 
  2. 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'
); 
  3. 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'
); 
  4. 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.以下哪些语句是等价的？

  1. SELECT employee_id , salary
FROM employees 
WHERE salary < ALL (SELECT salary FROM employees WHERE department_id=100); 
  2. SELECT employee_id , salary
FROM employees WHERE salary < (SELECT min(salary) FROM employees WHERE department_id=100); 
  3. SELECT employee_id 
FROM employees 
WHERE salary not >= ANY (SELECT salary FROM employees WHERE department_id=100);
  4. 以上都不是

答案：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');

关于这两个语句，可以说什么？

  1. 两个查询都应该生成相同的结果。
  2. 两个查询都将抛出错误。
  3. 如果有两个部门名称相同，则两个查询都将失败。
  4. 即使存在多个名为'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);

上述查询的结果是什么？

  1. 它成功执行并给出所需的结果
  2. 它成功执行，但没有给出所需的输出
  3. 执行时会抛出ORA错误
  4. 当>ALL被替换为>=ALL时，它成功执行并给出所需的结果

答案：B, D. >ALL不会给出所需的结果，因为可能有两名员工拥有相同的工资，并且是部门100中收入最高的员工

考虑展品中显示的表结构，并回答接下来的第87到89题

Table EMPLOYEES Table DEPARTMENTS

87.你需要按反向字母顺序获取部门ID = 100中所有员工的姓名（firstName），并且这些员工在职位ID = 'SA_REP'中拥有最高工资。以下哪个查询将给出所需的输出？（选择最合适的输出）

  1. 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; 
  2. 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; 
  3. 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; 
  4. 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是正确的答案），你需要显示所有职位ID为'SA_REP'并且在部门100中拥有最高工资的员工。以下哪个查询将给出所需的输出？

  1. 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; 
  2. 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; 
  3. 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; 
  4. 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.选择一个查询，该查询将提供最高工资和最高佣金百分比。如果最高薪员工获得最高佣金百分比，则该查询还应提供支付的最高佣金百分比。

  1. SELECT employee_id, max(salary), max(commission_pct )
FROM employees E
GROUP BY salary, commission_pct ; 
  2. SELECT employee_id, max(salary), max(commission_pct )
FROM employees E
GROUP BY salary; 
  3. SELECT employee_id, max(salary)
FROM employees E
GROUP BY salary, commission_pct 
HAVING max(commission_pct ) = 100; 
  4. SELECT employee_id,
(SELECT max(salary) FROM employees) * (SELECT max(commission_pct ) FROM employees)
FROM DUAL;

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

90.关于在SQL语句的SELECT子句中使用的子查询，哪个说法是正确的？

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

答案：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;
  1. 它给出系统日期和每个部门的最高工资
  2. 它给出所有部门的最高工资
  3. 它抛出 ORA 错误
  4. 它成功执行，但返回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.以下哪些查询与上述查询等效？

  1. SELECT salary
FROM employees
WHERE salary >10 or salary > 20 and salary >30; 
  2. SELECT salary
FROM employees
WHERE salary <10 and salary < 20 and salary <30; 
  3. SELECT salary
FROM employees
WHERE salary >10 and salary > 20 and salary >30; 
  4. SELECT salary
FROM employees
WHERE salary >10 and salary > 20 or salary < 30;

答案：C. 问题以简化方式显示了ALL子句，在后面跟着一个列表。

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

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

答案：B. 问题以简化方式显示了ALL子句，在后面跟着一个子查询。

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

  1. SELECT E.salary
FROM employees E
WHERE NOT EXISTS (E.salary =ANY (SELECT  E1.salary
FROM employees E1
WHERE E1.department_id  = 100); 
  2. SELECT E.salary
FROM employees E
WHERE E.salary >ANY (SELECT  E1.salary
FROM employees E1
WHERE E1.department_id  = 100); 
  3. SELECT E.salary
FROM employees E
WHERE E.salary =ANY (SELECT  E1.salary
FROM employees E1
WHERE E1.department_id  = 100); 
  4. 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运算符，则以下哪个查询是正确的？

  1. SELECT E.salary
FROM employees E
WHERE NOT EXISTS (E.salary = ANY (SELECT  E1.salary
FROM employees E1
WHERE E1.department_id  = 100); 
  2. 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);
  3. A或B
  4. 以上都不是

答案：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.以下哪些查询与上述查询等效？

  1. SELECT salary
FROM employees
WHERE salary >10 or salary > 20 and or >30; 
  2. SELECT salary
FROM employees
WHERE salary <10 and salary < 20 and salary <30; 
  3. SELECT salary
FROM employees
WHERE salary >10 and salary > 20 or salary >30; 
  4. SELECT salary
FROM employees
WHERE salary >10 and salary > 20 or salary < 30;

答案：A. 问题以简化方式显示了ANY子句，在后面跟着一个列表。

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

  1. SELECT E.salary
FROM employees E
WHERE E.salary > (SELECT  E1.salary
FROM employees E1
WHERE E1.department_id  = 100); 
  2. SELECT E.salary
FROM employees E
WHERE E.salary >ANY (SELECT  E1.salary
FROM employees E1
WHERE E1.department_id  = 100); 
  3. SELECT E.salary
FROM employees E
WHERE E.salary = (SELECT  E1.salary
FROM employees E1
WHERE E1.department_id  = 100); 
  4. 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，则以下哪个查询将是等效的？

  1. SELECT E.salary
FROM employees E
WHERE NOT EXISTS (E.salary =ANY (SELECT  E1.salary
FROM employees E1
WHERE E1.department_id  = 100); 
  2. SELECT E.salary
FROM employees E
WHERE EXISTS (SELECT  E1.salary
FROM employees E1
WHERE E1.department_id  = 100
And E.salary >E1.salary); 
  3. SELECT E.salary
FROM employees E
WHERE EXISTS (SELECT  E1.salary
FROM employees E1
WHERE E1.department_id  = 100
); 
  4. 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. 1行
  2. 0行
  3. A或B
  4. 以上都不是

答案：B. 如果子查询返回零行，则'> ANY'条件将评估为FALSE，因此不返回任何行。

100.如果满足以下哪个条件，则必须将子查询放在外部查询的HAVING子句中？

  1. 内部查询需要引用返回给外部查询的值。
  2. 内部查询返回的值需要与外部查询中的分组数据进行比较。
  3. 子查询返回多个值给外部查询。
  4. 以上都不对。子查询不能用于外部查询的HAVING子句中。

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

打印页面
上一页
下一页
广告