Aquí hay tres opciones para devolver filas que contienen caracteres en mayúsculas en MySQL.
Datos de muestra
Supongamos que tenemos una tabla con los siguientes datos:
SELECT c1 FROM t1;Resultado:
+----------------+ | c1 | +----------------+ | CAFÉ | | Café | | café | | 1café | | eCafé | | James Bond 007 | | JB 007 | | 007 | | NULL | | | | É | | É 123 | | é | | é 123 | | ø | | Ø | +----------------+
Podemos usar los siguientes métodos para devolver las filas que contienen letras mayúsculas.
Opción 1:comparar con LOWER() Cadena
Podemos usar LOWER() función para comparar el valor original con su equivalente en minúsculas:
SELECT c1 FROM t1
WHERE CAST(LOWER(c1) AS BINARY) <> CAST(c1 AS BINARY);Resultado:
+----------------+ | c1 | +----------------+ | CAFÉ | | Café | | eCafé | | James Bond 007 | | JB 007 | | É | | É 123 | | Ø | +----------------+
Usando el no igual a (<> ) operador (alternativamente, puede usar != en lugar de <> si lo prefiere), solo devolvemos aquellas filas que son diferentes a sus equivalentes en minúsculas. La razón por la que hacemos esto es porque, si un valor es igual a su equivalente en minúsculas, para empezar ya estaba en minúsculas (y no queremos devolverlo).
De forma predeterminada, MySQL realiza una búsqueda que no distingue entre mayúsculas y minúsculas, por lo que uso el CAST() función para convertir los valores a binario para obtener una búsqueda que distinga entre mayúsculas y minúsculas.
También es posible usar el BINARY operador para convertir el valor en binario, pero este operador está obsoleto a partir de MySQL 8.0.27 y podría eliminarse en una versión futura.
En cualquier caso, así es como se ve el código cuando se usa BINARY operador:
SELECT c1 FROM t1
WHERE BINARY LOWER(c1) <> BINARY c1;También se puede hacer así:
SELECT c1 FROM t1
WHERE BINARY(LOWER(c1)) <> BINARY(c1);Estos son los resultados que obtengo de ambos cuando ejecuto el código en MySQL 8.0.27:
+----------------+ | c1 | +----------------+ | CAFÉ | | Café | | eCafé | | James Bond 007 | | JB 007 | | É | | É 123 | | Ø | +----------------+ 8 rows in set, 2 warnings (0.00 sec)
Y cuando muestro las advertencias:
SHOW WARNINGS;Resultado:
+---------+------+----------------------------------------------------------------------------------------------+ | Level | Code | Message | +---------+------+----------------------------------------------------------------------------------------------+ | Warning | 1287 | 'BINARY expr' is deprecated and will be removed in a future release. Please use CAST instead | | Warning | 1287 | 'BINARY expr' is deprecated and will be removed in a future release. Please use CAST instead | +---------+------+----------------------------------------------------------------------------------------------+
Opción 2:comparar con los caracteres reales
Otra opción es usar el REGEXP operador con un patrón de expresión regular que incluye explícitamente cada carácter en mayúscula que queremos hacer coincidir:
SELECT c1 FROM t1
WHERE CAST(c1 AS BINARY) REGEXP CAST('[ABCDEFGHIJKLMNOPQRSTUVWXYZ]' AS BINARY);Resultado:
+----------------+ | c1 | +----------------+ | CAFÉ | | Café | | eCafé | | James Bond 007 | | JB 007 | +----------------+
Esta vez se devuelven menos filas que en los ejemplos anteriores. Eso es porque no especifiqué caracteres como É y Ø , que se devolvieron en esos ejemplos. Nuestro resultado contiene É pero esa fila solo se devolvió porque también contiene otros caracteres en mayúscula que do partido.
Por lo tanto, deberá asegurarse de tener cubiertos todos los caracteres válidos si usa esta opción.
Opción 3:comparar con un rango de caracteres
Otra forma de hacerlo es especificar el rango de caracteres en mayúscula que queremos hacer coincidir:
SELECT c1 FROM t1
WHERE CAST(c1 AS BINARY) REGEXP CAST('[A-Z]' AS BINARY);Resultado:
+----------------+ | c1 | +----------------+ | CAFÉ | | Café | | eCafé | | James Bond 007 | | JB 007 | +----------------+
