SQL LIKE Pattern Matching Tutorial

Suppose you have an employees table and would like to find all names that start with ‘A’:

You could spend time looking through the table manually. But why would you do that when you have the LIKE operator?

SELECT DISTINCT
	first_name
FROM employees
WHERE first_name LIKE 'A%'

The magic here is in the clause `WHERE first_name LIKE ‘A%’`, which means “find all first_name starting with "A" and ending with any number of characters.” The `A%` here is known as a pattern for matching. 

The `%` is not the only wildcard you can use in conjunction with the LIKE operator. You could use the underscore sign `_` , too:

• `%` matches any number of characters.
• `_` matches any single character.

The syntax is easy to remember. It is simply:

column_name LIKE pattern

You can use LIKE to achieve a variety of pattern-matching. Here’s how:

Beginner SQL LIKE Examples

Below, we’ve outlined some practical examples of how you can use the LIKE statement and the results from our sample data set. 

1. Use LIKE for exact string match

If you’d like to perform an exact string match, use LIKE without ‘%’ or ‘_’

SELECT
    first_name, last_name
FROM employees
WHERE first_name LIKE 'Barry' -- the same as WHERE first_name = ‘Barry’

2. Use ‘%’ to match any number of characters 

‘%’ can be used to match any (even zero) number of characters – a number, an alphabet, or a symbol.

Suppose you want to find all employees whose name starts with ‘Adam’; you can use the pattern ‘Adam%’

SELECT DISTINCT
    first_name
FROM employees
WHERE first_name LIKE 'Adam%'

To find names that end with "z" try the pattern ‘%z’. You can also use multiple ‘%’ in one pattern. For example, if you want to find names that contain "z", use ‘%z%’.

3. Use ‘_’ to match one (and only one) character

Like the game Hangman, the underscore sign _ can only fit one character.

How many ways are there to spell Le_n? The pattern would match anything from "Lexn", "LeAn", "Le3n", or "Le-n".

SELECT DISTINCT
    first_name
FROM employees
WHERE first_name LIKE 'Le_n'

What are the different names with only three characters? We can find out using three consecutive underscores ___ as the pattern.

SELECT DISTINCT
    first_name
FROM employees
WHERE first_name LIKE '___'

4. Use both ‘%’ and ‘_’ to match any pattern

Of course, you can use both ‘%’ and ‘_’ to create interesting patterns. 

SELECT DISTINCT
    first_name
FROM employees
WHERE first_name LIKE '%ann_'

The pattern ‘%ann_’ matches a string that starts with any number of characters and ends with "ann" and one other character.

5. Use NOT to find strings that do not match a pattern

What if you want to find all rows that do not match a specific criterion? You can use the NOT LIKE operator. For example, to find all titles except for "Staff", we can use the syntax

`WHERE title NOT LIKE ‘Staff’`

This is exactly equivalent to the syntax

`WHERE title != ‘Staff’`

SELECT DISTINCT
    title
FROM titles
WHERE title NOT LIKE 'Staff'

Of course, you can use NOT LIKE with any of the patterns we described.

SELECT DISTINCT
    title
FROM titles 
WHERE title NOT LIKE '%engineer'

6. Use LOWER (or UPPER) with LIKE for case-insensitive pattern matching

You can use the following syntax if you need to perform pattern matching but aren’t sure if the string is stored in lowercase, uppercase, or mixed case.

`LOWER(column_name) LIKE pattern`

The function LOWER() returns all strings in lowercase, regardless of whether they are stored as upper-, lower-, or mixed case. 

When using the syntax, make sure you spell the pattern in all lowercase! Else, you might not get any matches.

You could replace LOWER with UPPER in the syntax above, too. Be sure to spell out the pattern in capital letters.

`UPPER(column_name) LIKE PATTERN`

For example, to find out if an employee’s name is "Joanne", "JoAnne", "Joanna", or "JoAnna", try either of the following:

SELECT DISTINCT
    first_name
FROM employees
WHERE lower(first_name) LIKE 'joann_'

SELECT DISTINCT
    first_name
FROM employees
WHERE UPPER(first_name) LIKE 'JOANN_'

7. SQL LIKE with multiple values using OR/AND

You can combine multiple conditions using the LIKE syntax, too. 

For example, use the OR condition to find results that satisfy at least one out of multiple LIKE patterns.

SELECT DISTINCT
    first_name
FROM employees
WHERE
first_name LIKE 'Ad_l' OR
first_name LIKE 'Ad_m'

On the other hand, to find a string that matches multiple LIKE conditions, use the AND keyword.

SELECT DISTINCT
    first_name
FROM employees
WHERE
first_name LIKE '%am%' AND
first_name LIKE '%me%'

The LIKE syntax can be applied to multiple columns as long as their variable type is a variable-length character (varchar). Knowing that we can find the names of employees whose initials are "Z. Z."

SELECT DISTINCT
    first_name, last_name
FROM employees
WHERE
first_name LIKE 'Z%' AND
last_name LIKE 'Z%'

8. Use LIKE in the SELECT CASE WHEN clause 

Thus far, we have focused on using LIKE as a condition for selecting records in the WHERE clause. We also use LIKE in the SELECT clause. For example, can we find out how many employees named "Adam" are in our database?

SELECT
    COUNT(CASE WHEN first_name LIKE 'Adam' THEN 1 END) num_employees_adam
FROM employees

On the other hand, how many employees have the initials "A.Z."?

SELECT
    COUNT(CASE WHEN first_name LIKE 'A%' AND last_name LIKE 'Z%' THEN 1 END) num_employees
FROM employees

Common patterns used in SQL LIKE

Here's a summary of the patterns we discussed for quick reference:

Intermediate Examples of SQL LIKE

The LIKE function is largely similar across different flavors of SQL (e.g. PostgreSQL, MySQL, Redshift, etc.). However some have additional variations of the LIKE function that are worth mentioning. 

1. The ILIKE operator

Available in Redshift and PostgreSQL, ILIKE is the case-insensitive version of LIKE. As such, all of the following are equivalent.

SELECT
  datacamp ILIKE ‘datacamp’, -- returns TRUE
  DATACAMP ILIKE ‘datacamp’, -- returns TRUE
  Datacamp ILIKE ‘datacamp’, -- returns TRUE
  datacamp ILIKE ‘DataCamp’, -- returns TRUE

2. Using square brackets [] and [^] as wildcard characters

Users of T-SQL or SQL Server have additional wildcard characters for more complex pattern matching.

The square bracket syntax [] matches any specific character within the range or set. For example, the following will all return TRUE.

SELECT
  ‘Carson’ LIKE ‘[C-K]arson’, -- returns TRUE because C is in the range C-K
  ‘Karson’ LIKE ‘[C-K]arson’, -- returns TRUE because K is in range
  ‘Larson’ LIKE ‘[CKL]arson’, -- returns TRUE because L is in the set [CKL]
  ‘Parson’ LIKE ‘[C-K]arson’ -- returns FALSE because P is out of range

The caret-in-square-bracket [^] wildcard matches any single character that is not within the specified range or set. Can you see why the following results are such? 

SELECT
  ‘Carson’ LIKE ‘[^C-K]arson’ -- returns FALSE 
  ‘Parson’ LIKE ‘[^C-K]arson’ -- returns TRUE

Here, since "C" is within the range of [C-K], the pattern ‘C’ will not match [^C-K]. Thus, "Carson" will not match [^C-K]arson, but "Parson" will.

3. The RLIKE operator

Available in MySQL, the RLIKE operator recognizes regular expressions (RegEx) in the pattern. RegEx is a powerful and versatile tool for advanced pattern matching. 

It does not hurt to have a basic understanding of RegEx, especially if your SQL flavor supports RLIKE. You can learn more about RegEx with our Regular Expressions in Python course.

SELECT DISTINCT
    first_name
FROM employees
WHERE first_name RLIKE 'Susann[a-e]'

4. The ‘~~’ operator

In PostgreSQL, ‘~~’ is completely synonymous with LIKE. There are also equivalents of ILIKE, NOT LIKE, and NOT ILIKE.

Troubleshooting: Common Errors and Mistakes with LIKE

Here are some common errors you may run into when using LIKE, and how to correct them:

1. No results returned: Check for case sensitivity. In some SQL dialects, LIKE is case-sensitive by default. Use LOWER() or ILIKE (if supported) for case-insensitive matching.
2. Unexpected results with wildcards: Make sure % and _ are used correctly. % matches any number of characters, while _ matches exactly one character. Misplacing these can lead to unexpected matches.
3. Performance issues: If your query is slow, look for leading % in patterns (e.g., %pattern), which disables index usage. Rewrite patterns to start with a specific string if possible. See the section below for more on performance. 
4. SQL injection errors: If you’re using user input in your query, make sure it is properly parameterized to avoid syntax errors or vulnerabilities.
5. Special characters in patterns: Wildcard symbols like % and _ in the search string must be escaped if intended as literal characters. Use ESCAPE in your query to define an escape character.

WHERE column_name LIKE '50\% OFF' ESCAPE '\'

Performance Considerations When Using the LIKE Operator

The LIKE operator is great, but it can potentially impact query performance, especially when used on large datasets. Here are some considerations to optimize its use:

1. Indexes: The LIKE operator performs best when the pattern starts with a constant string, such as Adam%, because the database can use indexes. However, patterns like %Adam or %Adam% require a full table scan, which can be slow for large tables.
2. Avoid leading wildcards: Starting a pattern with %, such as %pattern, disables index usage, as the database has to examine every record.
3. Collation and case-insensitive matching: Using functions like LOWER() or UPPER() on columns for case-insensitive searches can also prevent indexes from being used. Instead, make sure the database collation is set appropriately for case-insensitive comparisons.
4. Alternative approaches: For large datasets, consider using full-text search or database-specific search features, such as GIN indexes in PostgreSQL or FULLTEXT indexes in MySQL, when performing complex or frequent string matching.
5. Selective queries: Limit the scope of your queries using additional filters, such as date ranges or numerical columns, to reduce the data processed by the LIKE operator.

LIKE vs. Full-Text Search

Full-text search, available in databases like MySQL, PostgreSQL, and SQL Server, is optimized for advanced text queries, such as searching for keywords, handling linguistic variations, and ranking results by relevance. While LIKE is great for basic tasks, full-text search is better for scalable and sophisticated text search.

Use SQL LIKE Confidently

Mastering SQL functions is key to succeeding in data science, and SQL’s LIKE command is no exception. A good command of SQL will supercharge your analytics progress, so be sure to learn it well!

For more resources on SQL, be sure to check out the following:

• Introduction to SQL Course
• Learn SQL hub
• SQL Basics Cheat Sheet