A continuación hay cinco opciones para devolver filas que contienen letras mayúsculas en SQL Server.
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 LOWER(c1) COLLATE Latin1_General_CS_AS <> c1;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).
También usamos COLLATE Latin1_General_CS_AS para especificar explícitamente una intercalación que distingue mayúsculas de minúsculas (y acentos). Sin esto, podría obtener resultados inesperados, según la intercalación que se utilice en su sistema.
Opción 2:comparar con los caracteres reales
Otra opción es usar el LIKE operador y especifique los caracteres en mayúsculas reales que queremos hacer coincidir:
SELECT c1 FROM t1
WHERE c1 LIKE '%[ABCDEFGHIJKLMNOPQRSTUVWXYZ]%'
COLLATE Latin1_General_CS_AS;Resultado:
+----------------+ | c1 | |----------------| | CAFÉ | | Café | | eCafé | | James Bond 007 | | JB 007 | +----------------+
En este caso, se devuelven menos filas que en el ejemplo anterior. Esto se debe a que no especifiqué caracteres como É y Ø , que se devolvieron en el ejemplo anterior. Nuestro resultado contiene É pero esa fila solo se devolvió porque también contiene otros caracteres en mayúscula que do partido.
Por lo tanto, esta opción es más limitada que la anterior, pero le brinda más control sobre los caracteres que desea emparejar.
Opción 3:comparar con un rango de caracteres
Alternativamente, podemos especificar el rango de caracteres que queremos hacer coincidir:
SELECT * FROM t1
WHERE c1 LIKE '%[A-Z]%'
COLLATE Latin1_General_100_BIN2;Resultado:
+----------------+ | c1 | |----------------| | CAFÉ | | Café | | eCafé | | James Bond 007 | | JB 007 | +----------------+
En este caso, utilicé una intercalación binaria (Latin1_General_100_BIN2 ). Hice esto porque las intercalaciones binarias clasifican cada caso por separado (así:AB....YZ...ab...yz ).
Otras intercalaciones tienden a entremezclar las letras mayúsculas y minúsculas (como esta:AaBb...YyZz ), que por lo tanto coincidiría con caracteres en mayúsculas y minúsculas.
Opción 4:encontrar la primera instancia de un carácter en mayúscula
Otra forma de hacerlo es usar el PATINDEX() función:
SELECT * FROM t1
WHERE PATINDEX('%[ABCDEFGHIJKLMNOPQRSTUVWXYZ]%', c1
COLLATE Latin1_General_CS_AS) > 0;Resultado:
+----------------+ | c1 | |----------------| | CAFÉ | | Café | | eCafé | | James Bond 007 | | JB 007 | +----------------+
En este ejemplo, especificamos los caracteres exactos que queremos hacer coincidir, por lo que en este caso no obtuvimos las filas con caracteres like É y Ø (que no sea el que también contiene otros caracteres que coincidieron).
Un beneficio de esta técnica es que podemos usarla para ignorar el primer carácter (o un número específico de caracteres) si así lo deseamos:
SELECT * FROM t1
WHERE PATINDEX('%[ABCDEFGHIJKLMNOPQRSTUVWXYZ]%', c1
COLLATE Latin1_General_CS_AS) > 1;Resultado:
Time: 0.472s +-------+ | c1 | |-------| | eCafé | +-------+
Por lo tanto, podemos devolver todas las filas que contienen caracteres en mayúsculas, pero donde el primer carácter no está en mayúsculas.
Esto se debe a que PATINDEX() devuelve la posición inicial de la primera aparición del patrón (en nuestro caso, el patrón es una lista de caracteres en mayúsculas). Si la posición de inicio de la primera aparición es mayor que 1, entonces el primer carácter no está en nuestra lista de caracteres en mayúscula.
Opción 5:encontrar la primera instancia basada en un rango
También podemos usar PATINDEX() con un rango:
SELECT * FROM t1
WHERE PATINDEX('%[A-Z]%', c1
COLLATE Latin1_General_100_BIN2) > 1;Resultado:
+-------+ | c1 | |-------| | eCafé | +-------+
Nuevamente usé una intercalación binaria (como con el otro ejemplo de rango).
