# SIMILAR TO

In SQL, when you need to perform pattern matching with more advanced capabilities than the **LIKE** operator, you can use the **SIMILAR TO** operator. The **SIMILAR TO** operator in PostgreSQL offers a way to search for patterns that follow regular expression rules.

Imagine you want to find customers in a database whose names contain a combination of specific characters. 

For example, you might remember that the customer names contain specific combinations of letters, but you don’t know the exact order. Instead of searching with multiple `LIKE` statements or using wildcard characters excessively, you can use the **SIMILAR TO** operator, which can provide much more powerful and flexible pattern matching.

## **How SIMILAR TO Works**

The **SIMILAR TO** operator allows you to match a pattern to a string using regular expression syntax, similar to **POSIX regular expressions**. The syntax for **SIMILAR TO** is

```sql
value SIMILAR TO pattern    
```

Where:

* `value` is the string or column to be matched.
* `pattern` is the regular expression pattern that you want to compare against.

The **SIMILAR TO** operator is used to check if the value matches the given regular expression pattern. If it does, the operator returns `TRUE`; otherwise, it returns `FALSE`.

## **Basic Syntax and Examples**

Let’s look at some basic examples of using the **SIMILAR TO** operator in PostgreSQL.

### **1) Basic SIMILAR TO Example**

Let’s say you want to find customers whose first names start with either "Jen", "Jon", or "Jan". Instead of writing multiple `LIKE` queries, you can use **SIMILAR TO** with a single pattern.

```sql
SELECT first_name, last_name
FROM customer
WHERE first_name SIMILAR TO 'J(e|o|a)n%';
```

In this example:

* The pattern `J(e|o|a)n%` matches any string that starts with "J" followed by either "e", "o", or "a", and then any sequence of characters (`%`).
* The `|` character is used to specify alternatives within the regular expression.

### **2) Using SIMILAR TO with Multiple Patterns**

If you want to match several different patterns, **SIMILAR TO** lets you combine them into one regular expression. For example, to find customer names that start with "A" or "B" and have two additional characters, you could use

```sql
SELECT first_name, last_name
FROM customer
WHERE first_name SIMILAR TO '[AB]__';
```

In this query:

* `[AB]` means the first character must be "A" or "B".
* `__` means there should be exactly two characters following it.

### **3) SIMILAR TO with Wildcards**

You can also use wildcards in the **SIMILAR TO** pattern. For instance, if you want to find any first name starting with "S" and followed by at least one character.

```sql
SELECT first_name, last_name
FROM customer
WHERE first_name SIMILAR TO 'S%';
```

Here, `%` is the wildcard matching any sequence of characters (just like in **LIKE**).


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://courses.parottasalna.com/database-engineering/filtering-data/similar-to.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.