{"id":28113,"date":"2023-01-06T14:18:33","date_gmt":"2023-01-06T22:18:33","guid":{"rendered":"https:\/\/coderpad.io\/?p=28113"},"modified":"2023-06-07T13:39:51","modified_gmt":"2023-06-07T20:39:51","slug":"mysql-like-operator-a-detailed-guide","status":"publish","type":"post","link":"https:\/\/coderpad.io\/blog\/development\/mysql-like-operator-a-detailed-guide\/","title":{"rendered":"MySQL LIKE Operator: A Detailed Guide"},"content":{"rendered":"\n

A super common task when working with databases is searching for a text string  matching a given pattern. You might need to get all customers whose last names start with a “B” or retrieve all products whose ids contain a certain numerical sequence. If MySQL is your database, then the MySQL LIKE<\/code> operator is the solution you need.<\/p>\n\n\n\n

This post is a guide to using the LIKE<\/code> operator in MySQL. We’ll explain what exactly the MySQL LIKE<\/code> operator, and what you need it for and show several practical usage examples. Before we get started, let’s review some requirements for the post.<\/p>\n\n\n\n

Prerequisites<\/strong><\/h2>\n\n\n\n

For this post, I assume you have some familiarity with the SQL language. You should be fine if you have experience with some relational database, even if it’s not MySQL.<\/p>\n\n\n\n

You’ll need a local MySQL instance running and a way to connect to that instance to run commands. I recommend using the <\/a>CoderPad MySQL Sandbox<\/a> to quickly and easily get started writing SQL as it\u2019ll be your MySQL client for this article. <\/p>\n\n\n\n

MySQL LIKE operator: The what and why<\/strong><\/h2>\n\n\n\n

Let’s start with the basics. What is the LIKE<\/code> operator in MySQL, and why would you need it?<\/p>\n\n\n\n

MySQL LIKE<\/code> (and like<\/code> in other database engines as well) is an SQL operator you use to match textual columns against certain patterns. You’ve already seen some examples in the introduction, but here’s a longer list of potential use cases for the LIKE<\/code> operator:<\/p>\n\n\n\n

    \n
  • Retrieving all phone numbers that start with a given country calling code<\/li>\n\n\n\n
  • Getting all email addresses that belong to a given domain<\/li>\n\n\n\n
  • Retrieving all users who live at a certain street or district<\/li>\n<\/ul>\n\n\n\n

    In short, you’d typically use this operator when you need to retrieve potentially many rows that all have something in common, and such rows can’t be obtained through the use of the comparison operators (>, <, ==, !=<\/code>, and so on) or clauses such as BETWEEN<\/code>.<\/p>\n\n\n\n

    MySQL LIKE operator: some basic examples<\/strong><\/h2>\n\n\n\n

    In your sandbox MySQL instance, run the following commands to create a database, select it and create a table:<\/p>\n\n\n

    CREATE<\/span> TABLE<\/span> students (id<\/span> INT<\/span> NOT<\/span> NULL<\/span> AUTO_INCREMENT PRIMARY KEY<\/span>, first_name VARCHAR<\/span>(250<\/span>) NOT<\/span> NULL<\/span>, last_name VARCHAR<\/span>(250<\/span>) NOT<\/span> NULL<\/span>);<\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
    For the next steps, let’s add some students:<\/p>\n\n\n
    INSERT<\/span> INTO<\/span> students (first_name, last_name) VALUES<\/span> ('John'<\/span>, 'Smith'<\/span>);\n\nINSERT<\/span> INTO<\/span> students (first_name, last_name) VALUES<\/span> ('Pamelia'<\/span>, 'Black'<\/span>);\n\nINSERT<\/span> INTO<\/span> students (first_name, last_name) VALUES<\/span> ('Jonathan'<\/span>, 'Grey'<\/span>);<\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
    Now for the example. Let’s retrieve the id<\/code> and first_name<\/code> of students whose names start with “Jo”:<\/p>\n\n\n
    SELECT<\/span> id<\/span>, first_name FROM<\/span> students WHERE<\/span> first_name LIKE<\/span> 'Jo%'<\/span>;<\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
    The command above results in the following output:<\/p>\n\n\n
    +----+------------+<\/span>\n| id | first_name |\n+----+------------+<\/span>\n|  1 | John       |\n|  2 | Jonathan   |\n+----+------------+<\/span><\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
    Some things to note for this first example:<\/p>\n\n\n\n
      \n
    • The LIKE<\/code> operator is used alongside the WHERE<\/code> clause, in the condition portion<\/li>\n\n\n\n
    • To filter for values that start with a given text, we specify the text followed by the %<\/code> wildcard, which is a placeholder for “everything.”<\/li>\n<\/ul>\n\n\n\n
      Let’s now retrieve all students whose first name contains the letter “a”, in any position:<\/p>\n\n\n
      SELECT<\/span> id<\/span>, first_name FROM<\/span> students WHERE<\/span> first_name LIKE<\/span> '%a%'<\/span>;<\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
      Now, as you can see, the wildcard is put before and after the letter. And here’s the result:<\/p>\n\n\n
      +----+------------+<\/span>\n| id | first_name |\n+----+------------+<\/span>\n|  2 | Jonathan   |\n|  3 | Pamelia    |\n+----+------------+<\/span><\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
      That’s enough for you to get the gist of it. Let’s see more examples.<\/p>\n\n\n\n
      Matching a Single Character<\/strong><\/h2>\n\n\n\n
      All of the examples you saw until now use the %<\/code> character as a wildcard. This wildcard matches any number of characters. There’s another wildcard that matches exactly one character: the underscore (_<\/code>) wildcard. Let’s see in practice how it works.<\/p>\n\n\n\n
      Let’s insert two more students into the table:<\/p>\n\n\n
      INSERT<\/span> INTO<\/span> students (first_name, last_name) VALUES<\/span> ('Joe'<\/span>, 'Martin'<\/span>);\n\nINSERT<\/span> INTO<\/span> students (first_name, last_name) VALUES<\/span> ('Jon'<\/span>, 'Mendel'<\/span>);<\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
      Would it be possible to write a query to retrieve Joe and Jon, but not John or Jonathan? Yes:<\/p>\n\n\n
      SELECT<\/span> id<\/span>, first_name FROM<\/span> students WHERE<\/span> first_name LIKE<\/span> 'Jo_'<\/span>;<\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
      The query above gets students whose first name starts with “Jo”, followed by exactly one character. Here’s the result:<\/p>\n\n\n
      +----+------------+<\/span>\n| id | first_name |\n+----+------------+<\/span>\n|  4 | Joe        |\n|  5 | Jon        |\n+----+------------+<\/span><\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
      A Negative Match<\/strong><\/h2>\n\n\n\n
      What if you want to retrieve values that don’t match a given pattern? That’s also possible using the NOT LIKE<\/code> clause. For instance, let’s say you want to retrieve students whose last names don’t start with an M. Here’s the query for that:<\/p>\n\n\n
      SELECT<\/span> * FROM<\/span> students WHERE<\/span> last_name NOT<\/span> LIKE<\/span> 'M%'<\/span>;<\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
      The query above returns the students with last names “Black”, “Grey”, and “Smith”.<\/p>\n\n\n\n
      Escaping The Wildcard<\/strong><\/h2>\n\n\n\n
      What if the pattern you want to match contains the character “%” or “_”? In this case, it’s possible to escape the wildcard. Start by inserting a new student:<\/p>\n\n\n
      INSERT<\/span> INTO<\/span> students (first_name, last_name) VALUES<\/span> ('WeirdName%'<\/span>, '_WeirderLastName'<\/span>);<\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
      Now, let’s try to match the last name:<\/p>\n\n\n
      SELECT<\/span> * FROM<\/span> students WHERE<\/span> last_name LIKE<\/span> '_%'<\/span>;<\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
      If you ran the query above, you’ve seen that it gets all rows. Not what we wanted. Trying to match the first name will result in the same result.<\/p>\n\n\n\n
      Fortunately, it’s easy to escape the offending character using a backslash, which is the default escaping character. Let’s rewrite the query above in the correct way:<\/p>\n\n\n
      mysql> SELECT<\/span> * FROM<\/span> students WHERE<\/span> last_name LIKE<\/span> '\\_%'<\/span>;\n\n+----+------------+------------------+<\/span>\n| id | first_name | last_name        |\n+----+------------+------------------+<\/span>\n|  6 | WeirdName% | _WeirderLastName |\n+----+------------+------------------+<\/span><\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
      I already include the results above. As you can see, adding the backslash tells MySQL to treat the underscore just like a normal character. Now, for the first name:<\/p>\n\n\n
      mysql> SELECT<\/span> * FROM<\/span> students WHERE<\/span> first_name LIKE<\/span> '%\\%'<\/span>;\n\n+----+------------+------------------+<\/span>\n| id | first_name | last_name        |\n+----+------------+------------------+<\/span>\n|  6 | WeirdName% | _WeirderLastName |\n+----+------------+------------------+<\/span><\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
      In this case, the order is different. Since the student’s name ends with the percent character, first we include the wildcard and then the actual percentage character we’re trying to match, preceded by the escape character. As you can see above, it works like a charm.<\/p>\n\n\n\n
      Finally, even though the backslash is the default escaping character, it’s not the only one. Actually, you can pick your own escaping character using the ESCAPE<\/code> instruction. Let’s rewrite the query to retrieve match the last name, but specify the “#” character as the escape character:<\/p>\n\n\n
      SELECT<\/span> * FROM<\/span> students WHERE<\/span> last_name LIKE<\/span> '#_%'<\/span> ESCAPE '#'<\/span>;<\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
      And the result:<\/p>\n\n\n
      +----+------------+------------------+<\/span>\n| id | first_name | last_name        |\n+----+------------+------------------+<\/span>\n|  6 | WeirdName% | _WeirderLastName |\n+----+------------+------------------+<\/span><\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
      Test out the LIKE<\/code> operator in the sandbox below:<\/p>\n\n\n\n\t