SUBQUERIES

SUBQUERY

• A subquery is a query within a query.

• Subqueries enable you to write queries that
select data rows for criteria that are actually
developed while the query is executing at
run time.

Bordoloi and Bock

 Example
SELECT emp_last_name "Last Name",
emp_first_name "First Name",
emp_salary "Salary"
FROM employee
WHERE emp_salary =
(SELECT MIN(emp_salary)
FROM employee);
Last Name First Name Salary
--------------- --------------- --------
Markis Marcia $25,000
Amin Hyder $25,000
Prescott Sherri $25,000
Bordoloi and Bock
 SUBQUERY TYPES

• There are three basic types of subqueries. We

will study each of these in the remainder of this
chapter.
1. Subqueries that operate on lists by use of the IN
operator or with a comparison operator modified
by the ANY or ALL optional keywords. These
subqueries can return a group of values, but the
values must be from a single column of a table.

Bordoloi and Bock

 SUBQUERY TYPES

2. Subqueries that use an unmodified comparison

operator (=, <, >, <>) – these subqueries must
return only a single, scalar value.
3. Subqueries that use the EXISTS operator to test
the existence of data rows satisfying specified
criteria.

Bordoloi and Bock

 SUBQUERY – General Rules
• A subquery SELECT statement is very similar to
the SELECT statement used to begin a regular or
outer query. The complete syntax of a subquery
is shown below.

( SELECT [DISTINCT] subquery_select_argument

FROM {table_name | view_name}
{table_name | view_name} ...
[WHERE search_conditions]
[GROUP BY aggregate_expression [, aggregate_expression] ...]
[HAVING search_conditions] )

Bordoloi and Bock

 Rules Cont’d

• The SELECT clause of a subquery must

contain only one expression, only one
aggregate function, or only one column
name.
• The value(s) returned by a subquery must
be join-compatible with the WHERE
clause of the outer query.

Bordoloi and Bock

 Example
SELECT emp_last_name "Last Name",
emp_first_name "First Name"
FROM employee
WHERE emp_ssn IN
(SELECT dep_emp_ssn
FROM dependent);

Last Name First Name

------------- ---------------
Bock Douglas
Zhu Waiman
Joyner Suzanne
Bordoloi and Bock
 Rules Cont’d

• In addition to concerns about the domain of

values returned from a subquery, the data type of
the returned column value(s) must be join-
compatible.
• Join-compatible data types are data types that
the Oracle Server will convert automatically
when matching data in criteria conditions.

Bordoloi and Bock

 Rules Cont’d
• The Oracle Server will automatically
convert among any of the following ANSI
numeric data types when making
comparisons of numeric values because
they all map into the Oracle NUMBER
data type.
• int (integer)
• smallint (small integer)
• decimal
• float
Bordoloi and Bock
 Rules Cont’d

• Oracle does not make comparisons based

on column names.
• Columns from two tables that are being
compared may have different names as
long as they have a shared domain and the
same data type or convertible data types.

Bordoloi and Bock

 Rules Cont’d

There are additional restrictions for subqueries.

• The DISTINCT keyword cannot be used in
subqueries that include a GROUP BY clause.
• Subqueries cannot manipulate their results
internally. This means that a subquery cannot
include the ORDER BY clause, the COMPUTE
clause, or the INTO keyword.

Bordoloi and Bock

 SUBQUERIES AND THE IN Operator

• Subqueries that are introduced with the

keyword IN take the general form:
– WHERE expression [NOT] IN (subquery)

• The only difference in the use of the IN

operator with subqueries is that the list does
not consist of hard-coded values.

Bordoloi and Bock

 Example
SELECT emp_last_name "Last Name",
emp_first_name "First Name"
FROM employee
WHERE emp_ssn IN
(SELECT dep_emp_ssn
FROM dependent
WHERE dep_gender = 'M');

Last Name First Name

--------------- ---------------
Bock Douglas
Zhu Waiman
Joyner Suzanne
Bordoloi and Bock
 SUBQUERIES AND THE IN Operator

• Conceptually, this statement is evaluated in two

steps.
• First, the inner query returns the identification
numbers of those employees that have male
dependents.
SELECT dep_emp_ssn
FROM dependent
WHERE dep_gender = 'M';
DEP_EMP_S
---------
999444444
999555555
999111111

Bordoloi and Bock

 SUBQUERIES AND THE IN
Operator
• Next, these social security number values are
substituted into the outer query as the listing that
is the object of the IN operator. So, from a
conceptual perspective, the outer query now
looks like the following.
SELECT emp_last_name "Last Name",
emp_first_name "First Name"
FROM employee
WHERE emp_ssn IN (999444444, 999555555, 999111111);
Last Name First Name
--------------- ---------------
Joyner Suzanne
Zhu Waiman
Bock Douglas
Bordoloi and Bock
 The NOT IN Operator
• Like the IN operator, the NOT IN operator can take the
result of a subquery as the operator object.

SELECT emp_last_name "Last Name", emp_first_name "First

Name"
FROM employee
WHERE emp_ssn NOT IN
(SELECT dep_emp_ssn
FROM dependent);
Last Name First Name
--------------- ---------------
Bordoloi Bijoy
Markis Marcia
Amin Hyder
more rows are displayed . . .
Bordoloi and Bock
 The NOT IN Operator
• The subquery shown above produces an
intermediate result table containing the social
security numbers of employees who have
dependents in the dependent table.
• Conceptually, the outer query compares each row
of the employee table against the result table. If
the employee social security number is NOT
found in the result table produced by the inner
query, then it is included in the final result table.

Bordoloi and Bock

 MULTIPLE LEVELS OF NESTING
• Subqueries may themselves contain subqueries.
• When the WHERE clause of a subquery has as its
object another subquery, these are termed nested
subqueries.
• Oracle places no practical limit on the number of
queries that can be nested in a WHERE clause.
• Consider the problem of producing a listing of
employees that worked more than 10 hours on the
project named Order Entry.

Bordoloi and Bock

Example

SELECT emp_last_name "Last Name",

emp_first_name "First Name"
FROM employee
WHERE emp_ssn IN
(SELECT work_emp_ssn
FROM assignment
WHERE work_hours > 10 AND work_pro_number IN
(SELECT pro_number
FROM project
WHERE pro_name = 'Order Entry') );
Last Name First Name
--------------- ---------------
Bock Douglas
Prescott Sherri

Bordoloi and Bock

Understanding SUBQUERIES
• In order to understand how this query executes,
we begin our examination with the lowest
subquery.
• We will execute it independently of the outer
queries.
SELECT pro_number
FROM project
WHERE pro_name = 'Order Entry';
PRO_NUMBER
----------
1

Bordoloi and Bock

Understanding SUBQUERIES
• Now, let's substitute the project number into the
IN operator list for the intermediate subquery and
execute it.
• The intermediate result table lists two employee
social security numbers for employees that
worked more than 10 hours on project #1.
SELECT work_emp_ssn
FROM assignment
WHERE work_hours > 10 AND work_pro_number IN (1);
WORK_EMP_SSN
-----------------------
999111111
999888888

Bordoloi and Bock

Understanding SUBQUERIES
• Finally, we will substitute these two social security
numbers into the IN operator listing for the outer
query in place of the subquery.
SELECT emp_last_name "Last Name",
emp_first_name "First Name"
FROM employee
WHERE emp_ssn IN (999111111, 999888888);
Last Name First Name
--------------- ---------------
Bock Douglas
Prescott Sherri

Bordoloi and Bock

 SUBQUERIES AND COMPARISON
OPERATORS
• The general form of the WHERE clause with a
comparison operator is similar to that used thus far
in the text.
• Note that the subquery is again enclosed by
parentheses.

WHERE <expression> <comparison_operator> (subquery)

Bordoloi and Bock

 SUBQUERIES AND COMPARISON
OPERATORS
• The most important point to remember when using
a subquery with a comparison operator is that the
subquery can only return a single or scalar value.
• This is also termed a scalar subquery because a
single column of a single row is returned by the
subquery.
• If a subquery returns more than one value, the
Oracle Server will generate the “ ORA-01427:
single-row subquery returns more than one row ”
error message, and the query will fail to execute.

Bordoloi and Bock

 SUBQUERIES AND COMPARISON
OPERATORS
• Let's examine a subquery that will not execute because it
violates the "single value" rule.
• The query shown below returns multiple values for the
emp_salary column.

SELECT emp_salary
FROM employee
WHERE emp_salary > 40000;
EMP_SALARY
-------------------
55000
43000
43000

Bordoloi and Bock

 SUBQUERIES AND COMPARISON
OPERATORS
• If we substitute this query as a subquery in another
SELECT statement, then that SELECT statement will fail.
• This is demonstrated in the next SELECT statement. Here
the SQL code will fail because the subquery uses the
greater than (>) comparison operator and the subquery
returns multiple values.

SELECT emp_ssn
FROM employee
WHERE emp_salary >
(SELECT emp_salary
FROM employee
WHERE emp_salary > 40000);
ERROR at line 4:
ORA-01427: single-row subquery returns more than one row

Bordoloi and Bock

 Aggregate Functions and Comparison
Operators
• The aggregate functions (AVG, SUM, MAX,
MIN, and COUNT) always return a scalar result
table.
• Thus, a subquery with an aggregate function as the
object of a comparison operator will always
execute provided you have formulated the query
properly.

Bordoloi and Bock

 Aggregate Functions and Comparison
Operators
SELECT emp_last_name "Last Name",
emp_first_name "First Name",
emp_salary "Salary"
FROM employee
WHERE emp_salary >
(SELECT AVG(emp_salary)
FROM employee);

Last Name First Name Salary

--------------- --------------- ----------
Bordoloi Bijoy $55,000
Joyner Suzanne $43,000
Zhu Waiman $43,000
Joshi Dinesh $38,000

Bordoloi and Bock

 Comparison Operators Modified with the
ALL or ANY Keywords
• The ALL and ANY keywords can modify a
comparison operator to allow an outer query to
accept multiple values from a subquery.
• The general form of the WHERE clause for this
type of query is shown here.
WHERE <expression> <comparison_operator> [ALL |
ANY] (subquery)

• Subqueries that use these keywords may also

include GROUP BY and HAVING clauses.

Bordoloi and Bock

 The ALL Keyword
• The ALL keyword modifies the greater than
comparison operator to mean greater than all values.

SELECT emp_last_name "Last Name",

emp_first_name "First Name",
emp_salary "Salary"
FROM employee
WHERE emp_salary > ALL
(SELECT emp_salary
FROM employee
WHERE emp_dpt_number = 7);
Last Name First Name Salary
--------------- --------------- --------
Bordoloi Bijoy $55,000

Bordoloi and Bock

 The ANY Keyword

• The ANY keyword is not as restrictive as the

ALL keyword.
• When used with the greater than comparison
operator, "> ANY" means greater than some
value.

Bordoloi and Bock

 Example
SELECT emp_last_name "Last Name",
emp_first_name "First Name",
emp_salary "Salary"
FROM employee
WHERE emp_salary > ANY
(SELECT emp_salary
FROM employee
WHERE emp_salary > 30000);

Last Name First Name Salary

--------------- --------------- --------
Bordoloi Bijoy $55,000
Joyner Suzanne $43,000
Zhu Waiman $43,000

Bordoloi and Bock

 An "= ANY" (Equal Any) Example
• The "= ANY" operator is exactly equivalent to the IN operator.
• For example, to find the names of employees that have male
dependents, you can use either IN or "= ANY" – both of the
queries shown below will produce an identical result table.
SELECT emp_last_name "Last Name", emp_first_name "First Name"
FROM employee
WHERE emp_ssn IN
(SELECT dep_emp_ssn
FROM dependent
WHERE dep_gender = 'M');

SELECT emp_last_name "Last Name", emp_first_name "First Name"

FROM employee
WHERE emp_ssn = ANY
(SELECT dep_emp_ssn
FROM dependent
WHERE dep_gender = 'M');

Bordoloi and Bock

 An "= ANY" (Equal Any) Example

• OUTPUT

Last Name First Name

--------------- ---------------
Bock Douglas
Zhu Waiman
Joyner Suzanne

Bordoloi and Bock

 A "!= ANY" (Not Equal Any) Example
• The "= ANY" is identical to the IN operator.
• However, the "!= ANY" (not equal any) is not equivalent
to the NOT IN operator.
• If a subquery of employee salaries produces an
intermediate result table with the salaries $38,000,
$43,000, and $55,000, then the WHERE clause shown here
means "NOT $38,000" AND "NOT $43,000" AND "NOT
$55,000".
WHERE NOT IN (38000, 43000, 55000);
• However, the "!= ANY" comparison operator and keyword
combination shown in this next WHERE clause means
"NOT $38,000" OR "NOT $43,000" OR "NOT $55,000".

Bordoloi and Bock

 CORRELATED SUBQUERIES

• A correlated subquery is one where the inner

query depends on values provided by the outer
query.
• This means the inner query is executed repeatedly,
once for each row that might be selected by the
outer query.

Bordoloi and Bock

 CORRELATED SUBQUERIES
SELECT emp_last_name "Last Name",
emp_first_name "First Name",
emp_dpt_number "Dept",
emp_salary "Salary"
FROM employee e1 WHERE emp_salary =
(SELECT MAX(emp_salary)
FROM employee
WHERE emp_dpt_number =
e1.emp_dpt_number);

Bordoloi and Bock

 CORRELATED SUBQUERIES
• Output

Last Name FirstName Dept Salary

---------- ---------- ----- --------
Bordoloi Bijoy 1 $55,000
Joyner Suzanne 3 $43,000
Zhu Waiman 7 $43,000

Bordoloi and Bock

 CORRELATED SUBQUERIES

• The subquery in this SELECT statement

cannot be resolved independently of the
main query.
• Notice that the outer query specifies that
rows are selected from the employee table
with an alias name of e1.
• The inner query compares the employee
department number column
(emp_dpt_number) of the employee table to
the same column for the alias table name e1.
Bordoloi and Bock
 CORRELATED SUBQUERIES

• The value of e1.emp_dpt_number is treated like a

variable – it changes as the Oracle server examines
each row of the employee table.
• The subquery's results are correlated with each
individual row of the main query – thus, the term
correlated subquery.

Bordoloi and Bock

 Subqueries and the EXISTS operator

• When a subquery uses the EXISTS operator,

the subquery functions as an existence test.
• The WHERE clause of the outer query tests
for the existence of rows returned by the
inner query.
• The subquery does not actually produce any
data; rather, it returns a value of TRUE or
FALSE.

Bordoloi and Bock

 Subqueries and the EXISTS operator
• The general format of a subquery WHERE
clause with an EXISTS operator is shown
here.
• Note that the NOT operator can also be used
to negate the result of the EXISTS operator.

WHERE [NOT] EXISTS (subquery)

Bordoloi and Bock

 Example
SELECT emp_last_name "Last Name",
emp_first_name "First Name"
FROM employee
WHERE EXISTS
(SELECT *
FROM dependent
WHERE emp_ssn = dep_emp_ssn);
Last Name First Name
---------- ---------------
Joyner Suzanne
Zhu Waiman
Bock Douglas
Bordoloi and Bock
 Subqueries and the EXISTS operator
• Subqueries using an EXISTS operator are a bit
different from other subqueries, in the following
ways:
1. The keyword EXISTS is not preceded by a
column name, constant, or other expression.
2. The SELECT clause list of a subquery that uses
an EXISTS operator almost always consists of
an asterisk (*). This is because there is no real
point in listing column names since you are
simply testing for the existence of rows that
meet the conditions specified in the subquery.

Bordoloi and Bock

 Subqueries and the EXISTS operator

3. The subquery evaluates to TRUE or FALSE

rather than returning any data.
4. A subquery that uses an EXISTS operator will
always be a correlated subquery.

Bordoloi and Bock

 Subqueries and the EXISTS operator
• The EXISTS operator is very important,
because there is often no alternative to its use.
• All queries that use the IN operator or a
modified comparison operator (=, <, >, etc.
modified by ANY or ALL) can be expressed
with the EXISTS operator.
• However, some queries formulated with
EXISTS cannot be expressed in any other
way!

Bordoloi and Bock

 Subqueries and the EXISTS operator
SELECT emp_last_name SELECT emp_last_name
FROM employee FROM employee
WHERE emp_ssn = ANY WHERE EXISTS
(SELECT dep_emp_ssn (SELECT *
FROM dependent); FROM dependent
WHERE emp_ssn =
dep_emp_ssn);

EMP_LAST_NAME EMP_LAST_NAME
------------- ----------------
Bock Bock
Zhu Zhu
Joyner Joyner

Bordoloi and Bock

 Subqueries and the EXISTS operator

• The NOT EXISTS operator is the

mirror-image of the EXISTS operator.
• A query that uses NOT EXISTS in the
WHERE clause is satisfied if the
subquery returns no rows.

Bordoloi and Bock

 Subqueries and the ORDER BY Clause
• The SELECT statement shown below adds the
ORDER BY clause to specify sorting by first name
within last name.
• Note that the ORDER BY clause is placed after the
WHERE clause, and that this includes the subquery
as part of the WHERE clause.
SELECT emp_last_name "Last Name",
emp_first_name "First Name"
FROM employee
WHERE EXISTS
(SELECT *
FROM dependent
WHERE emp_ssn = dep_emp_ssn)
ORDER BY emp_last_name, emp_first_name;
Bordoloi and Bock
 Subqueries and the ORDER BY Clause

Output:

Last Name First Name

---------- ---------------
Bock Douglas
Joyner Suzanne
Zhu Waiman

Bordoloi and Bock

 END
Bordoloi and Bock