使用组函数问题

笔记首页 >> sql_certificate >> 使用组函数问题

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

最大限度
最小
NVL
平均收入

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

2. SELECT 查询中没有 GROUP BY 子句可以使用以下哪些函数？

数数
最大限度
最小
平均收入

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

SELECT department_id , max(salary ) FROM employees ;

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

SELECT max(salary ) FROM employees  GROUP BY department_id ;

```
SELECT max(salary ) FROM employees ;
```

答案：B . MAX 函数可用于返回每个组由一个部门组成的部门的最高工资。

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

COUNT 函数计算行数
COUNT(*) 函数计算具有重复和 NULL 值的行数
COUNT(DISTINCT) 函数计算不同行的数量
COUNT(*) 等价于 COUNT(ALL)

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

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

嵌套表
数字
CLOB
日期

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

12
6
9
抛出异常，因为 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;

12
6
9
抛出异常，因为 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;

12
6
9
抛出异常，因为 COUNT 函数不适用于 NULL 值

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

9、表T_COUNT有12个数值，分别为1, 2, 3, 32, 1, 1, null, 24, 12, null, 32, null。预测以下查询的输出。

SELECT COUNT (DISTINCT num) FROM t_count;

12
6
9
抛出异常，因为 COUNT 函数不适用于 NULL 值

答案：B. COUNT（DISTINCT 列）计算不同的非空值。

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

SELECT COUNT() FROM dual;

执行成功，不返回任何输出
成功执行并返回输出为“1”
抛出异常“ORA-00909：参数数量无效”
引发异常“ORA-00904：“COUNT”：无效标识符”，因为 COUNT 函数不适用于 DUAL 表

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

11.这里有几个关于SQL中VARIANCE函数的语句。

一世。该函数接受多个数字输入并返回所有值的方差

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

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

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

我和三
我和二
ii
三

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

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

通过…分组
分组集
立方体
卷起

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

SUM 是按功能分组的，因为它处理在一个部门工作的一组员工
SUM 是一个聚合函数，因为它为每组数据生成一个结果
SUM 是一个单行函数，因为它返回一个组的单个值，即部门
SUM 是一个 group by 扩展函数，因为它使用 GROUP BY 子句对部门进行逻辑分组

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

14. 哪个子句用于使用 group by 函数根据聚合结果过滤查询输出？

在哪里
限制
组在哪里
有

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

查询返回没有佣金的员工人数
查询抛出错误，因为在搜索 NULL 值时不能使用等号
查询返回佣金为NULL值的部门员工人数
查询抛出错误，因为查询中缺少 GROUP BY 子句

答案：B.使用 WHERE 条件排除 NULL 是一种引导查询忽略 NULL 的方法。但是这里使用 IS NULL 运算符是错误的。条件应该是’WHERE comm IS NULL’。

16.下列关于群函数的说法正确的是？

MIN 函数只能用于数值数据。
MAX 函数只能用于日期值。
AVG 函数只能用于数值数据。
SUM 函数不能是嵌套函数的一部分。

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

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

SELECT AVG(retail-cost) FROM books GROUP BY category;

SELECT category, AVG(retail-cost) FROM books;

SELECT category, AVG(retail-cost) FROM books WHERE AVG(retail-cost) > 8.56 GROUP BY category;

SELECT category, AVG(retail-cost) Profit FROM books GROUP BY category HAVING profit > 8.56;

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

18.下列说法正确的是？

WHERE 子句只能包含一个组函数，如果该函数也没有在 SELECT 子句中列出。
不能在 SELECT、FROM 或 WHERE 子句中使用组函数。
HAVING 子句总是在 WHERE 子句之前处理。
GROUP BY 子句总是在 HAVING 子句之前处理。

答案：D。虽然如果 HAVING 子句在 GROUP BY 子句之前，Oracle 不会引发错误，但只有在处理 GROUP BY 子句并且组准备好过滤后才会处理它。

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

SELECT MIN(pubdate) FROM books GROUP BY category HAVING pubid = 4;

SELECT MIN(pubdate) FROM books WHERE category = 'COOKING';

SELECT COUNT(*) FROM orders WHERE customer# = 1005;

SELECT MAX(COUNT(customer#)) FROM orders GROUP BY customer#;

答案：A。

20.下列说法正确的是？

COUNT 函数可用于确定包含 NULL 值的行数。
组函数中只包含不同的值，除非 SELECT 子句中包含 ALL 关键字。
WHERE 子句限制处理哪些行。
HAVING 子句确定在查询结果中显示哪些组。

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

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

SELECT customer#, order#, MAX(shipdate-orderdate) FROM orders GROUP BY customer# WHERE customer# = 1001;

SELECT customer#, COUNT(order#) FROM orders GROUP BY customer#;

SELECT customer#, COUNT(order#) FROM orders GROUP BY COUNT(order#);

SELECT customer#, COUNT(order#) FROM orders GROUP BY order#;

答案：B . GROUP BY 子句必须包含除 group 函数内部使用的列之外的所有列。

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

SELECT title, MAX(retail-cost) FROM books GROUP BY title;

SELECT title, MAX(retail-cost) FROM books GROUP BY title HAVING MAX(retail-cost);

SELECT title, MAX(retail-cost) FROM books;

以上都不是

答案：A。

23. 以下哪些说法是正确的？

1. 组函数可以嵌套在组函数中。

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

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

1
2
3
1 和 3

答案：A、B、C。组函数只能嵌套到两个深度。组函数可以嵌套在单行函数中（AVG 嵌入到 TO_CHAR 函数中）。此外，单行函数可以嵌套在组函数中。

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

数数
添加
全部的
和

答案：D. SUM 函数用于求数值相加。

25. 以下哪个 SELECT 语句列出了 Family 类别中所有书籍的最高零售价？

SELECT MAX(retail) FROM books WHERE category = 'FAMILY';

SELECT MAX(retail) FROM books HAVING category = 'FAMILY';

SELECT retail FROM books WHERE category = 'FAMILY' HAVING MAX(retail);

以上都不是

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

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

和
NVL
最大限度
最小

答案：B. NVL 是一个通用函数，用于为 NULL 值提供替代值。它确实可以在使用 AVG、STDDEV 和 VARIANCE 组函数的算术计算中产生影响。

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

您必须在组函数中输入 ALL 关键字以包含所有重复值。
AVG 函数可用于查找两个日期之间的平均计算差异。
MIN 和 MAX 函数可用于 VARCHAR2 列。
上述所有的

答案： A. ALL 关键字计算重复但忽略 NULL。‘*’ 和列名规范也包含重复项。

28. 以下哪个 SQL 语句决定了其他客户推荐的客户总数？

SELECT customer#, SUM(referred) FROM customers GROUP BY customer#;

```
SELECT COUNT(referred) FROM customers;
```
```
SELECT COUNT(*) FROM customers;
```

SELECT COUNT(*) FROM customers WHERE referred IS NULL;

答案：B. 将所有客户视为一组，COUNT(referred) 将仅计算被某人推荐的客户。COUNT(referred) 将忽略列的 NULL 值。

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

1.选择

2.发件人

3.哪里

4.GROUP BY

5.有

6.订购者

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

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

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

有
在哪里
通过…分组
分组

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

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

VAR_POP
STDDEV_POP
方差
STDDEV_SASMP

答案：A、B。

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

选择语句
WHERE 子句
ORDER BY 子句
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)

SELECT department_id , MIN (salary ) from EMPLOYEES ;

SELECT department_id , MIN (salary ) from EMPLOYEES  GROUP BY department_id ;

SELECT department_id , MIN (salary ) from EMPLOYEES  GROUP BY salary ;

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 ;

它会引发错误，因为在查询中只能使用一个聚合函数。
它抛出错误，因为缺少 GROUP BY 子句。
它成功执行并为两者返回相同的值。
它在 COUNT(*) 包括 NULL 和 COUNT(all comm) 不包括 NULL 的情况下成功执行。

答案：D。

35. 下列关于群函数的说法正确的是？

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

答案：C.组函数只能嵌套到两个深度。组函数可以嵌套在单行函数中（AVG 嵌入到 TO_CHAR 函数中）。此外，单行函数可以嵌套在组函数中。

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 ;

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

将创建视图，您可以对视图执行 DLM 操作
视图不会被创建，因为创建视图时不允许使用 join 语句
不会创建视图，因为创建视图时不允许使用 GROUP BY 子句
将创建视图，但不允许对视图进行 DML 操作

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

37.下列关于观点的说法，哪些是正确的？

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

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

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 ;

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

答案：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 查询将显示每个工作类别的最高和最低工资？

SELECT job, MAX(salary ), MIN (salary ) FROM employees  GROUP BY department_id ;

SELECT job, MAX(salary ), MIN (salary ) FROM employees  GROUP BY job;

SELECT job, MAX(salary ), MIN (salary ) FROM employees ;

两个聚合函数不能在 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;

它成功执行并生成所需的结果。
它会产生一个错误，因为 COUNT(*) 也应该在 SELECT 子句中指定。
它成功执行但没有产生任何结果，因为应该使用 COUNT(prod_id) 而不是 COUNT(*)。
它产生一个错误，因为 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;

它成功执行并列出每个工作类别下的员工人数，但忽略 HAVING 子句，因为“salary”不在 GROUP BY 子句中。
它抛出错误，因为 HAVING 子句无效。
它引发错误，因为“salary”未包含在 GROUP BY 子句中。
它执行成功并列出每个类别下工资总和大于 5000 的员工数。

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

42. 在包含 NULL 值的列上使用组函数是什么意思？

列上的组函数忽略 NULL 值。
返回日期的列上的组函数包括 NULL 值。
返回数字的列上的组函数包括 NULL 值。
列上的组函数不能准确地用于包含 NULL 值的列。

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

43.关于子查询中GROUP BY列的使用，下列哪些说法是正确的？

子查询可以包含 GROUP BY 和 ORDER BY 子句。
子查询不能包含 GROUP BY 和 ORDER BY 子句。
子查询可以包含 ORDER BY 但不能包含 GROUP BY 子句。
子查询不能包含 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;

它执行成功。
由于 HAVING 子句无效，它给出了错误。
它给出了错误，因为 GROUP BY 表达式无效。
它给出了一个错误，因为聚合函数不能嵌套在 SELECT 语句中。

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

45. 预测以下查询的输出

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

它给出错误，因为聚合函数不能出现在 SELECT 子句之后。
它给出错误，因为 GROUP BY 子句无效。
它执行时没有错误，但不产生任何输出。
它执行成功并给出每个部门的平均工资。

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

46. 预测以下查询的输出

SELECT lower(job),avg(salary )
FROM employees 
GROUP BY upper(job);

它成功执行并以小写字母显示“job”。
它成功执行但在原始情况下显示“作业”。
它抛出错误，因为单行和聚合函数不能一起使用。
它抛出错误，因为 SELECT 列表中的大小写转换与大小写转换 GROUP BY 子句不匹配。

答案：D . LOWER 函数是一个单行函数，必须在 GROUP BY 子句中指定，以作为 EMPLOYEES 数据分组的基础。

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

SELECT employee_id , COUNT(hiredate-sysdate) FROM employees ;

SELECT AVG(salary ), MAX(salary ) FROM employees ;

SELECT AVG(salary ), MAX(salary ) FROM employees  GROUP BY department_id ;

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

它执行成功并显示高于 10 的部门的平均工资。
它抛出错误，因为在 HAVING 子句中不能使用非聚合列。
它执行成功，但为部门显示错误的结果。
它抛出错误，因为 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);

它抛出错误，因为在 HAVING 子句中不能给出多个条件。
它抛出错误，因为不能在 HAVING 子句中使用非聚合列。
执行成功，显示部门平均工资10以上2000以上。
它执行成功，但没有显示结果。

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

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

平均收入
最小
和
数数

答案：B、D。组函数 AVG 和 SUM 只能用于数值数据。

51.以下哪些说法是正确的？

AVG 和 SUM 只能用于数值数据类型。
STDDEV 和 VARIANCE 只能用于数值数据类型。
MAX 可用于 LONG 数据类型。
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 ;

不能在单个 SELECT 查询中使用多个聚合函数
GROUP BY 子句无效
COUNT 函数不能与 DATE 值一起使用
没有错误，它执行成功

答案：D。

53. 以下哪个组函数可以与 LOB 数据类型一起使用？

最大限度
最小
数数
都不是

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

两个查询产生相同的结果
Query – 1 和 Query – 2 产生不同的结果，因为 Query-1 考虑 COMM 的 NULL 值，而 Query-2 将 COMM 的 NULL 值替换为零
查询 – 1 产生错误，因为 COMM 具有 NULL 值
查询 – 2 产生错误，因为 NVL 不能与聚合函数嵌套。

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

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

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

答案：D。按照处理顺序，SELECT 查询中的 GROUP BY 子句必须出现在 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 ;

它引发错误，因为 GROUP BY 列列表与 SELECT 列列表不匹配。
它成功执行并产生每个部门工作类别的平均工资。
它成功执行并为每个工作类别的部门产生平均工资。
它引发错误，因为 GROUP BY 和 ORDER BY 子句具有不同的列列表。

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

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

在哪里
有
通过…分组
订购者

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

它执行成功。
它抛出错误，因为 HAVING 子句在 GROUP BY 子句之前。
它抛出错误，因为 HAVING 子句使用聚合函数。
它执行但不显示任何结果，因为 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;

它返回错误，因为 BETWEEN 运算符不能在 HAVING 子句中使用。
它返回一个错误，因为 WHERE 和 HAVING 子句不能在同一个 SELECT 语句中使用。
它返回错误，因为 WHERE 和 HAVING 子句不能用于在同一列上应用条件。
它执行成功。

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

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

HAVING 子句可与子查询中的组函数一起使用。
WHERE 子句可用于在将行分组后排除行。
WHERE 子句可用于在将行分组之前排除行。
只有当 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 ;

它抛出一个错误，因为在 HAVING 子句中使用的聚合函数必须在 SELECT 列表中。
它抛出错误，因为 HAVING 子句出现在 GROUP BY 子句之前。
显示平均工资高于部门最低工资的部门。
显示平均工资高于组织最低工资的部门。

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

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

SELECT SUM(AVG(LENGTH(first_name )))
FROM employees  
GROUP BY department_id ;

它计算每个部门员工姓名长度平均值的总和。
它计算每个部门员工姓名的平均长度。
它抛出错误，因为单行函数不能与组函数一起使用。
它抛出错误，因为组列 DEPARTMENT_ID 未在 SELECT 列表中使用。

答案： A.组函数可以与 SELECT 查询中的单行或通用函数一起使用。

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

1
2
3
无限

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

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

1
2
3
没有限制

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

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

HAVING 子句是 SELECT 语句中的可选子句。
如果 SELECT 语句使用 GROUP BY 子句，则 HAVING 子句是强制性子句。
HAVING 子句只有在使用 GROUP BY 子句时才能出现在 SELECT 语句中。
如果 SELECT 语句使用 GROUP BY 子句，则 HAVING 子句是强制性子句。

答案：A、C。如果存在 GROUP BY 子句，则 HAVING 子句只能出现在查询中，反之则不然。

66. 以下查询的输出是什么。

SELECT count(*) FROM dual GROUP BY dummy;

1
0
无效的
引发错误，因为无法在 DUAL 表上应用组函数。

答案： A. DUAL 表包含值为 ‘X’ 的 CHAR(1) 类型的单列 DUMMY。

根据以下情景，回答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 ;

无效的
14000
19000
0

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

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

SELECT AVG (salary ) FROM employees ;

1000
736.84
无效的
0

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

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

SELECT AVG (nvl(salary ,0)) FROM employees ;

1000
无效的
736.84
0

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

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

SELECT VARIANCE (salary ) FROM employees ;

1000
0
无效的
204678.36

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

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

SELECT VARIANCE (nvl(salary ,0)) FROM employees ;

1000
0
无效的
204678.36

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

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

SELECT STDDEV (salary ) FROM employees ;

1
1000
0
无效的

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

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

SELECT STDDEV (nvl(salary ,0)) FROM employees ;

0
452.41
1000
无效的

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

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

从员工中选择 count(*),count(salary) ；

19,19
14,19
19,14
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 名员工在其中工作的部门？

SELECT department_id  FROM employees  WHERE COUNT(*) > 5 GROUP BY department_id ;

SELECT department_id  FROM employees  HAVING COUNT(*) > 5;

SELECT department_id  FROM employees  GROUP BY employee_id  HAVING COUNT(*) > 5;

SELECT department_id  FROM employees  GROUP BY department_id  HAVING COUNT(*) > 5;

答案：D。

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

允许使用单个查询执行多个 GROUP BY 子句。
对包含的所有可能的列组合执行聚合。
根据提供的列列表执行递增级别的累积小计。
以上都不是

答案：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 语句的哪一行用于限制查询处理的记录数？

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

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

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

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

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

80. 必须包含哪个子句才能使查询成功执行？

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

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

指定表中的记录数
每个客户下的订单数量
指定表中 NULL 值的数量
已下订单的客户数量

答案：B。它统计一个组下处理的行数。在这种情况下，group 由客户组成，COUNT(*) 计算每个客户下的订单。

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

计数功能
最大值函数
最小值功能
STDDEV 函数

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

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

```
SELECT STDDEV(retail) FROM books;
```

SELECT AVG(SUM(retail)) FROM orders NATURAL JOIN orderitems NATURAL JOIN books GROUP BY customer#;

SELECT order#, TO_CHAR(SUM(retail),'999.99') FROM orderitems JOIN books USING (isbn) GROUP BY order#;

SELECT title, VARIANCE(retail-cost) FROM books GROUP BY pubid;

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

84.关于群函数的嵌套，下列哪些说法是正确的？

首先解析最内部的函数。
Oracle 允许最多 3 级嵌套组函数。
单行函数可以与组函数嵌套。
Oracle 允许最多 2 级嵌套组函数。

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

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

平均收入
标准差错
方差
统计数据

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

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

订购者
有
通过…分组
都不是

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

工资不能平均，因为并非所有数字都会平均分配。
您不能在 GROUP BY 子句中使用列别名。
GROUP BY 子句必须有 GROUP 的东西。
部门 ID 未列在部门表中。

答案：B. GROUP BY 子句和 HAVING 子句都不适用于列别名。

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

仅数字数据类型
仅整数
任何数据类型
除数字外的所有

答案： 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. 以下哪个查询将显示每个部门工作的不同职位类别的数量？

SELECT department_id , COUNT(DISTINCT job) FROM employees  GROUP BY job;

SELECT department_id , COUNT(job) FROM employees  GROUP BY employee_id ;

SELECT department_id , COUNT(job) FROM employees  GROUP BY department_id ;

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;

为什么这个语句会导致错误？

缺少 HAVING 子句。
WHERE 子句包含语法错误。
SALARY 列不包含在 GROUP BY 子句中。
HIRE_DATE 列不包含在 GROUP BY 子句中。

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

91. 下列关于 GROUP BY 子句的说法正确的是？

要在使用 GROUP BY 子句将它们分组之前排除行，您应该使用 WHERE 子句。
您必须将 HAVING 子句与 GROUP BY 子句一起使用。
列别名可以在 GROUP BY 子句中使用。
默认情况下，使用 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 ;

组织中最早的雇用日期。
组织中的最新雇用日期。
部门中最早的雇用日期。
部门的最新雇用日期。

答案：C。查询返回各部门最早录用的员工。

93.关于群函数的说法正确的是？

除 COUNT(*) 之外的组函数，忽略空值。
在 SELECT 列表中包含组函数的查询必须包含 GROUP BY 子句。
组函数可以在 WHERE 子句中使用。
组函数只能在 SELECT 列表中使用。

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

94. 以下哪些条款代表了群函数的有效使用？

GROUP BY MAX（薪水）
ORDER BY AVG（薪水）
拥有 MAX(salary) > 10000
SELECT AVG(NVL(salary, 0))

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

95. 下列关于 GROUP BY 子句的说法中哪些是正确的？

GROUP BY 子句中列出的最后一列是最主要的分组。
GROUP BY 子句中列出的第一列是最主要的分组。
没有 ORDER BY 子句就不能使用 GROUP BY 子句。
GROUP BY 子句不确保输出的排序。

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

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

WHERE 子句在分组前限制行，而 HAVING 子句限制组。
WHERE 子句不能包含组函数，但 HAVING 子句可以包含。
WHERE 子句可以使用 AND 或 OR 运算符连接多个条件，但 HAVING 子句不能。
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(*);

它执行成功。
它抛出错误，因为 ORDER BY 子句无效。
它抛出错误，因为 GROUP BY 子句无效。
它抛出错误，因为 GROUP BY 和 ORDER BY 子句不能一起使用。

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