🇯🇵 日本語 | 🇺🇸 English | 🇪🇸 Español | 🇵🇹 Português | 🇹🇭 ไทย | 🇨🇳 中文

【Cláusula LIKE de SQL】¡Domina la Búsqueda por Coincidencia Parcial! Cómo Usar los Comodines '%' y '_'

Una función de búsqueda es esencial para cualquier sitio web, ¿verdad? Innumerables veces, te encontrarás queriendo buscar datos que no son una coincidencia exacta, sino parcial, como "Quiero encontrar libros que contengan la palabra 'SQL'" o "Listar todos los usuarios cuyos nombres comiencen con 'Suzuki'". Usar = (igual) en una cláusula WHERE encuentra coincidencias exactas, pero ¿cómo manejas las "búsquedas aproximadas" o "coincidencias parciales" como estas?

La respuesta es la cláusula LIKE de SQL. Cuando se combina con la cláusula WHERE, LIKE te permite extraer datos basados en una coincidencia parcial de una cadena de texto. Y lo que mejora dramáticamente sus capacidades de búsqueda son unos símbolos especiales llamados comodines (wildcards). Al igual que un comodín en una baraja de cartas, estos símbolos pueden sustituir a cualquier carácter, haciendo que tus búsquedas de datos sean más flexibles y potentes.

Este artículo explicará a fondo todo, desde el uso básico de la cláusula LIKE, cómo utilizar los dos comodines principales (% y _), hasta consejos prácticos, todo con código que puedes copiar y pegar. ¡Ahora, exploremos el mundo de la cláusula LIKE en tu camino para convertirte en un maestro de la búsqueda!

Preparación: Configuremos Nuestros Datos de Libros para la Búsqueda

Para probar las búsquedas de coincidencia parcial, primero necesitamos algunos datos con los que buscar. Esta vez, crearemos una tabla simple de books para gestionar una lista de libros. Registraremos intencionadamente libros con títulos similares y títulos que contienen caracteres especiales para poder probar varios patrones de búsqueda.

-- Si la tabla books existe, la elimina (para pruebas repetibles)
DROP TABLE IF EXISTS books;

-- Crea una nueva tabla books
CREATE TABLE books (
  id INTEGER PRIMARY KEY,
  title TEXT NOT NULL,
  author TEXT NOT NULL,
  price INTEGER
);

-- Inserta datos iniciales
INSERT INTO books (id, title, author, price) VALUES
(1, 'Empezando con SQL', 'Yamada Taro', 2500),
(2, 'Análisis Práctico de Datos con SQL', 'Suzuki Ichiro', 3200),
(3, 'El Manual de Diseño Web', 'Sato Hanako', 2800),
(4, 'Introducción Divertida a SQL', 'Yamada Taro', 2200),
(5, 'Guía de Producción de Sitios Web', 'Sato Jiro', 3000),
(6, 'Marketing para un Crecimiento del 120%', 'Tanaka Minoru', 1800),
(7, 'Empezando con SQL, Parte 2', 'Yamada Taro', 2600);

Ahora estamos listos para intentar buscar con varias palabras clave.

Comodín ①: `%` (Porcentaje) - Cero o Más Caracteres

El % es el comodín más comúnmente usado con la cláusula LIKE. Representa "cualquier cadena de cero o más caracteres", sin importar la longitud o el tipo. En otras palabras, piénsalo como la carta comodín todopoderosa que puede ser cualquier cosa.

Coincidencia de Prefijo: Encontrando datos que "comienzan con..."

Usar el patrón 'cadena_a_buscar%' te permite encontrar datos que comienzan con la cadena especificada.

Escenario: "Quiero encontrar libros cuyos títulos comiencen con 'SQL'."

SELECT * FROM books WHERE title LIKE 'SQL%';

Resultado:

id | title                   | author      | price
---|-------------------------|-------------|-------
1  | Empezando con SQL       | Yamada Taro | 2500
7  | Empezando con SQL, Parte 2 | Yamada Taro | 2600

Encontró los libros con ID 1 y 7. 'Introducción Divertida a SQL' y 'Análisis Práctico de Datos con SQL' no se incluyeron en los resultados porque sus títulos no comienzan con "SQL".

Coincidencia de Sufijo: Encontrando datos que "terminan en..."

Usar el patrón '%cadena_a_buscar' te permite encontrar datos que terminan con la cadena especificada.

Escenario: "Quiero encontrar libros de autores cuyos nombres terminen en 'Taro'."

SELECT * FROM books WHERE author LIKE '%Taro';

Resultado:

id | title                         | author      | price
---|-------------------------------|-------------|-------
1  | Empezando con SQL             | Yamada Taro | 2500
4  | Introducción Divertida a SQL  | Yamada Taro | 2200
7  | Empezando con SQL, Parte 2    | Yamada Taro | 2600

Se han listado todos los libros de "Yamada Taro".

Coincidencia de Subcadena (Contiene): Encontrando datos que "contienen..."

Este es el uso más versátil. Al rodear la palabra clave de búsqueda con %, como '%cadena_a_buscar%', puedes encontrar todos los datos que contienen la cadena especificada en cualquier parte.

Escenario: "Quiero encontrar todos los libros que contengan la palabra 'SQL' en su título."

SELECT * FROM books WHERE title LIKE '%SQL%';

Resultado:

id | title                                | author        | price
---|--------------------------------------|---------------|-------
1  | Empezando con SQL                    | Yamada Taro   | 2500
2  | Análisis Práctico de Datos con SQL   | Suzuki Ichiro | 3200
4  | Introducción Divertida a SQL         | Yamada Taro   | 2200
7  | Empezando con SQL, Parte 2           | Yamada Taro   | 2600

Esta vez, todos los libros con "SQL" en cualquier parte del título se incluyen en los resultados de la búsqueda. Consultas como esta se usan con frecuencia entre bastidores en las funciones de búsqueda de los sitios web.

Comodín ②: `_` (Guion Bajo) - Cualquier Carácter Único

El otro comodín importante es el _ (guion bajo). Mientras que % era el comodín "todo vale" para cero o más caracteres, el _ representa "exactamente un carácter de cualquier tipo". La diferencia clave es que el número de caracteres es fijo, exactamente uno.

Esto es útil para búsquedas más precisas, como distinguir entre "Sato" y "Saitou".

Escenario: "Quiero encontrar autores cuyo apellido sea 'Sato' y cuyo nombre consista en cuatro letras (ej., Sato Jiro, Sato Hana)."

-- Un patrón que coincide con 'Sato ' seguido de cuatro caracteres cualesquiera
SELECT * FROM books WHERE author LIKE 'Sato ____';

Resultado:

id | title                   | author     | price
---|-------------------------|------------|-------
3  | El Manual de Diseño Web | Sato Hanako| 2800
5  | Guía de Producción de Sitios Web| Sato Jiro  | 3000

Al usar cuatro guiones bajos, especificamos "cuatro caracteres cualesquiera", lo que nos permitió encontrar tanto a "Sato Hanako" como a "Sato Jiro". Si hubiéramos usado LIKE 'Sato _', solo habría coincidido con autores con un nombre de una sola letra (si existiera alguno).

Aplicación: Buscando '%' o '_' como Caracteres Literales (La Cláusula `ESCAPE`)

Ahora un problema un poco más difícil. ¿Qué pasa si quieres encontrar un libro con "120%" en el título?

Si simplemente escribes WHERE title LIKE '%120%%', los símbolos % del principio y del final se interpretarán como comodines, y no obtendrás los resultados de búsqueda deseados. Para situaciones como esta, en las que deseas buscar los propios caracteres comodín como texto literal, entra en juego la cláusula ESCAPE.

La cláusula ESCAPE te permite definir un "carácter de escape" especial (como !, #, o \) que le dice a la base de datos que deshabilite el significado especial del comodín que le sigue inmediatamente.

-- Definir '!' como el carácter de escape
SELECT * FROM books WHERE title LIKE '%120!%%' ESCAPE '!';

En esta consulta, ESCAPE '!' especifica ! como el carácter de escape. Esto significa que la parte escrita como !% se interpreta como "esto no es un comodín, sino un carácter '%' literal". Como resultado, solo el libro con ID 6, 'Marketing para un Crecimiento del 120%', coincide correctamente.

Los caracteres de escape comúnmente utilizados incluyen !, #, y \ (barra invertida).

【Patio de Recreo Interactivo】¡Prueba las Búsquedas por Coincidencia Parcial en tu Navegador!

¡Es hora de convertir el conocimiento en habilidad! Copia todo el código HTML a continuación, guárdalo como un archivo llamado sql_like_test.html y ábrelo en tu navegador. Se iniciará tu propio entorno SQL personal, precargado con la tabla books que hemos estado usando en este artículo.

Prueba a cambiar las posiciones de % y _, o a usar diferentes palabras clave, para ver cómo cambian los resultados de la búsqueda. ¡El camino para convertirse en un maestro de la búsqueda está pavimentado con la prueba y el error!

<!DOCTYPE html>
<html lang="es">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Patio de Recreo en Línea de la Cláusula LIKE de SQL</title>
  <style>
    body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif; line-height: 1.7; color: #333; max-width: 800px; margin: 2rem auto; padding: 0 1rem; }
    h1 { color: #3498db; }
    textarea { width: 100%; height: 180px; font-family: "SF Mono", "Consolas", monospace; font-size: 16px; padding: 12px; border: 1px solid #ccc; border-radius: 6px; box-sizing: border-box; margin-bottom: 1rem; }
    button { background-color: #3498db; color: white; border: none; padding: 12px 22px; font-size: 16px; border-radius: 6px; cursor: pointer; transition: background-color 0.2s; }
    button:hover { background-color: #2980b9; }
    button:disabled { background-color: #bdc3c7; cursor: not-allowed; }
    #result-container { margin-top: 2rem; border: 1px solid #ddd; padding: 1rem; border-radius: 6px; background: #fdfdfd; min-height: 50px; }
    #error-message { color: #e74c3c; font-weight: bold; }
    table { border-collapse: collapse; width: 100%; margin-top: 1rem; }
    th, td { border: 1px solid #ddd; padding: 10px; text-align: left; }
    th { background-color: #f2f2f2; }
    tr:nth-child(even) { background-color: #f9f9f9; }
  </style>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/sql.js/1.10.3/sql-wasm.js"></script>
</head>
<body>

  <h1>¡Probemos SQL!</h1>
  <p>Introduce una sentencia SQL en el área de texto de abajo y haz clic en el botón "Ejecutar". ¡Intenta buscar con diferentes palabras clave!</p>

  <textarea id="sql-input">-- Busquemos libros con "Web" en el título
SELECT * FROM books WHERE title LIKE '%Web%';
  </textarea>
  
  <button id="execute-btn">Ejecutar</button>
  
  <div id="result-container">
    <p id="error-message"></p>
    <div id="result-output"></div>
  </div>

  <script>
    const sqlInput = document.getElementById('sql-input');
    const executeBtn = document.getElementById('execute-btn');
    const errorMsg = document.getElementById('error-message');
    const resultOutput = document.getElementById('result-output');

    let db;

    async function initDb() {
      executeBtn.disabled = true;
      executeBtn.textContent = 'Inicializando BD...';
      try {
        const SQL = await initSqlJs({
          locateFile: file => `https://cdnjs.cloudflare.com/ajax/libs/sql.js/1.10.3/${file}`
        });
        db = new SQL.Database();
        
        const setupSql = `
          DROP TABLE IF EXISTS books;
          CREATE TABLE books (
            id INTEGER PRIMARY KEY,
            title TEXT NOT NULL,
            author TEXT NOT NULL,
            price INTEGER
          );
          INSERT INTO books (id, title, author, price) VALUES
          (1, 'Empezando con SQL', 'Yamada Taro', 2500),
          (2, 'Análisis Práctico de Datos con SQL', 'Suzuki Ichiro', 3200),
          (3, 'El Manual de Diseño Web', 'Sato Hanako', 2800),
          (4, 'Introducción Divertida a SQL', 'Yamada Taro', 2200),
          (5, 'Guía de Producción de Sitios Web', 'Sato Jiro', 3000),
          (6, 'Marketing para un Crecimiento del 120%', 'Tanaka Minoru', 1800),
          (7, 'Empezando con SQL, Parte 2', 'Yamada Taro', 2600);
        `;
        db.run(setupSql);
        
        executeBtn.disabled = false;
        executeBtn.textContent = 'Ejecutar';
        resultOutput.innerHTML = '<p>¡Todo listo! Siéntete libre de probar tus propias consultas SQL.</p>';

      } catch (err) {
        errorMsg.textContent = 'Error al inicializar la base de datos: ' + err.message;
        console.error(err);
      }
    }

    function executeSql() {
      if (!db) return;
      
      const sql = sqlInput.value;
      errorMsg.textContent = '';
      resultOutput.innerHTML = '';

      try {
        const results = db.exec(sql);
        if (results.length === 0) {
          resultOutput.innerHTML = '<p>Consulta ejecutada con éxito, pero no se devolvió ningún conjunto de resultados.</p>';
          return;
        }
        
        results.forEach(result => {
          const table = document.createElement('table');
          const thead = document.createElement('thead');
          const tbody = document.createElement('tbody');
          
          const headerRow = document.createElement('tr');
          result.columns.forEach(colName => {
            const th = document.createElement('th');
            th.textContent = colName;
            headerRow.appendChild(th);
          });
          thead.appendChild(headerRow);
          
          result.values.forEach(row => {
            const bodyRow = document.createElement('tr');
            row.forEach(cellValue => {
              const td = document.createElement('td');
              td.textContent = cellValue === null ? 'NULL' : cellValue;
              bodyRow.appendChild(td);
            });
            tbody.appendChild(bodyRow);
          });
          
          table.appendChild(thead);
          table.appendChild(tbody);
          resultOutput.appendChild(table);
        });

      } catch (err) {
        errorMsg.textContent = 'Error de SQL: ' + err.message;
        console.error(err);
      }
    }

    executeBtn.addEventListener('click', executeSql);
    
    initDb();
  </script>
</body>
</html>

Puntos a Tener en Cuenta: Rendimiento y Sensibilidad a Mayúsculas y Minúsculas

Aunque la cláusula LIKE es muy conveniente, hay algunos puntos a tener en cuenta al usarla en la práctica.

Para búsquedas de alta velocidad en grandes cantidades de datos de texto, es más común usar una función más avanzada llamada "Búsqueda de Texto Completo" (Full-Text Search) en lugar de la cláusula LIKE. Después de dominar LIKE, aprender sobre la búsqueda de texto completo sería un excelente siguiente paso.

Conclusión

En este artículo, nos hemos centrado en la cláusula LIKE para realizar búsquedas de coincidencia parcial en SQL, centrándonos en sus poderosos ayudantes, los comodines.

Dominar la cláusula LIKE es una habilidad esencial para proporcionar una funcionalidad de búsqueda fácil de usar. Por favor, utiliza el patio de recreo interactivo de este artículo para probar varios patrones y familiarizarte con la búsqueda por coincidencia parcial. ¡Tus habilidades de SQL acaban de subir de nivel otra vez!

Plantillas Relacionadas