SQL - 使用分组函数的问题

上一页
下一页

1. 以下哪个不是GROUP BY函数？

  1. MAX
  2. MIN
  3. NVL
  4. AVG

答案：C. NVL是一个通用函数，用于为NULL值提供替代值。MAX、MIN和AVG函数可以用作GROUP BY函数。

2. 以下哪些函数可以在SELECT查询中不用GROUP BY子句？

  1. COUNT
  2. MAX
  3. MIN
  4. AVG

答案：A，B，C，D.所有列出的分组函数都可以在查询中使用，前提是SELECT查询中没有选择其他列。

3. 以下哪个SELECT查询返回薪资最高的员工所在部门编号？（考虑给定的表结构）

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_id , max(salary ) FROM employees ;
  2. SELECT department_id , max(salary ) FROM employees  GROUP BY department_id ;
  3. SELECT max(salary ) FROM employees  GROUP BY department_id ;
  4. SELECT max(salary ) FROM employees ;

答案：B.MAX函数可以用来返回每个部门中最高的薪资，其中每个组由一个部门构成。

4. 关于COUNT函数，以下哪些说法是正确的？

  1. COUNT函数计算行数
  2. COUNT(*)函数计算包含重复值和NULL值的行数
  3. COUNT(DISTINCT)函数计算不同行数
  4. COUNT(*)等价于COUNT(ALL)

答案：B.COUNT(*)计算行数，包括重复值和NULL值。使用DISTINCT和ALL关键字来限制重复值和NULL值。

5. GROUP BY函数接受哪些合适的数据类型？

  1. 嵌套表
  2. NUMBER
  3. CLOB
  4. DATE

答案：B.带有参数的函数的数据类型可以是CHAR、VARCHAR2、NUMBER或DATE。

6. 表T_COUNT有12个数字值：1, 2, 3, 32, 1, 1, null, 24, 12, null, 32, null。预测以下查询的输出。

SELECT COUNT (*) FROM t_count;
  1. 12
  2. 6
  3. 9
  4. 抛出异常，因为COUNT函数不适用于NULL值

答案：A.COUNT(*)计算行数，包括重复值和NULL值。使用DISTINCT和ALL关键字来限制重复值和NULL值。

7. 表T_COUNT有12个数字值：1, 2, 3, 32, 1, 1, null, 24, 12, null, 32, null。预测以下查询的输出。

SELECT COUNT (num) FROM t_count;
  1. 12
  2. 6
  3. 9
  4. 抛出异常，因为COUNT函数不适用于NULL值

答案：C.COUNT(列)忽略NULL值，但计算重复值。

8. 表T_COUNT有12个数字值：1, 2, 3, 32, 1, 1, null, 24, 12, null, 32, null。预测以下查询的输出。

SELECT COUNT (ALL num) FROM t_count;
  1. 12
  2. 6
  3. 9
  4. 抛出异常，因为COUNT函数不适用于NULL值

答案：C.COUNT(ALL 列)忽略NULL值，但计算重复值。

9. 表T_COUNT有12个数字值：1, 2, 3, 32, 1, 1, null, 24, 12, null, 32, null。预测以下查询的输出。

SELECT COUNT (DISTINCT num) FROM t_count;
  1. 12
  2. 6
  3. 9
  4. 抛出异常，因为COUNT函数不适用于NULL值

答案：B.COUNT(DISTINCT 列)计算不同的非NULL值。

10. 在SQL*Plus中执行以下查询时会发生什么？

SELECT COUNT() FROM dual;
  1. 成功执行并返回无输出
  2. 成功执行并返回输出为'1'
  3. 抛出异常“ORA-00909:无效的参数个数”
  4. 抛出异常“ORA-00904: “COUNT”:无效的标识符”，因为COUNT函数不适用于DUAL表

答案：C.COUNT函数需要至少一个参数，该参数可以是带有[ALL | DISTINCT]修饰符的列或'*'。

11. 以下是关于SQL中VARIANCE函数的一些语句。

i. 该函数接受多个数值输入并返回所有值的方差

ii. 该函数接受一个数字列并返回所有列值的方差，包括NULL值

iii. 该函数接受一个数字列并返回所有列值的方差，不包括NULL值

从以下选项中选择正确的组合。

  1. i和iii
  2. i和ii
  3. ii
  4. iii

答案：C.VARIANCE函数接受单个数值参数作为列名，并返回所有列值的方差，包括NULL值。

12. 以下哪个不是SQL中的GROUP BY扩展？

  1. GROUP BY
  2. GROUPING SETS
  3. CUBE
  4. ROLLUP

答案：A.GROUPING SETS操作可以用来用单个查询执行多个GROUP BY聚合。

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 department_id , SUM(salary )
FROM employees 
GROUP BY department_id ;
  1. SUM是一个分组函数，因为它处理在某个部门工作的员工组
  2. SUM是一个聚合函数，因为它为每组数据生成一个结果
  3. SUM是一个单行函数，因为它为一个组（即部门）返回单个值
  4. SUM是一个GROUP BY扩展函数，因为它使用GROUP BY子句逻辑地分组部门

答案：A.SUM是一个分组函数，它计算在某个部门工作的员工组的薪资总和。

14. 使用分组函数基于聚合结果过滤查询输出使用哪个子句？

  1. WHERE
  2. LIMIT
  3. GROUP WHERE
  4. HAVING

答案：D.HAVING子句用于限制组结果。使用HAVING子句指定要显示的组，从而基于聚合信息进一步限制组。HAVING子句可以放在GROUP BY子句之前，但建议先放置GROUP BY子句，因为它更符合逻辑。在HAVING子句应用于SELECT列表中的组之前，会先形成组并计算分组函数。

15. 检查给定的表结构并预测以下查询的结果。

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 count(*)
FROM employees 
WHERE comm = NULL;
  1. 查询返回没有佣金的员工人数
  2. 查询抛出错误，因为在搜索NULL值时不能使用等号
  3. 查询返回佣金为NULL值的部门中的员工人数
  4. 查询抛出错误，因为查询中缺少GROUP BY子句

答案：B.使用WHERE条件排除NULL值是指示查询忽略NULL值的一种方法。但此处IS NULL运算符的用法是错误的。条件应该是'WHERE comm IS NULL'。

16. 关于分组函数，以下哪项陈述是正确的？

  1. MIN函数只能用于数值数据。
  2. MAX函数只能用于日期值。
  3. AVG函数只能用于数值数据。
  4. SUM函数不能作为嵌套函数的一部分。

答案：C.AVG函数只能用于数值。其他有此限制的函数包括SUM、STDDEV和VARIANCE。

17. 以下哪个是有效的SELECT语句？

  1. SELECT AVG(retail-cost) FROM books GROUP BY category;
  2. SELECT category, AVG(retail-cost) FROM books;
  3. SELECT category, AVG(retail-cost) FROM books WHERE AVG(retail-cost) > 8.56 GROUP BY category;
  4. SELECT category, AVG(retail-cost) Profit FROM books GROUP BY category HAVING profit > 8.56;

答案：A.列别名不能用于GROUP BY或HAVING子句。

18. 以下哪个陈述是正确的？

  1. 如果函数未列在SELECT子句中，则WHERE子句只能包含分组函数。
  2. 分组函数不能用于SELECT、FROM或WHERE子句。
  3. HAVING子句总是先于WHERE子句处理。
  4. GROUP BY子句总是先于HAVING子句处理。

答案：D.尽管Oracle如果HAVING子句在GROUP BY子句之前也不会报错，但它只在GROUP BY子句处理完毕且组准备过滤后才处理。

19. 以下哪个不是有效的SQL语句？

  1. SELECT MIN(pubdate) FROM books GROUP BY category HAVING pubid = 4;
  2. SELECT MIN(pubdate) FROM books WHERE category = 'COOKING';
  3. SELECT COUNT(*) FROM orders WHERE customer# = 1005;
  4. SELECT MAX(COUNT(customer#)) FROM orders GROUP BY customer#;

答案：A。

20. 以下哪个陈述是正确的？

  1. COUNT函数可以用来确定有多少行包含NULL值。
  2. 除非SELECT子句中包含ALL关键字，否则分组函数只包含不同的值。
  3. WHERE子句限制处理哪些行。
  4. HAVING子句确定在查询结果中显示哪些组。

答案：C，D.WHERE子句在分组和处理行之前限制行，而HAVING子句限制组。

21. 以下哪个是有效的SQL语句？

  1. SELECT customer#, order#, MAX(shipdate-orderdate) FROM orders GROUP BY customer# WHERE customer# = 1001;
  2. SELECT customer#, COUNT(order#) FROM orders GROUP BY customer#;
  3. SELECT customer#, COUNT(order#) FROM orders GROUP BY COUNT(order#);
  4. SELECT customer#, COUNT(order#) FROM orders GROUP BY order#;

答案：B.GROUP BY子句必须包含所有列，除了在分组函数中使用的列。

22. 以下哪个SELECT语句只列出利润最大的图书？

  1. SELECT title, MAX(retail-cost) FROM books GROUP BY title;
  2. SELECT title, MAX(retail-cost) FROM books GROUP BY title HAVING MAX(retail-cost);
  3. SELECT title, MAX(retail-cost) FROM books;
  4. 以上都不是

答案：A。

23. 以下哪个/哪些陈述是正确的？

1. 分组函数可以嵌套在分组函数内。

2. 分组函数可以嵌套在单行函数内。

3. 单行函数可以嵌套在分组函数内。

  1. 1
  2. 2
  3. 3
  4. 1和3

答案：A，B，C.分组函数最多只能嵌套两层。分组函数可以嵌套在单行函数内（AVG嵌套在TO_CHAR函数内）。此外，单行函数可以嵌套在分组函数内。

24. 以下哪个函数用于计算指定列中存储的总值？

  1. COUNT
  2. ADD
  3. TOTAL
  4. SUM

答案：D.SUM函数用于获取数值的加和。

25. 以下哪个SELECT语句列出家庭类所有图书的最高零售价？

  1. SELECT MAX(retail) FROM books WHERE category = 'FAMILY';
  2. SELECT MAX(retail) FROM books HAVING category = 'FAMILY';
  3. SELECT retail FROM books WHERE category = 'FAMILY' HAVING MAX(retail);
  4. 以上都不是

答案：A.由于必须在分组之前限制类别FAMILY，因此必须使用WHERE子句而不是HAVING子句来过滤表行。

26. 以下哪些函数可用于将NULL值包含在计算中？

  1. SUM
  2. NVL
  3. MAX
  4. MIN

答案：B.NVL是一个通用函数，用于为NULL值提供替代值。它在使用AVG、STDDEV和VARIANCE分组函数进行算术计算时确实可以发挥作用。

27. 以下哪个不是有效的陈述？

  1. 必须在分组函数中输入ALL关键字才能包含所有重复值。
  2. AVG函数可用于查找两个日期之间计算出的平均差。
  3. MIN和MAX函数可用于VARCHAR2列。
  4. 以上都是

答案：A.ALL关键字计算重复值，但忽略NULL值。使用'*'和列名规范也会包含重复值。

28. 以下哪个SQL语句确定有多少客户是由其他客户推荐的？

  1. SELECT customer#, SUM(referred) FROM customers GROUP BY customer#;
  2. SELECT COUNT(referred) FROM customers;
  3. SELECT COUNT(*) FROM customers;
  4. SELECT COUNT(*) FROM customers WHERE referred IS NULL;

答案：B. 将所有客户视为一个组，COUNT(referred) 只计算那些被他人推荐的客户。COUNT(referred) 会忽略该列的 NULL 值。

29. 确定以下 SELECT 语句中子句的正确执行顺序。

1. SELECT

2. FROM

3. WHERE

4. GROUP BY

5. HAVING

6. ORDER BY

  1. 2-3-4-5-1-6
  2. 1-2-3-4-5-6
  3. 6-5-4-3-2-1
  4. 5-4-2-3-1-6

答案：A. 处理顺序从 FROM 子句开始，获取表名，然后使用 WHERE 子句限制行，使用 GROUP BY 子句对它们进行分组，使用 HAVING 子句限制组。ORDER BY 子句是最后处理的，用于对最终数据集进行排序。

30. 以下哪个子句用于基于一列或多列对一组行进行分组？

  1. HAVING
  2. WHERE
  3. GROUP BY
  4. GROUPING

答案：C. GROUP BY 子句根据指定的列列表形成数据的组。

31. 以下哪些分组函数可用于总体方差和总体标准差问题？

  1. VAR_POP
  2. STDDEV_POP
  3. VARIANCE
  4. STDDEV_SASMP

答案：A, B。

32. 选择 SELECT 查询中可以出现分组函数的位置。

  1. SELECT 语句
  2. WHERE 子句
  3. ORDER BY 子句
  4. GROUP BY 子句

答案：A, C, D. 分组函数可以出现在 SELECT、ORDER BY 和 HAVING 子句中。如果在 WHERE 或 GROUP BY 子句中使用分组函数，Oracle 会引发异常。

33. 检查给定的 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 department_id , MIN (salary ) from EMPLOYEES ;
  2. SELECT department_id , MIN (salary ) from EMPLOYEES  GROUP BY department_id ;
  3. SELECT department_id , MIN (salary ) from EMPLOYEES  GROUP BY salary ;
  4. SELECT department_id , MIN (salary ) from EMPLOYEES  GROUP BY employee_id ;

答案：B. MIN 函数返回由部门形成的组中的最低工资。

34. 检查 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 COUNT(*), COUNT(all comm) FROM employees ;
  1. 它抛出错误，因为查询中只能使用一个聚合函数。
  2. 它抛出错误，因为缺少 GROUP BY 子句。
  3. 它成功执行并返回两个相同的值。
  4. 它成功执行，其中 COUNT(*) 包括 NULL 值，而 COUNT(all comm) 排除 NULL 值。

答案：D。

35. 关于分组函数，以下哪些说法是正确的？

  1. 你可以在 SELECT 语句的任何子句中使用分组函数。
  2. 你只能在 SELECT 子句的列列表和 SELECT 语句的 WHERE 子句中使用分组函数。
  3. 通过对单行列进行分组，你可以在 SELECT 子句的列列表中将单行列与分组函数混合使用。
  4. 你可以将列名、表达式、常量或函数作为参数传递给分组函数。

答案：C. 分组函数最多只能嵌套两层。分组函数可以嵌套在单行函数中（嵌入在 TO_CHAR 函数中的 AVG）。此外，单行函数可以嵌套在分组函数中。

36. 检查给定的 EMPLOYEES 表的结构。你希望通过执行以下 SQL 语句创建一个“emp_dept_sales”视图。

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)
CREATE VIEW emp_dept_sales
AS
SELECT d.department_name , sum(e.salary )
FROM employees  e, departments  d
where e.department_id =d.department_id 
GROUP by d.department_name ;

关于上述语句的执行，哪个语句是正确的？

  1. 视图将被创建，你可以在视图上执行 DML 操作
  2. 视图不会被创建，因为不允许使用连接语句创建视图
  3. 视图不会被创建，因为不允许使用 GROUP BY 子句创建视图
  4. 视图将被创建，但不允许在视图上执行 DML 操作

答案：D. 在视图上执行 DML 操作的规则。如果视图包含分组函数或 GROUP BY 子句或 DISTINCT 关键字，则无法通过视图添加数据。伪列 ROWNUM 关键字 基表中未被视图选择的非空列。由表达式定义的列。

37. 关于视图，以下哪些陈述是正确的？

  1. 定义视图的子查询不能包含 GROUP BY 子句
  2. 使用包含 DISTINCT 关键字的子查询创建的视图可以更新
  3. 可以在使用包含表所有非空列的子查询创建的视图上执行数据操作语言 (DML) 操作
  4. 使用包含伪列 ROWNUM 关键字的子查询创建的视图无法更新

答案：C, D. 在视图上执行 DML 操作的规则。如果视图包含分组函数或 GROUP BY 子句或 DISTINCT 关键字，则无法通过视图添加数据。伪列 ROWNUM 关键字 基表中未被视图选择的非空列。由表达式定义的列。

38. 检查给定的表结构。

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)

以下 SQL 查询中的哪个子句会生成错误？

SELECT department_id , avg(salary )
FROM departments 
WHERE upper(job) in ('SALES','CLERK')
GROUP BY job
ORDER BY department_id ;
  1. WHERE
  2. SELECT
  3. ORDER BY
  4. GROUP BY

答案：D. GROUP BY 子句必须包含 SELECT 语句中出现的所有列。它会引发错误，因为 JOB 不是选定的列。它应该使用 DEPARTMENT_ID 代替 JOB。

39. 检查给定的表结构。

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 查询将显示每个职位类别获得的最高和最低工资？

  1. SELECT job, MAX(salary ), MIN (salary ) FROM employees  GROUP BY department_id ;
  2. SELECT job, MAX(salary ), MIN (salary ) FROM employees  GROUP BY job;
  3. SELECT job, MAX(salary ), MIN (salary ) FROM employees ;
  4. 在 SELECT 语句中不能一起使用两个聚合函数。

答案：B. SELECT 语句中可以出现多个分组函数。

40. 考虑给定的表结构。

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_id 
FROM employees 
WHERE hiredate > '01-JAN-1985'
AND COUNT(*) > 2
GROUP by department_id 
HAVING SUM (salary ) > 1000;
  1. 它成功执行并生成所需的结果。
  2. 它产生错误，因为 COUNT(*) 也应该在 SELECT 子句中指定。
  3. 它成功执行，但没有产生结果，因为应该使用 COUNT(prod_id) 代替 COUNT(*)。
  4. 它产生错误，因为 COUNT(*) 应该只在 HAVING 子句中，而不是在 WHERE 子句中。

答案：D. 分组函数不能在 WHERE 子句中使用。它们可以出现在 SELECT、HAVING 和 ORDER BY 子句中。

41. 检查给定的表结构。

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 job, COUNT(employee_id ),sum(salary )
FROM employees 
GROUP BY job
HAVING SUM (salary ) > 5000;
  1. 它成功执行并列出每个职位类别下员工的数量，但忽略 HAVING 子句，因为“salary”不在 GROUP BY 子句中。
  2. 它抛出错误，因为 HAVING 子句无效。
  3. 它抛出错误，因为“salary”未包含在 GROUP BY 子句中。
  4. 它成功执行并列出每个类别下工资总和大于 5000 的员工数量。

答案：D. HAVING 子句限制组结果。COUNT 函数用于计数，而 SUM 函数用于添加数值。

42. 在包含 NULL 值的列上使用分组函数的情况如何？

  1. 列上的分组函数忽略 NULL 值。
  2. 返回日期的列上的分组函数包括 NULL 值。
  3. 返回数字的列上的分组函数包括 NULL 值。
  4. 列上的分组函数不能精确地用于包含 NULL 值的列。

答案：A. 除 COUNT 函数外，所有分组函数都忽略 NULL 值。

43. 关于在子查询中使用 GROUP BY 列的以下哪些陈述是正确的？

  1. 子查询可以包含 GROUP BY 和 ORDER BY 子句。
  2. 子查询不能包含 GROUP BY 和 ORDER BY 子句。
  3. 子查询可以包含 ORDER BY 但不能包含 GROUP BY 子句。
  4. 子查询不能包含 ORDER BY 但可以包含 GROUP BY 子句。

答案：A. 与主查询一样，子查询也可以包含 GROUP BY 和 ORDER BY 子句。

检查给定的表结构并回答接下来的问题 44 到 49。

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)

44. 预测以下查询的结果

SELECT avg(max(salary ))
FROM employees 
GROUP BY department_id 
HAVING avg(max(salary ))>100;
  1. 它成功执行。
  2. 它给出错误，因为 HAVING 子句无效。
  3. 它给出错误，因为 GROUP BY 表达式无效。
  4. 它给出错误，因为聚合函数不能嵌套在 SELECT 语句中。

答案：B. HAVING 子句不允许嵌套聚合函数。

45. 预测以下查询的输出

SELECT avg(salary ), department_id 
FROM employees 
GROUP BY department_id ;
  1. 它给出错误，因为聚合函数不能出现在 SELECT 子句之后。
  2. 它给出错误，因为 GROUP BY 子句无效。
  3. 它执行时没有错误，但没有产生输出。
  4. 它成功执行并给出每个部门的平均工资。

答案：D. 在 SELECT 查询中，分组函数可以在任何顺序（在 group by 列之前或之后）使用。

46. 预测以下查询的输出

SELECT lower(job),avg(salary )
FROM employees 
GROUP BY upper(job);
  1. 它成功执行并以小写显示“job”。
  2. 它成功执行，但以原始大小写显示“job”。
  3. 它抛出错误，因为单行函数和聚合函数不能一起使用。
  4. 它抛出错误，因为 SELECT 列表中的大小写转换与 GROUP BY 子句的大小写转换不匹配。

答案：D. LOWER 函数是一个单行函数，必须在 GROUP BY 子句中指定，才能基于 EMPLOYEES 数据进行分组。

47. 以下哪个查询成功执行？

  1. SELECT employee_id , COUNT(hiredate-sysdate) FROM employees ;
  2. SELECT AVG(salary ), MAX(salary ) FROM employees ;
  3. SELECT AVG(salary ), MAX(salary ) FROM employees  GROUP BY department_id ;
  4. SELECT AVG(hiredate) FROM employees ;

答案：B, C. 第一个查询对整个 EMPLOYEES 数据进行操作，而第二个查询对部门组的数据进行处理。

48. 确定以下 SELECT 语句中的错误。

SELECT department_id , AVG (salary )
FROM employees 
GROUP BY department_id 
HAVING department_id  > 10;
  1. 它成功执行并显示大于 10 的部门的平均工资。
  2. 它抛出错误，因为非聚合列不能在 HAVING 子句中使用。
  3. 它成功执行，但显示部门的错误结果。
  4. 它抛出错误，因为 HAVING 子句必须放在 GROUP BY 子句之前。

答案：A. GROUP BY 表达式可以在 HAVING 子句中使用，以从最终数据集中过滤掉组。

49. 预测以下查询的输出

SELECT department_id , AVG (salary )
FROM employees 
GROUP BY department_id 
HAVING (department_id >10 and AVG(salary )>2000);
  1. 它抛出错误，因为在 HAVING 子句中不能给出多个条件。
  2. 它抛出错误，因为非聚合列不能在 HAVING 子句中使用。
  3. 它成功执行并显示大于 10 且大于 2000 的部门的平均工资。
  4. 它成功执行，但没有显示结果。

答案：C. HAVING 子句可以使用 AND 或 OR 运算符连接的多个条件来过滤组。

50. 以下哪些分组函数可以与 DATE 值一起使用？

  1. AVG
  2. MIN
  3. SUM
  4. COUNT

答案：B, D. 分组函数 AVG 和 SUM 只能与数值数据一起使用。

51. 以下哪些陈述是正确的？

  1. AVG 和 SUM 只能与数值数据类型一起使用。
  2. STDDEV 和 VARIANCE 只能与数值数据类型一起使用。
  3. MAX 可以与 LONG 数据类型一起使用。
  4. MAX 和 MIN 函数不能用于 LOB 或 LONG 数据类型。

答案：A，B，D。 AVG、SUM、VARIANCE 和 STDDEV 等分组函数只能用于数值数据。所有分组函数都不能用于 LONG 数据类型。

52. 查看给定的表结构。

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_id , avg(salary ), count(hiredate)
FROM employees 
GROUP BY department_id ;
  1. 单个 SELECT 查询中不能使用多个聚合函数
  2. GROUP BY 子句无效
  3. COUNT 函数不能用于 DATE 值
  4. 没有错误，可以成功执行

答案：D。

53. 以下哪个分组函数可以用于 LOB 数据类型？

  1. MAX
  2. MIN
  3. COUNT
  4. 没有任何一个

答案：D。 任何聚合函数都不能用于 LOB 数据类型。

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 avg(comm)
FROM employees ;

查询 - 2

SELECT avg(nvl(comm,0))
FROM employees ;
  1. 两个查询产生相同的结果
  2. 查询 1 和查询 2 产生不同的结果，因为查询 1 考虑了 COMM 的 NULL 值，而查询 2 将 COMM 的 NULL 值替换为零
  3. 查询 1 产生错误，因为 COMM 包含 NULL 值
  4. 查询 2 产生错误，因为 NVL 不能嵌套在聚合函数中。

答案：B。 AVG 函数在计算数值数据的平均值时会忽略 NULL 值。AVG(column) 只会计算非 NULL 值的平均值。但是，如果使用 NVL 将 NULL 值替换为零，则所有值都将被考虑。

55. 选择关于 GROUP BY 子句的正确语句。

  1. 可以在 GROUP BY 子句中使用列别名。
  2. GROUP BY 列必须出现在 SELECT 子句中。
  3. GROUP BY 子句必须与 HAVING 子句一起出现在 SELECT 查询中。
  4. GROUP BY 子句必须出现在 SELECT 查询中的 WHERE 子句之后。

答案：D。 根据处理顺序，GROUP BY 子句必须出现在 SELECT 查询中的 WHERE 子句之后。

56. 查看给定的表结构。

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_id ,avg(salary )
FROM employees 
GROUP BY department_id , job
ORDER BY department_id ;
  1. 它会抛出错误，因为 GROUP BY 列列表与 SELECT 列列表不匹配。
  2. 它成功执行并产生每个部门中每个职位的平均工资。
  3. 它成功执行并产生每个职位类别中每个部门的平均工资。
  4. 它会抛出错误，因为 GROUP BY 和 ORDER BY 子句具有不同的列列表。

答案：B。 虽然 GROUP BY 子句隐式地对组进行排序，但 GROUP BY 和 ORDER BY 子句可以一起在查询中使用。

57. 应该使用哪个子句来排除使用分组函数的查询中的分组结果？

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

答案：B。 HAVING 子句用于限制组。

查看给定的表结构并回答接下来的问题 58 和 59。

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)

58. 预测以下查询的结果

SELECT department_id ,avg(salary )
FROM employees 
HAVING avg(salary )>2000
GROUP BY department_id 
ORDER BY department_id
  1. 它成功执行。
  2. 它会抛出错误，因为 HAVING 子句位于 GROUP BY 子句之前。
  3. 它会抛出错误，因为 HAVING 子句使用了聚合函数。
  4. 它会执行，但不会显示任何结果，因为 HAVING 子句位于 GROUP BY 子句之前。

答案：A。 HAVING 子句可以位于 GROUP BY 子句之前，但它只在计算分组结果后才进行处理。

59. 预测以下查询的结果

SELECT department_id , COUNT(first_name )
FROM employees 
WHERE job IN ('SALESMAN','CLERK','MANAGER','ANALYST')
GROUP BY department_id 
HAVING AVG(salary ) BETWEEN 2000 AND 3000;
  1. 它会返回错误，因为 BETWEEN 运算符不能用于 HAVING 子句。
  2. 它会返回错误，因为 WHERE 和 HAVING 子句不能在同一个 SELECT 语句中使用。
  3. 它会返回错误，因为 WHERE 和 HAVING 子句不能用于对同一列应用条件。
  4. 它成功执行。

答案：D。 WHERE 子句限制了参与分组处理的行数。

60. 关于 SELECT 语句中的 WHERE 和 HAVING 子句，哪些语句是正确的？

  1. HAVING 子句可以与子查询中的分组函数一起使用。
  2. WHERE 子句可以用于在将行分成组之后排除行。
  3. WHERE 子句可以用于在将行分成组之前排除行。
  4. 只有当 WHERE 和 HAVING 子句应用于表中的不同列时，它们才能在同一语句中使用。

答案：A，C。 WHERE 和 HAVING 子句可以一起在查询中使用。WHERE 在分组处理之前排除行，而 HAVING 限制组。

查看给定的表结构并回答接下来的问题 61 和 62。

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)

61. 预测以下查询的结果。

SELECT department_id , avg(salary )
FROM employees 
HAVING avg(salary ) > min(salary )
GROUP BY department_id ;
  1. 它会抛出错误，因为 HAVING 子句中使用的聚合函数必须在 SELECT 列表中。
  2. 它会抛出错误，因为 HAVING 子句出现在 GROUP BY 子句之前。
  3. 它显示平均工资高于部门最低工资的部门。
  4. 它显示平均工资高于公司最低工资的部门。

答案：C。 HAVING 子句可以使用分组函数来过滤组。

62. 解释以下查询的输出。

SELECT SUM(AVG(LENGTH(first_name )))
FROM employees  
GROUP BY department_id ;
  1. 它计算每个部门中员工姓名长度平均值的总和。
  2. 它计算每个部门中员工姓名长度的平均值。
  3. 它会抛出错误，因为单行函数不能与分组函数一起使用。
  4. 它会抛出错误，因为分组列 DEPARTMENT_ID 未在 SELECT 列表中使用。

答案：A。 分组函数可以在 SELECT 查询中与单行函数或一般函数一起使用。

63. 分组函数最多可以嵌套多少层？

  1. 1
  2. 2
  3. 3
  4. 没有限制

答案：B。 分组函数最多可以嵌套 2 层。但是，单行函数可以嵌套任意数量的层。

64. 由 GROUP BY 子句创建的组中组的数量限制是多少？

  1. 1
  2. 2
  3. 3
  4. 无限制

答案：D。 可以形成的组和子组的数量没有限制。

65. 选择关于 HAVING 子句的正确语句。

  1. HAVING 子句是 SELECT 语句中的可选子句。
  2. 如果 SELECT 语句使用 GROUP BY 子句，则 HAVING 子句是必需的子句。
  3. 只有当 SELECT 语句使用 GROUP BY 子句时，HAVING 子句才能出现在 SELECT 语句中。
  4. 如果 SELECT 语句使用 GROUP BY 子句，则 HAVING 子句是必需的子句。

答案：A，C。 只有在存在 GROUP BY 子句的情况下，HAVING 子句才能出现在查询中，但反之则不然。

66. 下面查询的输出是什么？

SELECT count(*) FROM dual GROUP BY dummy;
  1. 1
  2. 0
  3. NULL
  4. 抛出错误，因为分组函数不能应用于 DUAL 表。

答案：A。 DUAL 表包含单个名为 DUMMY 的列，类型为 CHAR(1)，其值为 'X'。

根据以下场景，回答第 67 至 74 个问题。

一家公司有 14 名员工，他们的固定工资为 1000。公司又招聘了 5 名新员工，他们的工资尚未由薪资部门确定。但是，在月底处理期间，人力资源薪资部门会生成几份报告来核对公司的财务数据。查看给定的表结构。

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)

67. 下面查询的输出是什么？

SELECT SUM (salary ) FROM employees ;
  1. NULL
  2. 14000
  3. 19000
  4. 0

答案：B。 SUM 函数将员工的工资相加。

68. 下面查询的输出是什么？

SELECT AVG (salary ) FROM employees ;
  1. 1000
  2. 736.84
  3. NULL
  4. 0

答案：A。 AVG(salary) 函数计算工资的平均值，并忽略 NULL 值。在这种情况下，AVG(salary) = (14 * 1000) / 14 = 1000。

69. 下面查询的输出是什么？

SELECT AVG (nvl(salary ,0)) FROM employees ;
  1. 1000
  2. NULL
  3. 736.84
  4. 0

答案：C。 AVG(NVL(salary, 0)) 为 NULL 值提供替代值，并使它们能够参与平均值计算。在这种情况下，(14 * 1000) / 19 = 736.84。

70. 下面查询的输出是什么？

SELECT VARIANCE (salary ) FROM employees ;
  1. 1000
  2. 0
  3. NULL
  4. 204678.36

答案：B。 VARIANCE(salary) 计算工资列值的方差，忽略 NULL 值。

71. 下面查询的输出是什么？

SELECT VARIANCE (nvl(salary ,0)) FROM employees ;
  1. 1000
  2. 0
  3. NULL
  4. 204678.36

答案：D。 VARIANCE(NVL(salary, 0)) 计算工资列值的方差，包括 NULL 值。

72. 下面查询的输出是什么？

SELECT STDDEV (salary ) FROM employees ;
  1. 1
  2. 1000
  3. 0
  4. NULL

答案：C。 STDDEV(salary) 计算工资列值的标准差，忽略 NULL 值。

73. 下面查询的输出是什么？

SELECT STDDEV (nvl(salary ,0)) FROM employees ;
  1. 0
  2. 452.41
  3. 1000
  4. NULL

答案：B。 STDDEV(NVL(salary, 0)) 计算工资列值的标准差，包括 NULL 值。

74. 下面查询的输出是什么？

select count(*),count(salary ) from employees ;
  1. 19,19
  2. 14,19
  3. 19,14
  4. 14,14

答案：C。 COUNT(*) 包括 NULL 值，而 COUNT(salary) 忽略 NULL 值。

75. 查看给定的表结构。

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)

以下哪个查询将给出拥有 5 名以上员工的部门？

  1. SELECT department_id  FROM employees  WHERE COUNT(*) > 5 GROUP BY department_id ;
  2. SELECT department_id  FROM employees  HAVING COUNT(*) > 5;
  3. SELECT department_id  FROM employees  GROUP BY employee_id  HAVING COUNT(*) > 5;
  4. SELECT department_id  FROM employees  GROUP BY department_id  HAVING COUNT(*) > 5;

答案：D。

76. 关于 GROUP BY 的 CUBE 扩展，以下哪些说法是正确的？

  1. 能够使用单个查询执行多个 GROUP BY 子句。
  2. 对包含的所有列的所有可能组合执行聚合。
  3. 根据提供的列列表，执行越来越多的累积小计。
  4. 以上都不是

答案：B。 CUBE、ROLLUP 是用于 OLAP 处理的 GROUP BY 扩展。CUBE 在形成列的新排列时聚合结果。

使用以下 SELECT 语句回答下面的问题 77 到 82

1 SELECT customer#, COUNT(*)
2 FROM customers JOIN orders USING (customer#)
3 WHERE orderdate > '02-APR-09'
4 GROUP BY customer#
5 HAVING COUNT(*) > 2;

77. SELECT 语句的哪一行用于限制查询处理的记录数？

  1. 1
  2. 3
  3. 4
  4. 5

答案：B。 WHERE 子句用于在形成组之前限制行。

78. SELECT 语句的哪一行用于限制查询结果中显示的组？

  1. 1
  2. 3
  3. 4
  4. 5

答案：D。 HAVING 用于在组处理结束后限制组结果。

79. SELECT 语句的哪一行用于对数据库中存储的数据进行分组？

  1. 1
  2. 3
  3. 4
  4. 5

答案：C。 GROUP BY 子句使用分组列对表中的数据进行分组。

80. 为了使查询成功执行，必须包含哪个子句？

  1. 1
  2. 3
  3. 4
  4. 5

答案：C。 因为 SELECT 子句包含 CUSTOMER# 列，所以必须使用包含 CUSTOMER# 列的 GROUP BY 子句。

81. 在 SELECT 查询中使用 COUNT(*) 的目的是什么？

  1. 指定表中的记录数
  2. 每个客户下的订单数量
  3. 指定表中 NULL 值的数量
  4. 下过订单的客户数量

答案：B. 它计算在分组下处理的行数。在本例中，分组是由客户形成的，COUNT(*) 计算每个客户下的订单数量。

82. 以下哪个函数可以用来确定 JustLee Books 最近处理的所有订单的最早发货日期？

  1. COUNT 函数
  2. MAX 函数
  3. MIN 函数
  4. STDDEV 函数

答案：C. MIN 函数用于检索列的最小值。当用于日期列时，它会从列中获取最小日期。

83. 以下哪个不是有效的 SELECT 语句？

  1. SELECT STDDEV(retail) FROM books;
  2. SELECT AVG(SUM(retail)) FROM orders NATURAL JOIN orderitems NATURAL JOIN books GROUP BY customer#;
  3. SELECT order#, TO_CHAR(SUM(retail),'999.99') FROM orderitems JOIN books USING (isbn) GROUP BY order#;
  4. SELECT title, VARIANCE(retail-cost) FROM books GROUP BY pubid;

答案：D. GROUP BY 子句必须指定 SELECT 子句中包含的列或列集。此处 PUBID 不包含在 SELECT 子句中，因此查询无效。

84. 关于分组函数的嵌套，以下哪些说法是正确的？

  1. 最内层的函数先被解析。
  2. Oracle 允许分组函数嵌套最多 3 层。
  3. 单行函数可以与分组函数嵌套。
  4. Oracle 允许分组函数嵌套最多 2 层。

答案：A、C、D. 在包含嵌套函数的表达式中，最内层的函数首先执行，其结果被馈送到下一个函数，向外移动。单行函数可以很好地与分组函数一起使用，最多可以嵌套 2 层。

85. Oracle 中的统计分组函数有哪些？

  1. AVG
  2. STDDEV
  3. VARIANCE
  4. STATS

答案：B、C. VARIANCE 和 STATS 是 Oracle SQL 中可用的统计分组函数。

86. 如果 SELECT 列表包含一个列和一个分组函数，则必须强制包含以下哪个子句？

  1. ORDER BY
  2. HAVING
  3. GROUP BY
  4. 没有任何一个

答案：C. GROUP BY 子句必须包含 SELECT 子句中包含的列或列集。

87. 检查给出的表结构。

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 语句无法执行的最佳解释是什么？

SELECT department_id "Department", AVG (salary)"Average"
FROM employees
GROUP BY Department;
  1. 薪水不能平均，因为并非所有数字都能被整除。
  2. 不能在 GROUP BY 子句中使用列别名。
  3. GROUP BY 子句必须有分组的内容。
  4. 部门 ID 未列在部门表中。

答案：B. GROUP BY 子句和 HAVING 子句都不能与列别名一起使用。

88. 以下哪些数据类型与 AVG、SUM、VARIANCE 和 STDDEV 函数兼容？

  1. 只有数值数据类型
  2. 仅整数
  3. 任何数据类型
  4. 除数值类型外的所有类型

答案：A. AVG、SUM、VARIANCE 和 STDDEV 函数必须仅与数值数据类型一起使用。

检查下面给出的表结构，并回答后面的第 89 和 90 题。

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)

89. 以下哪个查询将显示每个部门工作的不同职位类别的数量？

  1. SELECT department_id , COUNT(DISTINCT job) FROM employees  GROUP BY job;
  2. SELECT department_id , COUNT(job) FROM employees  GROUP BY employee_id ;
  3. SELECT department_id , COUNT(job) FROM employees  GROUP BY department_id ;
  4. SELECT department_id , COUNT(DISTINCT job) FROM employees  GROUP BY department_id ;

答案：D. 使用 DISTINCT 修饰符过滤掉重复项。

90. 评估此 SQL 语句

SELECT employee_id , first_name , department_id , SUM(salary )
FROM employees 
WHERE salary  > 1000
GROUP BY department_id , employee_id , first_name 
ORDER BY hiredate;

为什么此语句会出错？

  1. 缺少 HAVING 子句。
  2. WHERE 子句包含语法错误。
  3. SALARY 列未包含在 GROUP BY 子句中。
  4. HIRE_DATE 列未包含在 GROUP BY 子句中。

答案：D. SELECT 和 ORDER BY 子句中出现的所有列都必须包含在 GROUP BY 子句中。

91. 关于 GROUP BY 子句，以下哪个陈述是正确的？

  1. 要使用 GROUP BY 子句在将行分成组之前排除行，应使用 WHERE 子句。
  2. 必须将 HAVING 子句与 GROUP BY 子句一起使用。
  3. 可以在 GROUP BY 子句中使用列别名。
  4. 默认情况下，使用 GROUP BY 子句时不会对行进行排序。

答案：A. 使用 WHERE 子句，可以在将行分成组之前排除行。

92. 检查给出的表结构。

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_id , MIN (hiredate)
FROM employees 
GROUP by department_id ;
  1. 组织中最早的雇佣日期。
  2. 组织中最新的雇佣日期。
  3. 部门中最早的雇佣日期。
  4. 部门中最新的雇佣日期。

答案：C. 查询返回每个部门中最早被雇佣的员工。

93. 关于分组函数，哪个语句是正确的？

  1. 除 COUNT(*) 外的所有分组函数都忽略 NULL 值。
  2. SELECT 列表中包含分组函数的查询必须包含 GROUP BY 子句。
  3. 分组函数可以在 WHERE 子句中使用。
  4. 分组函数只能在 SELECT 列表中使用。

答案：A. 除 COUNT(*) 外的所有分组函数都忽略 NULL 值。这是因为它们直接处理特定列中包含的值。

94. 以下哪些子句代表分组函数的有效用法？

  1. GROUP BY MAX(salary)
  2. ORDER BY AVG(salary)
  3. HAVING MAX(salary) > 10000
  4. SELECT AVG(NVL(salary, 0))

答案：B、C、D. 分组函数只能出现在 SELECT、HAVING 和 ORDER BY 子句中。

95. 关于 GROUP BY 子句，以下哪些陈述是正确的？

  1. GROUP BY 子句中列出的最后一列是最主要的分组。
  2. GROUP BY 子句中列出的第一列是最主要的分组。
  3. 不能在没有 ORDER BY 子句的情况下使用 GROUP BY 子句。
  4. GROUP BY 子句不能确保输出的排序。

答案：B. 数据的分组基于 GROUP BY 子句中出现的列的顺序。

96. WHERE 子句和 HAVING 子句有什么区别？

  1. WHERE 子句在分组之前限制行，而 HAVING 子句限制组。
  2. WHERE 子句不能包含分组函数，但 HAVING 子句可以。
  3. WHERE 子句可以使用 AND 或 OR 运算符连接多个条件，但 HAVING 子句不能。
  4. WHERE 子句可以在没有 GROUP BY 子句的 SELECT 查询中出现，但 HAVING 子句不能。

答案：A、B、D. WHERE 子句在分组之前限制行，而 HAVING 子句限制组。

97. 检查给出的表结构。

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_id ,job,count(*)
FROM employees 
GROUP BY department_id ,job
ORDER BY department_id ,count(*);
  1. 它成功执行。
  2. 由于 ORDER BY 子句无效，它会抛出错误。
  3. 由于 GROUP BY 子句无效，它会抛出错误。
  4. 由于 GROUP BY 和 ORDER BY 子句不能一起使用，它会抛出错误。

答案：A. ORDER BY 子句可以使用分组函数进行排序。

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