> This page location: Filtering Data > WHERE
> Full Neon documentation index: https://neon.com/docs/llms.txt

# PostgreSQL WHERE

**Info:** The WHERE clause works the same across any standard PostgreSQL deployment, so the syntax and examples here apply wherever you run Postgres. If you're an enterprise looking for managed cloud Postgres built for the AI era, [Lakebase](https://www.databricks.com/product/lakebase) delivers performance, security, and native integration with the Lakehouse. If you're a developer or startup who needs to ship and scale fast, [Neon](https://neon.com) gives you the most productive Postgres platform to build on.

**Summary**: in this tutorial, you will learn how to use PostgreSQL `WHERE` clause to filter rows returned by a `SELECT` statement.

## Introduction to PostgreSQL WHERE clause

The [`SELECT`](https://neon.com/postgresql/tutorial/postgresql-select) statement returns all rows from one or more columns in a table. To retrieve rows that satisfy a specified condition, you use a `WHERE` clause.

The syntax of the PostgreSQL `WHERE` clause is as follows:

```sql
SELECT
  select_list
FROM
  table_name
WHERE
  condition
ORDER BY
  sort_expression;
```

In this syntax, you place the `WHERE` clause right after the `FROM` clause of the `SELECT` statement.

The `WHERE` clause uses the `condition` to filter the rows returned from the `SELECT` clause.

The `condition` is a boolean expression that evaluates to true, false, or unknown.

The query returns only rows that satisfy the `condition` in the `WHERE` clause. In other words, the query will include only rows that cause the `condition` to evaluate to true in the result set.

PostgreSQL evaluates the `WHERE` clause after the `FROM` clause but before the `SELECT` and `ORDER BY` clause:

![](https://neon.com/postgresqltutorial/PostgreSQL-WHERE.png)If you use [column aliases](https://neon.com/postgresql/tutorial/postgresql-column-alias) in the `SELECT` clause, you cannot use them in the `WHERE` clause.

Besides the `SELECT` statement, you can use the `WHERE` clause in the [`UPDATE`](https://neon.com/postgresql/tutorial/postgresql-update) and [`DELETE`](https://neon.com/postgresql/tutorial/postgresql-delete) statement to specify rows to update and delete.

To form the condition in the `WHERE` clause, you use comparison and logical operators:

| Operator                                                           | Description                                         |
| ------------------------------------------------------------------ | --------------------------------------------------- |
| =                                                                  | Equal                                               |
| >                                                                  | Greater than                                        |
| \<                                                                 | Less than                                           |
| >=                                                                 | Greater than or equal                               |
| \<=                                                                | Less than or equal                                  |
| \<> or !=                                                          | Not equal                                           |
| AND                                                                | Logical operator AND                                |
| OR                                                                 | Logical operator OR                                 |
| [IN](https://neon.com/postgresql/tutorial/postgresql-in)           | Return true if a value matches any value in a list  |
| [BETWEEN](https://neon.com/postgresql/tutorial/postgresql-between) | Return true if a value is between a range of values |
| [LIKE](https://neon.com/postgresql/tutorial/postgresql-like)       | Return true if a value matches a pattern            |
| [IS NULL](https://neon.com/postgresql/tutorial/postgresql-is-null) | Return true if a value is NULL                      |
| NOT                                                                | Negate the result of other operators                |

## PostgreSQL WHERE clause examples

Let's practice with some examples of using the `WHERE` clause.

We will use the `customer` table from the [sample database](../postgresql-getting-started/postgresql-sample-database) for demonstration.

![customer table](https://neon.com/postgresqltutorial/customer.png)

### 1)  Using WHERE clause with the equal (=) operator example

The following statement uses the `WHERE` clause to find customers whose first name is `Jamie`:

```sql
SELECT
  last_name,
  first_name
FROM
  customer
WHERE
  first_name = 'Jamie';
```

Output:

```text
 last_name | first_name
-----------+------------
 Rice      | Jamie
 Waugh     | Jamie
(2 rows)
```

### 2) Using the WHERE clause with the AND operator example

The following example uses a `WHERE` clause with the `AND` logical operator to find customers whose first name and last names are `Jamie` and `Rice`:

```sql
SELECT
  last_name,
  first_name
FROM
  customer
WHERE
  first_name = 'Jamie'
  AND last_name = 'Rice';
```

Output:

```text
 last_name | first_name
-----------+------------
 Rice      | Jamie
(1 row)
```

### 3) Using the WHERE clause with the OR operator example

The following example uses a `WHERE` clause with an `OR` operator to find the customers whose last name is `Rodriguez` or first name is `Adam`:

```sql
SELECT
  first_name,
  last_name
FROM
  customer
WHERE
  last_name = 'Rodriguez'
  OR first_name = 'Adam';
```

Output:

```text
 first_name | last_name
------------+-----------
 Laura      | Rodriguez
 Adam       | Gooch
(2 rows)
```

### 4) Using the WHERE clause with the IN operator example

If you want to find a value in a list of values, you can use the [`IN`](https://neon.com/postgresql/tutorial/postgresql-in) operator.

The following example uses the `WHERE` clause with the `IN` operator to find the customers with first names in the list Ann, Anne, and Annie:

```sql
SELECT
  first_name,
  last_name
FROM
  customer
WHERE
  first_name IN ('Ann', 'Anne', 'Annie');
```

Output:

```text
 first_name | last_name
------------+-----------
 Ann        | Evans
 Anne       | Powell
 Annie      | Russell
(3 rows)
```

### 5) Using the WHERE clause with the LIKE operator example

To find a string that matches a specified pattern, you use the [`LIKE`](https://neon.com/postgresql/tutorial/postgresql-like) operator.

The following example uses the `LIKE` operator in the `WHERE` clause to find customers whose first names start with the word `Ann`:

```sql
SELECT
  first_name,
  last_name
FROM
  customer
WHERE
  first_name LIKE 'Ann%';
```

Output:

```text
 first_name | last_name
------------+-----------
 Anna       | Hill
 Ann        | Evans
 Anne       | Powell
 Annie      | Russell
 Annette    | Olson
(5 rows)
```

The `%` is called a wildcard that matches any string. The `'Ann%'` pattern matches any strings that start with `'Ann'`.

### 6) Using the WHERE clause with the BETWEEN operator example

The following example finds customers whose first names start with the letter `A` and contains 3 to 5 characters by using the [`BETWEEN`](https://neon.com/postgresql/tutorial/postgresql-between) operator.

The `BETWEEN` operator returns true if a value is in a range of values.

```sql
SELECT
  first_name,
  LENGTH(first_name) name_length
FROM
  customer
WHERE
  first_name LIKE 'A%'
  AND LENGTH(first_name) BETWEEN 3
  AND 5
ORDER BY
  name_length;
```

Output:

```
first_name | name_length
------------+-------------
 Amy        |           3
 Ann        |           3
 Ana        |           3
 Andy       |           4
 Anna       |           4
 Anne       |           4
 Alma       |           4
 Adam       |           4
 Alan       |           4
 Alex       |           4
 Angel      |           5
...
```

In this example, we use the [`LENGTH()`](../postgresql-string-functions/postgresql-length-function) function to get the number of characters of an input string.

### 7) Using the WHERE clause with the not equal operator (<>) example

This example finds customers whose first names start with `Bra` and last names are not `Motley`:

```sql
SELECT
  first_name,
  last_name
FROM
  customer
WHERE
  first_name LIKE 'Bra%'
  AND last_name <> 'Motley';
```

Output:

```
 first_name | last_name
------------+-----------
 Brandy     | Graves
 Brandon    | Huey
 Brad       | Mccurdy
(3 rows)
```

Note that you can use the `!=` operator and `<>` operator interchangeably because they are equivalent.

## Summary

- Use a `WHERE` clause in the `SELECT` statement to filter rows of a query based on one or more conditions.

---

## Related docs (Filtering Data)

- [AND Operator](https://neon.com/postgresql/tutorial/and)
- [OR Operator](https://neon.com/postgresql/tutorial/or)
- [LIMIT](https://neon.com/postgresql/tutorial/limit)
- [FETCH](https://neon.com/postgresql/tutorial/fetch)
- [IN](https://neon.com/postgresql/tutorial/in)
- [BETWEEN](https://neon.com/postgresql/tutorial/between)
- [LIKE](https://neon.com/postgresql/tutorial/like)
- [IS NULL](https://neon.com/postgresql/tutorial/is-null)