使用组函数问题
使用组函数问题
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 语句的哪一行用于限制查询处理的记录数？
- 1
- 3
- 4
- 5
答案：B. WHERE 子句用于在组形成之前限制行。
78. SELECT 语句的哪一行用于限制查询结果中显示的组？
- 1
- 3
- 4
- 5
答案：D. HAVING 用于限制分组处理结束后的分组结果。
79. SELECT 语句的哪一行用于对存储在数据库中的数据进行分组？
- 1
- 3
- 4
- 5
答案：C. GROUP BY 子句使用 group by 列对表中的数据进行分组。
80. 必须包含哪个子句才能使查询成功执行？
- 1
- 3
- 4
- 5
答案：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 子句可以使用分组函数进行排序。
