25th June 2020: PostgreSQL 13 Beta 2 Released!

This documentation is for an unsupported version of PostgreSQL.

You may want to view the same page for the current version, or one of the supported versions listed above instead.

You may want to view the same page for the current version, or one of the supported versions listed above instead.

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 (value[, ...])

The right-hand side of this form of `IN` is a parenthesized list of scalar expressions.
The result is "true" if the
left-hand expression's result is equal to any of the right-hand
expressions. This is a shorthand notation for

expression=value1ORexpression=value2OR ...

Note that if the left-hand expression yields null, or if
there are no equal right-hand values and at least one
right-hand expression 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.

Note:This form ofINis not truly a subquery expression, but it seems best to document it in the same place as subqueryIN.

expressionIN (subquery)

The right-hand side of this form of `IN` 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 expressions or subquery 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 (value[, ...])

The right-hand side of this form of `NOT
IN` is a parenthesized list of scalar expressions. The
result is "true" if the left-hand
expression's result is unequal to all of the right-hand
expressions. This is a shorthand notation for

expression<>value1ANDexpression<>value2AND ...

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

Tip:x NOT IN yis equivalent toNOT (x IN y)in all cases. However, null values are much more likely to trip up the novice when working withNOT INthan when working withIN. It's best to express your condition positively if possible.

expressionNOT IN (subquery)

The right-hand side of this form of `NOT
IN` 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 expressions or subquery 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 of this form of `ANY` 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` queries. 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 expressions or subquery 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 of this form of `ALL` 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 expressions or subquery 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) (expression[,expression...])operator(expression[,expression...])

The left-hand side is a list of scalar expressions. The
right-hand side can be either a list of scalar expressions of
the same length, or 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, or to the right-hand
expression list. 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 expressions or subquery 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).