Introducción a las estructuras de control: IF, CASE, RETURN

Las estructuras de control son la base de cualquier programa, ya sea un script SQL, código Python o incluso un robot en Marte que piensa si mandar una señal a casa o buscar vida detrás de la esquina del cráter.

En PL/pgSQL las estructuras de control nos ayudan a:

• Ejecutar ciertas acciones si las condiciones son verdaderas.
• Controlar el orden de ejecución del código.
• Implementar lógica de toma de decisiones.

Puedes imaginarlas como señales de tráfico en la carretera: "Si ves STOP, para. Si ves luz verde — ¡sigue!"

Las estructuras de control más populares en PL/pgSQL:

• IF – comprueba una condición y ejecuta los comandos correspondientes.
• CASE – alternativa a IF cuando hay muchas condiciones.
• RETURN – termina la ejecución de la función y devuelve el resultado.

Ya tienes una idea de ellas. Y después de otros lenguajes de programación, entenderlas será muy fácil.

El operador condicional IF

El operador IF se usa para ejecutar código solo si una condición específica es TRUE (verdadera). Aquí tienes su estructura básica:

IF condición THEN
  -- Código que se ejecuta si la condición es verdadera.
ELSE
  -- Código alternativo si la condición es falsa.
END IF;

Vamos a escribir una función que recibe un número y devuelve si es par o impar:

CREATE OR REPLACE FUNCTION check_even_odd(num INTEGER)
RETURNS TEXT AS $$
BEGIN
  IF num % 2 = 0 THEN
    RETURN 'Número par';
  ELSE
    RETURN 'Número impar';
  END IF;
END;
$$ LANGUAGE plpgsql;

Ahora la probamos:

SELECT check_even_odd(4); -- Número par
SELECT check_even_odd(7); -- Número impar

Breve explicación: IF num % 2 = 0 THEN comprueba si el número es divisible por 2 sin resto.

La condición ELSIF

A veces una sola comprobación no es suficiente y necesitas chequear varias condiciones. Para eso existe ELSIF.

Supón que tenemos una función que devuelve un mensaje de texto sobre la temperatura:

CREATE OR REPLACE FUNCTION temperature_comment(temp INTEGER)
RETURNS TEXT AS $$
BEGIN
  IF temp < 0 THEN
    RETURN '¡Muy frío!';
  ELSIF temp >= 0 AND temp <= 20 THEN
    RETURN 'Fresquito';
  ELSE
    RETURN '¡Calor!';
  END IF;
END;
$$ LANGUAGE plpgsql;

Probamos:

SELECT temperature_comment(-5);  -- ¡Muy frío!
SELECT temperature_comment(15);  -- Fresquito
SELECT temperature_comment(25);  -- ¡Calor!

Sintaxis de CASE

Si tienes muchas condiciones, el operador CASE te salva la vida. Es un poco parecido a IF, pero más "elegante".

CASE
  WHEN condición_1 THEN valor_1
  WHEN condición_2 THEN valor_2
  ELSE valor_por_defecto
END;

Vamos a crear una función que devuelve una valoración en texto según el número:

CREATE OR REPLACE FUNCTION grade_comment(score INTEGER)
RETURNS TEXT AS $$
BEGIN
  RETURN CASE
    WHEN score >= 90 THEN 'Excelente'
    WHEN score >= 75 THEN 'Bien'
    WHEN score >= 50 THEN 'Suficiente'
    ELSE 'Insuficiente'
  END;
END;
$$ LANGUAGE plpgsql;

Probamos:

SELECT grade_comment(95); -- Excelente
SELECT grade_comment(80); -- Bien
SELECT grade_comment(45); -- Insuficiente

Nota: a diferencia de IF, CASE devuelve un valor, así que puedes usar el operador RETURN directamente dentro de CASE.

El operador RETURN

RETURN termina la ejecución de la función y devuelve un valor. Esto es súper importante para las funciones en PL/pgSQL, que tienen que devolver algo (por ejemplo, texto, número, etc.).

Veamos cómo funciona RETURN en un ejemplo muy simple:

CREATE OR REPLACE FUNCTION return_example()
RETURNS TEXT AS $$
BEGIN
  RETURN '¡Hola, Mundo!';
END;
$$ LANGUAGE plpgsql;

Resultado:

SELECT return_example(); -- ¡Hola, Mundo!

¿Pero qué pasa si tenemos varias ramas de código? Por ejemplo, comprobando los datos de entrada. Entonces RETURN se usará en diferentes partes de la función:

CREATE OR REPLACE FUNCTION check_positive_negative(num INTEGER)
RETURNS TEXT AS $$
BEGIN
  IF num > 0 THEN
    RETURN 'Número positivo';
  ELSIF num = 0 THEN
    RETURN 'Cero';
  ELSE
    RETURN 'Número negativo';
  END IF;
END;
$$ LANGUAGE plpgsql;

Probamos:

SELECT check_positive_negative(10); -- Número positivo
SELECT check_positive_negative(0);  -- Cero
SELECT check_positive_negative(-5); -- Número negativo

Errores típicos y dónde puedes liarte

1. Olvidar el operador END: si te olvidas de END CASE; o END IF;, PostgreSQL te va a recordar enseguida que tienes que cerrar el bloque de código.
2. Errores lógicos usando ELSIF: ¡el orden de las condiciones importa! Una condición más general (temp > 0) no debe ir antes que una más específica (temp > 20).
3. Olvidar el RETURN: en PL/pgSQL la función tiene que devolver algo si declaraste RETURNS.

Eso es todo. Hemos visto lo básico de las estructuras de control y la lógica en PL/pgSQL. ¡Estos conocimientos te van a servir en la práctica cuando crees funciones más complejas! La próxima vez veremos los bucles y cómo usarlos.