Comprender la función DECODE() de SQL

Comprender cómo implementar la lógica condicional directamente dentro de las consultas SQL es una habilidad necesaria para los analistas de datos, científicos e ingenieros. Este tutorial proporciona una guía completa sobre el uso de la función SQL DECODE() en Oracle. También compararé DECODE() con CASE WHEN en Oracle y te ayudaré a entender cuándo utilizar cada función. Por último, proporcionaré código para las transformaciones equivalentes en SQL Server, PostgreSQL y MySQL. 

Antes de ver los ejemplos prácticos, te recomiendo que sigas el curso Introducción a Oracle SQL de DataCamp para refrescar tus conocimientos sobre el uso del dialecto PL/SQL. Además, nuestro curso de SQL Intermedio te dotará de los conocimientos avanzados de SQL necesarios para manejar consultas con la función DECODE() porque, como veremos, DECODE() se utiliza a menudo con una sintaxis más avanzada, como las subconsultas.

Cómo utilizar la función DECODE() de SQL

La función SQL DECODE() está soportada de forma nativa en la base de datos Oracle y está disponible en el dialecto PL/SQL. La función DECODE() permite implementar la lógica condicional dentro de la consulta. Esta técnica es importante porque ayuda en la transformación de datos al recuperar registros de la base de datos.

Considera la siguiente tabla employees, en la que department_id tiene valores numéricos. En su lugar, queremos que department_id se llame department_name y tenga categorías más comprensibles.

Tabla de ejemplo para transformar utilizando la función SQL DECODE(). Imagen del autor.

El ejemplo siguiente muestra cómo utilizar la función DECODE() para transformar los department_id en los nombres reales.

-- Using DECODE to transform department_id to department_name
SELECT 
    employee_id,
    first_name,
    last_name,
    DECODE(department_id, 
        1, 'IT', 
        2, 'HR', 
        3, 'Finance', 
        4, 'Marketing', 
        5, 'Sales', 
        'Unknown') AS department_name,
    salary,
    hire_date,
    city
FROM employees;

Ejemplo de tabla de salida tras utilizar la función SQL DECODE(). Imagen del autor.

Comprender la función DECODE() de SQL

La función DECODE() está disponible en la base de datos Oracle y te permite transformar una columna utilizando la lógica condicional. La función DECODE() permite múltiples transformaciones condicionales utilizando una simple consulta.

La sintaxis de la función DECODE() es la que se muestra a continuación:

DECODE(expression, search1, result1, search2, result2, ..., default)

Dónde:

• expression: El valor a comparar.

• search: El valor a comparar con la expresión.

• result: El valor devuelto si la expresión coincide con el valor buscado.

• default: El valor devuelto si no se encuentra ninguna coincidencia (opcional).

Técnicas y consideraciones avanzadas con la función DECODE() de SQL

Algunas operaciones SQL avanzadas pueden realizarse utilizando la función DECODE(). Las técnicas avanzadas permiten una transformación lógica condicional más compleja. 

DECODE() con funciones agregadas

La función DECODE() de Oracle puede utilizarse en la sentencia SELECT para recategorizar una variable, y también puede utilizarse en la sentencia SELECT con funciones agregadas para una agrupación más complicada, lo que mejora aún más la flexibilidad y la interpretación de los resultados. 

En la siguiente consulta, utilizamos DECODE() para transformar department_id en department_name. También utilizamos DECODE() para clasificar el salario medio en "salarios altos" o "salarios bajos".

SELECT 
    department_id,
    
    -- Use DECODE to transform department_id into department_name
    DECODE(
        department_id,
        1, 'IT', 
        2, 'HR', 
        3, 'Finance', 
        4, 'Marketing', 
        5, 'Sales', 
        'Unknown'
    ) AS department_name,
    
    SUM(salary) AS total_salary, 
    
    -- Calculate the average salary for each department and round to nearest integer
    ROUND(AVG(salary), 0) AS average_salary,
    
    -- Use DECODE to categorize average salary into 'High Paying' or 'Low Paying'
    DECODE(
        SIGN(AVG(salary) - 65000), 
        1, 'High Paying', 
        0, 'High Paying', 
        -1, 'Low Paying' 
    ) AS salary_category
FROM 
    employees
GROUP BY 
    department_id; 

Ejemplo de salida de una tabla tras utilizar varias funciones SQL DECODE(). Imagen del autor

Sentencias DECODE() anidadas

Implementar la función DECODE() con subconsultas te permite realizar sofisticadas transformaciones lógicas condicionales de los datos. La sentencia DECODE() anidada en Oracle ayuda cuando queremos evaluar varias condiciones en una tabla.

En el ejemplo siguiente, hemos utilizado la sentencia anidada DECODE() para clasificar a los empleados en función de su departamento y salario.

-- Select the columns
SELECT 
    employee_id,
    first_name, 
    last_name, 
    department_id,
    salary, 
    
    -- Use DECODE to categorize salary based on department and salary thresholds
    DECODE(department_id,
        
        1, DECODE( -- If department_id is 1 (IT)
            CASE 
                WHEN salary > 65000 THEN 'High' 
                ELSE 'Low' 
            END, 
            'High', 'IT High Salary', 
            'Low', 'IT Low Salary' 
        ),
        
        2, DECODE( -- If department_id is 2 (HR)
            CASE 
                WHEN salary > 55000 THEN 'High'
                ELSE 'Low' 
            END, 
            'High', 'HR High Salary', 
            'Low', 'HR Low Salary' 
        ),
        
        3, DECODE( -- If department_id is 3 (Finance)
            CASE 
                WHEN salary > 70000 THEN 'High' 
                ELSE 'Low' 
            END, 
            'High', 'Finance High Salary', 
            'Low', 'Finance Low Salary' 
        ),
        
        4, DECODE( -- If department_id is 4 (Marketing)
            CASE 
                WHEN salary > 68000 THEN 'High'
                ELSE 'Low' 
            END, 
            'High', 'Marketing High Salary', 
            'Low', 'Marketing Low Salary' 
        ),
        
        5, DECODE( -- If department_id is 5 (Sales)
            CASE 
                WHEN salary > 60000 THEN 'High' 
                ELSE 'Low'  
            END, 
            'High', 'Sales High Salary', 
            'Low', 'Sales Low Salary'
        ),
        
        'Unknown Department' -- Default value if department_id does not match any case
    ) AS salary_category
FROM 
    employees;

Ejemplo de salida de tabla tras utilizar la función DECODE() anidada. Imagen del autor

Cómo trata DECODE() los valores NULL

La función DECODE() también trata de forma diferente los valores de NULL de dos maneras. Por un lado, DECODE() actúa como si dos valores de NULL fueran equivalentes. Esta funcionalidad significa que los valores de NULL se consideran coincidentes al comparar los valores de la columna con NULL. Aun así, debes tener cuidado con los resultados inesperados en los que no se tenga en cuenta explícitamente la NULL, ya que puede enmascarar los valores de NULL durante la transformación.

Además, debes saber que, al igual que la sentencia CASE WHEN, la función DECODE() devuelve un valor NULL si no se encuentra ninguna coincidencia.

El ejemplo siguiente muestra cómo la función DECODE() devuelve valores nulos cuando faltan department_id y salary.

-- Select columns
SELECT 
    employee_id,
    first_name,
    last_name, 
    department_id, 
    salary, 
    -- Determine the salary category based on the salary value
    DECODE(salary, 
        NULL, 'No Salary Information',
        60000, 'Standard Salary',
        'Other Salary') AS salary_category, 
    -- Determine the department name based on the department ID
    DECODE(department_id, 
        1, 'IT',
        2, 'HR',
        3, 'Finance',
        4, 'Marketing',
        5, 'Sales') AS department_name 
        -- If department_id does not match any of the above, return NULL
FROM 
    employees;

Ejemplo de salida de tabla después de utilizar DECODE() para tratar valores NULL. Imagen del autor

DECODE vs. CASE WHEN en Oracle

La función DECODE() fue la primera que se introdujo, y aunque ha sido sustituida por la declaración CASE WHEN, sigue siendo la preferida en algunos contextos. Por ejemplo, la sintaxis de la función DECODE() es más sencilla, por lo que si la lógica es bastante simple, es más fácil de leer y entender. 

Además, la función DECODE() suele ser más rápida, ya que su rendimiento se ha optimizado como función incorporada, aunque la diferencia puede ser insignificante. Por último, en los sistemas Oracle heredados, puede que tengas que utilizar la función DECODE() como función incorporada. 

Alternativas a DECODE() en otras bases de datos

La función DECODE() sólo es compatible con la base de datos Oracle. Sin embargo, SQL Server, PostgreSQL y MySQL proporcionan métodos alternativos para aplicar la lógica de transformación condicional de datos.

La función DECODE() es útil en la transformación de datos, ya que simplifica la lógica compleja al eliminar el uso de las sentencias IF ELSE o CASE. La función DECODE() también mejora la legibilidad de las consultas, permitiendo una manipulación eficaz de los datos. Examinemos los distintos casos de uso de la función DECODE().

Uso de CASE WHEN en SQL Server, PostgreSQL y MySQL

La sentencia CASE WHEN proporciona una alternativa a la función DECODE() para realizar la transformación lógica condicional de SQL. La sintaxis y la implementación de CASE WHEN son coherentes en las bases de datos SQL Server, PostgreSQL y MySQL.

El siguiente ejemplo muestra cómo utilizar la sentencia CASE WHEN para transformar los datos dentro de la sentencia SELECT. La consulta también muestra cómo combinar la sentencia CASE WHEN con otras funciones SQL para una transformación condicional compleja.

 -- Select department ID
SELECT 
    department_id,
    
    -- Use CASE to transform department_id into department_name
    CASE 
        WHEN department_id = 1 THEN 'IT'
        WHEN department_id = 2 THEN 'HR'
        WHEN department_id = 3 THEN 'Finance'
        WHEN department_id = 4 THEN 'Marketing'
        WHEN department_id = 5 THEN 'Sales'
        ELSE 'Unknown' 
    END AS department_name,
    
    SUM(salary) AS total_salary,
    
    -- Calculate the average salary for each department and round to the nearest whole number
    ROUND(AVG(salary), 0) AS average_salary,
    
    -- Use CASE to categorize average salary into 'High Paying' or 'Low Paying'
    CASE 
        WHEN AVG(salary) > 65000 THEN 'High Paying'
        ELSE 'Low Paying' 
    END AS salary_category
FROM 
    employees
GROUP BY 
    department_id; -- Group results by department ID   

Conclusión y aprendizaje posterior

Comprender la función Oracle DECODE() es importante para aprender a transformar datos con eficacia. La función DECODE() ofrece varios casos de uso para aplicar la lógica condicional durante la transformación de datos. También es importante que aprendas transformaciones condicionales alternativas en bases de datos SQL Server, PostgreSQL y MySQL. Te animo a que practiques la función DECODE() utilizando diferentes conjuntos de datos y casos de uso para perfeccionar tus habilidades de transformación de datos.

Si quieres avanzar en tus habilidades de análisis de datos, te recomiendo que sigas el curso de Informes en SQL de DataCamp para mejorar tus habilidades de análisis y presentación. Del mismo modo, deberías echar un vistazo a nuestro itinerario profesional de Analista de Datos Asociado en SQL para ayudarte a mantener el progreso del SQL necesario que necesitarás en tu carrera como analista de datos. Por último, te recomiendo encarecidamente que realices el proyecto Data-Driven Decision Making in SQL de DataCamp para demostrar tu dominio en el uso de distintas técnicas SQL para el análisis y la elaboración de informes, y así destacar entre los demás analistas de datos.