PostgreSQL 7.4.30 Documentation | ||||
---|---|---|---|---|

Prev | Fast Backward | Chapter 9. Functions and Operators | Fast Forward | Next |

This section describes the SQL-compliant subquery expressions available in PostgreSQL. All of the expression forms documented in this section return Boolean (true/false) results.

EXISTS (subquery)

The argument of `EXISTS` is an
arbitrary `SELECT` statement, or
*subquery*. The subquery is evaluated to
determine whether it returns any rows. If it returns at least
one row, the result of `EXISTS` is
"true"; if the subquery returns no
rows, the result of `EXISTS` is
"false".

The subquery can refer to variables from the surrounding query, which will act as constants during any one evaluation of the subquery.

The subquery will generally only be executed far enough to determine whether at least one row is returned, not all the way to completion. It is unwise to write a subquery that has any side effects (such as calling sequence functions); whether the side effects occur or not may be difficult to predict.

Since the result depends only on whether any rows are
returned, and not on the contents of those rows, the output
list of the subquery is normally uninteresting. A common coding
convention is to write all `EXISTS`
tests in the form `EXISTS(SELECT 1 WHERE
...)`. There are exceptions to this rule however, such as
subqueries that use `INTERSECT`.

This simple example is like an inner join on `col2`, but it produces at most one output row for
each `tab1` row, even if there are
multiple matching `tab2` rows:

SELECT col1 FROM tab1 WHERE EXISTS(SELECT 1 FROM tab2 WHERE col2 = tab1.col2);

expressionIN (subquery)

The right-hand side is a parenthesized subquery, which must
return exactly one column. The left-hand expression is
evaluated and compared to each row of the subquery result. The
result of `IN` is "true" if any equal subquery row is found. The
result is "false" if no equal row is
found (including the special case where the subquery returns no
rows).

Note that if the left-hand expression yields null, or if
there are no equal right-hand values and at least one
right-hand row yields null, the result of the `IN` construct will be null, not false. This is in
accordance with SQL's normal rules for Boolean combinations of
null values.

As with `EXISTS`, it's unwise to assume
that the subquery will be evaluated completely.

(expression[,expression...]) IN (subquery)

The right-hand side of this form of `IN` is a parenthesized subquery, which must return
exactly as many columns as there are expressions in the
left-hand list. The left-hand expressions are evaluated and
compared row-wise to each row of the subquery result. The
result of `IN` is "true" if any equal subquery row is found. The
result is "false" if no equal row is
found (including the special case where the subquery returns no
rows).

As usual, null values in the rows are combined per the
normal rules of SQL Boolean expressions. Two rows are
considered equal if all their corresponding members are
non-null and equal; the rows are unequal if any corresponding
members are non-null and unequal; otherwise the result of that
row comparison is unknown (null). If all the row results are
either unequal or null, with at least one null, then the result
of `IN` is null.

expressionNOT IN (subquery)

The right-hand side is a parenthesized subquery, which must
return exactly one column. The left-hand expression is
evaluated and compared to each row of the subquery result. The
result of `NOT IN` is "true" if only unequal subquery rows are found
(including the special case where the subquery returns no
rows). The result is "false" if any
equal row is found.

Note that if the left-hand expression yields null, or if
there are no equal right-hand values and at least one
right-hand row yields null, the result of the `NOT IN` construct will be null, not true. This is
in accordance with SQL's normal rules for Boolean combinations
of null values.

As with `EXISTS`, it's unwise to assume
that the subquery will be evaluated completely.

(expression[,expression...]) NOT IN (subquery)

The right-hand side of this form of `NOT
IN` is a parenthesized subquery, which must return exactly
as many columns as there are expressions in the left-hand list.
The left-hand expressions are evaluated and compared row-wise
to each row of the subquery result. The result of `NOT IN` is "true" if
only unequal subquery rows are found (including the special
case where the subquery returns no rows). The result is
"false" if any equal row is
found.

As usual, null values in the rows are combined per the
normal rules of SQL Boolean expressions. Two rows are
considered equal if all their corresponding members are
non-null and equal; the rows are unequal if any corresponding
members are non-null and unequal; otherwise the result of that
row comparison is unknown (null). If all the row results are
either unequal or null, with at least one null, then the result
of `NOT IN` is null.

expressionoperatorANY (subquery)expressionoperatorSOME (subquery)

The right-hand side is a parenthesized subquery, which must
return exactly one column. The left-hand expression is
evaluated and compared to each row of the subquery result using
the given `operator`, which must
yield a Boolean result. The result of `ANY` is "true" if any
true result is obtained. The result is "false" if no true result is found (including
the special case where the subquery returns no rows).

`SOME` is a synonym for `ANY`. `IN` is equivalent to
`= ANY`.

Note that if there are no successes and at least one
right-hand row yields null for the operator's result, the
result of the `ANY` construct will be
null, not false. This is in accordance with SQL's normal rules
for Boolean combinations of null values.

As with `EXISTS`, it's unwise to assume
that the subquery will be evaluated completely.

(expression[,expression...])operatorANY (subquery) (expression[,expression...])operatorSOME (subquery)

The right-hand side of this form of `ANY` is a parenthesized subquery, which must return
exactly as many columns as there are expressions in the
left-hand list. The left-hand expressions are evaluated and
compared row-wise to each row of the subquery result, using the
given `operator`. Presently, only
`=` and `<>` operators are allowed in row-wise
`ANY` constructs. The result of `ANY` is "true" if any
equal or unequal row is found, respectively. The result is
"false" if no such row is found
(including the special case where the subquery returns no
rows).

As usual, null values in the rows are combined per the
normal rules of SQL Boolean expressions. Two rows are
considered equal if all their corresponding members are
non-null and equal; the rows are unequal if any corresponding
members are non-null and unequal; otherwise the result of that
row comparison is unknown (null). If there is at least one null
row result, then the result of `ANY`
cannot be false; it will be true or null.

expressionoperatorALL (subquery)

The right-hand side is a parenthesized subquery, which must
return exactly one column. The left-hand expression is
evaluated and compared to each row of the subquery result using
the given `operator`, which must
yield a Boolean result. The result of `ALL` is "true" if all
rows yield true (including the special case where the subquery
returns no rows). The result is "false" if any false result is found.

`NOT IN` is equivalent to `<> ALL`.

Note that if there are no failures but at least one
right-hand row yields null for the operator's result, the
result of the `ALL` construct will be
null, not true. This is in accordance with SQL's normal rules
for Boolean combinations of null values.

As with `EXISTS`, it's unwise to assume
that the subquery will be evaluated completely.

(expression[,expression...])operatorALL (subquery)

The right-hand side of this form of `ALL` is a parenthesized subquery, which must return
exactly as many columns as there are expressions in the
left-hand list. The left-hand expressions are evaluated and
compared row-wise to each row of the subquery result, using the
given `operator`. Presently, only
`=` and `<>` operators are allowed in row-wise
`ALL` queries. The result of `ALL` is "true" if all
subquery rows are equal or unequal, respectively (including the
special case where the subquery returns no rows). The result is
"false" if any row is found to be
unequal or equal, respectively.

As usual, null values in the rows are combined per the
normal rules of SQL Boolean expressions. Two rows are
considered equal if all their corresponding members are
non-null and equal; the rows are unequal if any corresponding
members are non-null and unequal; otherwise the result of that
row comparison is unknown (null). If there is at least one null
row result, then the result of `ALL`
cannot be true; it will be false or null.

(expression[,expression...])operator(subquery)

The left-hand side is a list of scalar expressions. The
right-hand side is a parenthesized subquery, which must return
exactly as many columns as there are expressions on the
left-hand side. Furthermore, the subquery cannot return more
than one row. (If it returns zero rows, the result is taken to
be null.) The left-hand side is evaluated and compared row-wise
to the single subquery result row. Presently, only `=` and `<>`
operators are allowed in row-wise comparisons. The result is
"true" if the two rows are equal or
unequal, respectively.

As usual, null values in the rows are combined per the normal rules of SQL Boolean expressions. Two rows are considered equal if all their corresponding members are non-null and equal; the rows are unequal if any corresponding members are non-null and unequal; otherwise the result of the row comparison is unknown (null).

If you see anything in the documentation that is not correct, does not match your experience with the particular feature or requires further clarification, please use this form to report a documentation issue.