Cuando se trabaja con datos en SQL Server, es importante entender cómo la sensibilidad a mayúsculas y la colación afectan la manipulación y comparación de cadenas de caracteres. En este artículo, exploraremos diferentes escenarios relacionados con el cambio de mayúsculas y la comparación de cadenas.

¿Qué es la Colación?

La colación es una configuración que determina cómo se representan, almacenan y comparan los caracteres en SQL Server. Cada servidor, base de datos o columna de caracteres tiene una colación predeterminada. Un aspecto de la colación es la sensibilidad a mayúsculas, que determina si una “A” en mayúsculas y una “a” en minúsculas se consideran iguales o diferentes al compararlas. Por ejemplo, si la colación es insensible a mayúsculas, las cadenas “AaAaA” y “aaaaa” se considerarían iguales. Sin embargo, si la colación es sensible a mayúsculas, estas dos cadenas se considerarían diferentes.

Funciones UPPER y LOWER

SQL Server proporciona dos funciones, UPPER y LOWER, para manejar el caso de las cadenas de caracteres. La función UPPER convierte todos los caracteres de una cadena a mayúsculas, mientras que la función LOWER los convierte a minúsculas. Por ejemplo, si se pasa la cadena “AbCd1234” a la función UPPER, devolverá “ABCD1234”. Por el contrario, si se pasa la misma cadena a la función LOWER, devolverá “abcd1234”. Estas funciones son útiles cuando se necesita estandarizar el caso de los datos.

Convertir el Primer Carácter de Cada Columna a Mayúsculas

Supongamos que tienes una tabla con una columna que contiene valores de mayúsculas y minúsculas, y quieres convertir el primer carácter de cada valor a mayúsculas manteniendo el resto de la columna en minúsculas. Aquí tienes un ejemplo de cómo puedes lograr esto:

SET NOCOUNT ON

IF EXISTS (SELECT * FROM dbo.sysobjects WHERE id = OBJECT_ID(N'[mytable]') AND OBJECTPROPERTY(id, N'IsUserTable') = 1)
    DROP TABLE [mytable]

GO

CREATE TABLE [mytable] (
    A CHAR(10)
)

GO

INSERT INTO mytable VALUES('aAaA')
INSERT INTO mytable VALUES('bBbB')
INSERT INTO mytable VALUES('cCcC')
INSERT INTO mytable VALUES('dDdD')
INSERT INTO mytable VALUES('DDdD')

SELECT UPPER(SUBSTRING(A, 1, 1)) + LOWER(SUBSTRING(A, 2, LEN(A))) AS [Upper Case First Letter Only]
FROM mytable

DROP TABLE mytable

En este ejemplo, creamos una tabla llamada “mytable” con una sola columna “A”. Insertamos cinco registros en esta tabla, cada uno de ellos contiene una cadena con caracteres de mayúsculas y minúsculas. La instrucción SELECT utiliza la función SUBSTRING para extraer el primer carácter de la columna “A” y lo pasa a la función UPPER para convertirlo a mayúsculas. El resto de la columna “A” se concatena al primer carácter en mayúsculas después de ser convertido a minúsculas utilizando la función LOWER.

Formatear Correctamente el Nombre de una Persona

Otro escenario común es formatear correctamente el nombre de una persona, donde el primer carácter de cada nombre (primer nombre, segundo nombre, apellido, etc.) está en mayúsculas y el resto del nombre está en minúsculas. Aquí tienes un ejemplo de cómo puedes lograr esto utilizando una función T-SQL:

IF OBJECT_ID (N'dbo.ProperCase', N'FN') IS NOT NULL
    DROP FUNCTION dbo.ProperCase

GO

CREATE FUNCTION ProperCase (@String VARCHAR(8000)) RETURNS VARCHAR(8000) AS
BEGIN
    DECLARE @TempString VARCHAR(8000)
    DECLARE @PS VARCHAR(8000)

    SET @PS = ''

    -- Convertir toda la cadena a minúsculas
    SET @TempString = LOWER(@String)

    WHILE PATINDEX('%[-( ")]%', @TempString) > 0
    BEGIN
        -- Comprobar si el primer carácter de @TempString es un espacio en blanco
        IF (PATINDEX('%[-( ")]%', SUBSTRING(@TempString, 1, 1)) > 0)
        BEGIN
            SET @PS = @PS + SUBSTRING(@TempString, 1, 1)
        END
        ELSE
        BEGIN
            -- @TempString comienza con un nombre
            IF SUBSTRING(@TempString, 1, 2) = 'mc'
            BEGIN
                SET @PS = @PS + 'Mc'
                SET @TempString = SUBSTRING(@Tempstring, 3, LEN(@TempString))
            END

            IF SUBSTRING(@TempString, 1, 3) = 'mac'
            BEGIN
                SET @PS = @PS + 'Mac'
                SET @TempString = SUBSTRING(@Tempstring, 4, LEN(@TempString))
            END

            -- Convertir el primer carácter a mayúsculas y devolver la cadena hasta el siguiente espacio
            SET @PS = @PS + UPPER(SUBSTRING(@TempString, 1, 1)) + SUBSTRING(@TempString, 2, PATINDEX('%[-( ")]%', @TempString) - 1)
        END

        -- Truncar la cadena que ya ha sido procesada
        SET @TempString = SUBSTRING(@TempString, PATINDEX('%[-( ")]%', @TempString) + 1, LEN(@TempString))

        -- Eliminar espacios en blanco iniciales
        SET @TempString = LTRIM(@TempString)
    END

    IF SUBSTRING(@TempString, 1, 2) = 'mc'
    BEGIN
        SET @PS = @PS + 'Mc'
        SET @TempString = SUBSTRING(@Tempstring, 3, LEN(@TempString))
    END

    IF SUBSTRING(@TempString, 1, 3) = 'mac'
    BEGIN
        SET @PS = @PS + 'Mac'
        SET @TempString = SUBSTRING(@Tempstring, 4, LEN(@TempString))
    END

    -- Formatear correctamente la última palabra/nombre
    SET @PS = @PS + UPPER(SUBSTRING(@TempString, 1, 1)) + SUBSTRING(@TempString, 2, LEN(@TempString))

    -- Comprobar espacios delante de caracteres especiales
    SET @PS = REPLACE(@PS, ' -', '-')
    SET @PS = REPLACE(@PS, ' "', '')

    RETURN (@PS)
END

Una vez que hayas creado la función, puedes usarla para formatear correctamente el nombre de una persona. Aquí tienes un ejemplo:

CREATE TABLE #temp (
    PersonName VARCHAR(100)
)

INSERT INTO #temp VALUES('GREGory A. LARSEN')
INSERT INTO #temp VALUES('TODD JOShUA   SMITH')
INSERT INTO #temp VALUES('HARRY  JOnes')
INSERT INTO #temp VALUES('Danielle i. RobBins')
INSERT INTO #temp VALUES('mr. john d. johnson')
INSERT INTO #temp VALUES('Jon o"connor')
INSERT INTO #temp VALUES('mARtiN mCGalpan')
INSERT INTO #temp VALUES('sARah   maCdonald')
INSERT INTO #temp VALUES('maRy   Smith-foster')
INSERT INTO #temp VALUES('Robert (bob)  smith')

SELECT dbo.ProperCase(PersonName) AS [Nombres con Formato Correcto]
FROM #temp

DROP TABLE #temp

En este ejemplo, creamos una tabla temporal llamada “#temp” con una columna “PersonName” para almacenar los nombres. Insertamos varios registros con nombres en diferentes casos. La instrucción SELECT llama a la función “ProperCase” y pasa la columna “PersonName” como parámetro. La función convierte toda la cadena a minúsculas y luego la procesa para formatear correctamente cada nombre. El resultado es una columna con nombres con formato correcto.

Comparar Columnas con Diferente Sensibilidad a Mayúsculas

Como se mencionó anteriormente, la colación de una cadena de caracteres determina cómo SQL Server compara las cadenas. Si tus datos se almacenan utilizando una colación insensible a mayúsculas, comparar las cadenas “AAAA” y “aaaa” resultaría en que se consideren iguales. Sin embargo, si deseas comparar dos cadenas insensibles a mayúsculas y que la comparación devuelva falso cuando la única diferencia sea el caso de los caracteres, puedes usar la cláusula COLLATE. Aquí tienes un ejemplo:

CREATE TABLE #mytable (
    C CHAR(10) COLLATE Latin1_General_CI_AS
)

INSERT INTO #mytable VALUES('aaaa')

SELECT C
FROM #mytable
WHERE C = 'AAAA'

SELECT C
FROM #mytable
WHERE C = 'AAAA' COLLATE Latin1_General_CS_AS

DROP TABLE #mytable

En este ejemplo, creamos una tabla temporal “#mytable” con una columna “C” que tiene una colación insensible a mayúsculas. Insertamos un registro con el valor “aaaa”. La primera instrucción SELECT compara la columna “C” con la cadena “AAAA” sin especificar una colación, lo que resulta en una coincidencia. Sin embargo, en la segunda instrucción SELECT, especificamos explícitamente una colación sensible a mayúsculas para la cadena “AAAA”, lo que hace que no coincida con el valor en la columna “C”. Esto demuestra cómo se puede usar la cláusula COLLATE para controlar la sensibilidad a mayúsculas de las comparaciones.

Conclusión

En este artículo, hemos explorado varios escenarios relacionados con la sensibilidad a mayúsculas y la colación en SQL Server. Hemos visto cómo cambiar el caso de las cadenas de caracteres utilizando las funciones UPPER y LOWER, cómo formatear correctamente el nombre de una persona utilizando una función personalizada y cómo comparar cadenas con diferentes casos utilizando la cláusula COLLATE. Comprender estos conceptos es crucial al trabajar con datos de caracteres en SQL Server para garantizar una manipulación y comparación precisas de las cadenas.