Regular Expressions in SQL

Regular expressions (regex) are incredibly powerful tools that can vastly simplify data processing tasks. They're a method of specifying patterns of characters, numbers, and symbols, which can be used to identify, replace or split data. While regular expressions originate from computer science and are commonly used in programming languages, they're also available in SQL to help manage and manipulate data. SQL or Structured Query Language, is a powerful tool used to interact with databases and analyze large volumes of data. The goal of this blog post is to provide a beginner-friendly introduction to using regular expressions in SQL, complete with detailed explanations and code examples. Buckle up and prepare to add a powerful new tool to your SQL toolbox!

Introduction to Regular Expressions

In the most basic sense, a regular expression is a pattern that describes a certain amount of text. They allow us to formulate rules about what that pattern looks like. These patterns are used by string searching algorithms for "find", "find and replace" or "split" operations. They can also be used for input validation. For example, the regular expression for an email could be used to validate if a given string matches the typical pattern of an email address.

SELECT email FROM users WHERE REGEXP_LIKE(email, '^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$');

This SQL statement would return all emails from the 'users' table that match the regular expression, which is the pattern of an email address.

Regular Expressions in SQL

In SQL, three main functions allow us to work with regular expressions:



REGEXP_LIKE is a function that is used to match the input string with the regular expression pattern. If the input string matches the regular expression pattern, it returns true, otherwise false.

Here's an example to better illustrate the usage:

SELECT product_name FROM products WHERE REGEXP_LIKE(product_name, '^A');

This query will select all the product names from the products table that start with the letter 'A'.


The REGEXP_REPLACE function is used to replace the string matching a regular expression pattern. Here's an example:

SELECT REGEXP_REPLACE(phone_number, '[^0-9]', '') AS cleaned_number FROM contacts;

In this example, the REGEXP_REPLACE function will remove all non-numeric characters from the phone_number field in the 'contacts' table.


The REGEXP_SUBSTR function is used to extract a substring from a string that matches a regular expression pattern.

Here's an example:

SELECT REGEXP_SUBSTR(email, '@[^.]+') AS domain FROM users;

In this example, the REGEXP_SUBSTR function extracts the domain name from the email field in the 'users' table.

Basic Regular Expression Syntax

Regular expressions can be as simple or as complicated as you need them to be. Here are some of the most common elements:

  • . : Matches any single character.
  • * : Matches zero or more of the preceding element.
  • + : Matches one or more of the preceding element.
  • [abc] : Matches any of the enclosed characters.
  • [^abc] : Matches any character not enclosed.
  • ^ : Matches the start of a string.
  • $ : Matches the end of a string.
  • | : Logical OR operator.
  • (abc) : Matches 'abc' and remembers the match.

Real-World Examples of Regular Expressions in SQL

Example 1: Extracting URL from Text

Imagine we have a 'messages' table, and one of the fields contains a URL. We want to extract the URL from the text. Here's how we can do it:

SELECT REGEXP_SUBSTR(message, 'https?://[^ ]+') AS url FROM messages;

In this example, https?://[^ ]+ is the regular expression that matches the URL.

Example 2: Validating Email Addresses

If we want to find out which records in our 'users' table have valid email addresses, we can use the REGEXP_LIKE function with an email regular expression:

SELECT email FROM users WHERE REGEXP_LIKE(email, '^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$');

This query will return only those emails that match the regular expression, which corresponds to the typical structure of an email address.

Example 3: Replacing Non-Numeric Characters in a String

We may also need to clean up a string that should only contain numbers. For example, phone numbers in a 'contacts' table might contain special characters that we want to remove:

SELECT REGEXP_REPLACE(phone_number, '[^0-9]', '') AS cleaned_number FROM contacts;

In this case, [^0-9] is a regular expression that matches any character that is not a number. The REGEXP_REPLACE function replaces all these non-numeric characters with an empty string, effectively removing them from the phone number.

Frequently Asked Questions (FAQ)

1. Why should I use regular expressions in SQL?

Regular expressions allow you to perform complex pattern matching and manipulation of text fields in your SQL queries. They can help with tasks like data cleaning, validation, and extraction, which can be difficult to accomplish with standard SQL functions.

2. Are regular expressions case sensitive in SQL?

Yes, regular expressions in SQL are case sensitive. However, you can use the 'i' flag at the end of your regular expression pattern to make it case insensitive. For example, REGEXP_LIKE(name, 'john', 'i') will match 'John', 'john', 'JOHN', etc.

3. Can regular expressions be used in all SQL databases?

No, regular expression support in SQL depends on the specific SQL implementation. Oracle, PostgreSQL, and MySQL support regular expressions with specific functions. Some other database systems do not support regular expressions or have limited support.

4. Can regular expressions impact the performance of my SQL queries?

Yes, regular expressions can be computationally expensive if not used judiciously. It's recommended to use them only when necessary and ensure your regular expressions are as efficient as possible.

In conclusion, regular expressions are a powerful tool that can enhance your data manipulation and querying capabilities in SQL. Like any tool, it's not always the best solution for every problem, but when used properly, it can greatly simplify tasks that would otherwise be quite complex.

I hope this beginner-friendly guide has provided you with a clear understanding of how to use regular expressions in SQL. Happy querying!

Sharing is caring

Did you like what Mehul Mohan wrote? Thank them for their work by sharing it on social media.


No comments so far

Curious about this topic? Continue your journey with these coding courses: