Tipos de datos y su uso en PL/pgSQL: INTEGER, TEXT, BOOLEAN, RECORD

En esta lección vamos a ver qué tipos de datos soporta PL/pgSQL y cómo trabajar con ellos de forma eficiente. Nos vamos a centrar en cuatro tipos de datos:

• INTEGER para trabajar con números.
• TEXT para manejar cadenas de texto.
• BOOLEAN para valores lógicos.
• RECORD para estructuras de datos dinámicas.

Vamos a ver cada tipo de dato con ejemplos, para que puedas ver cómo se usan en la práctica.

Tipos de datos soportados en PL/pgSQL

PL/pgSQL soporta todos los tipos de datos que ya conoces de PostgreSQL. Desde los numéricos simples (INTEGER, NUMERIC) hasta otros más complejos como arrays y JSONB. Vamos a repasar los principales.

1. Tipos primitivos:

   • INTEGER, BIGINT, FLOAT, NUMERIC — tipos numéricos.
   • TEXT, CHAR, VARCHAR — tipos de texto.
   • BOOLEAN — tipo de dato lógico.

2. Tipos complejos:

   • RECORD — para trabajar con conjuntos de datos dinámicos.
   • ROWTYPE — para trabajar con tipos de fila de tabla.
   • Arrays y JSON — los veremos más adelante en el curso.

Trabajando con el tipo INTEGER

INTEGER es uno de los tipos de datos más comunes. Se usa para guardar números enteros. En PL/pgSQL puedes usar este tipo para hacer cálculos, manejar identificadores de registros y comprobar condiciones.

Ejemplo: contar el número de registros

Supón que tienes una tabla students y quieres saber cuántos estudiantes hay en la base de datos.

DO $$
DECLARE
    total_students INTEGER; -- Variable para guardar el número de estudiantes
BEGIN
    SELECT COUNT(*) INTO total_students FROM students; -- Guardamos el resultado de la consulta en la variable
    RAISE NOTICE 'Cantidad de estudiantes: %', total_students; -- Mostramos el mensaje
END;
$$;

Puntos importantes al trabajar con INTEGER:

• En PL/pgSQL, para asignar un valor a una variable se usa la palabra clave INTO.
• Si intentas guardar un valor decimal en un INTEGER, te dará error. Para eso usa NUMERIC o FLOAT.

Trabajando con el tipo TEXT

TEXT se usa para guardar datos de texto. Te sirve cuando necesitas trabajar con nombres, descripciones o cualquier otro texto.

Ejemplo: mostrar nombres de estudiantes

En este ejemplo vamos a mostrar los nombres de todos los estudiantes de la tabla students.

DO $$
DECLARE
    student_name TEXT; -- Variable para el nombre del estudiante
BEGIN
    FOR student_name IN SELECT name FROM students LOOP
        RAISE NOTICE 'Nombre del estudiante: %', student_name; -- Mostramos cada nombre
    END LOOP;
END;
$$;

Funciones útiles para trabajar con TEXT:

• UPPER() y LOWER() — para poner el texto en mayúsculas/minúsculas.
• CONCAT() — para unir cadenas.
• LENGTH() — para saber la longitud de una cadena.

Por ejemplo:

DO $$
DECLARE
    full_name TEXT;
BEGIN
    full_name := CONCAT('Alek', ' Min'); -- Unimos las cadenas
    RAISE NOTICE 'Nombre completo: %', UPPER(full_name); -- Mostramos el nombre en mayúsculas
END;
$$;

Trabajando con el tipo BOOLEAN

BOOLEAN sirve para guardar valores lógicos: TRUE, FALSE y NULL. Este tipo de dato es muy útil para comprobar condiciones y filtrar datos.

Ejemplo: comprobar si un estudiante está activo

Supón que tienes una tabla students con una columna is_active que indica si el estudiante está activo.

DO $$
DECLARE
    is_active BOOLEAN; -- Variable para guardar el estado de actividad
BEGIN
    SELECT is_active INTO is_active FROM students WHERE id = 1; -- Obtenemos el valor de la tabla
    IF is_active THEN
        RAISE NOTICE '¡El estudiante está activo!';
    ELSE
        RAISE NOTICE 'El estudiante NO está activo.';
    END IF;
END;
$$;

Puntos importantes al trabajar con BOOLEAN:

• Puedes usar valores lógicos directamente en condiciones IF y WHILE.
• El valor NULL en lógica se considera "indefinido", así que tenlo en cuenta al hacer comprobaciones.

Trabajando con el tipo RECORD

RECORD es un tipo de dato potente que se usa para guardar filas de datos sin una estructura definida de antemano. Es muy útil cuando trabajas con resultados de consultas SQL que devuelven varias columnas.

Ejemplo: recorrer todos los registros de una tabla

En el siguiente ejemplo recorremos todos los registros de la tabla students y mostramos el nombre y el ID de cada estudiante.

DO $$
DECLARE
    student RECORD; -- Tipo dinámico para guardar una fila de datos
BEGIN
    FOR student IN SELECT id, name FROM students LOOP
        RAISE NOTICE 'ID: %, Nombre: %', student.id, student.name; -- Accedemos a las columnas del registro
    END LOOP;
END;
$$;

Puntos importantes al trabajar con RECORD:

• Las variables de tipo RECORD solo se rellenan dentro de un bucle o usando una consulta SELECT INTO.
• Puedes acceder a las columnas usando record.nombre_columna.

Tipos de datos ROWTYPE para trabajar con tablas

Si quieres guardar un registro completo de una tabla (y además quieres tipado estricto), puedes usar el tipo ROWTYPE. Este tipo hereda automáticamente la estructura de la fila de la tabla.

Ejemplo: trabajar con el tipo ROWTYPE

DO $$
DECLARE
    student students%ROWTYPE; -- Variable con la estructura de la fila de la tabla students
BEGIN
    SELECT * INTO student FROM students WHERE id = 1; -- Cargamos los datos de la fila en la variable
    RAISE NOTICE 'Nombre del estudiante: %, Curso: %', student.name, student.course;
END;
$$;

Diferencias entre RECORD y ROWTYPE

Ejemplo práctico

Vamos a escribir una función que devuelva la cantidad de estudiantes activos y sus nombres.

CREATE FUNCTION active_students_report() RETURNS TABLE(id INT, name TEXT) AS $$
BEGIN
    RETURN QUERY
    SELECT id, name FROM students WHERE is_active = TRUE;
END;
$$ LANGUAGE plpgsql;

Llamada a la función:

SELECT * FROM active_students_report();

Errores al trabajar con tipos de datos

A veces trabajar con datos puede dar errores. Aquí tienes algunos casos típicos:

• Error de tipo: intentar guardar una cadena en una variable INTEGER (por ejemplo, my_var := 'abc';).
• Usar NULL donde se espera TRUE o FALSE.
• Usar RECORD sin inicializarlo correctamente.

Cómo evitar errores:

• Siempre declara explícitamente el tipo de las variables.
• Comprueba los tipos de datos de las columnas de las tablas antes de guardar datos.
• Usa comandos de depuración como RAISE NOTICE.

Ahora ya sabes cómo trabajar con los tipos de datos INTEGER, TEXT, BOOLEAN y RECORD en PL/pgSQL. Este conocimiento te va a permitir crear programas más complejos y potentes en el lenguaje de programación procedural de PostgreSQL.