Tipos de dados e como usar no PL/pgSQL: INTEGER, TEXT, BOOLEAN, RECORD

Nessa aula a gente vai ver quais tipos de dados são suportados no PL/pgSQL e como trabalhar com eles de forma eficiente. O foco vai ser em quatro tipos principais:

• INTEGER pra trabalhar com números.
• TEXT pra manipular strings.
• BOOLEAN pra lidar com valores lógicos.
• RECORD pra trabalhar com estruturas de dados dinâmicas.

Vamos ver cada tipo desses com exemplos, pra tu sacar como usar na prática.

Tipos de dados suportados no PL/pgSQL

O PL/pgSQL suporta todos os tipos de dados que tu já viu no PostgreSQL. Desde os numéricos simples (INTEGER, NUMERIC) até os mais avançados, tipo arrays e JSONB. Bora dar uma passada nos principais.

1. Tipos primitivos:

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

2. Tipos complexos:

   • RECORD — pra trabalhar com conjuntos de dados dinâmicos.
   • ROWTYPE — pra lidar com tipos de linha de tabela.
   • Arrays e JSON — a gente vai ver mais pra frente no curso.

Trabalhando com o tipo INTEGER

INTEGER é um dos tipos mais usados. Ele serve pra guardar números inteiros. No PL/pgSQL tu pode usar esse tipo pra fazer cálculos, trabalhar com IDs de registros e checar condições.

Exemplo: contando o número de registros

Imagina que a gente tem uma tabela students e quer saber quantos estudantes tem cadastrados no banco.

DO $$
DECLARE
    total_students INTEGER; -- Variável pra guardar a quantidade de estudantes
BEGIN
    SELECT COUNT(*) INTO total_students FROM students; -- Salva o resultado da query na variável
    RAISE NOTICE 'Quantidade de estudantes: %', total_students; -- Mostra a mensagem
END;
$$;

Pontos importantes ao usar INTEGER:

• No PL/pgSQL, pra atribuir valor pra variável, usa a palavra-chave INTO.
• Se tu tentar guardar um valor decimal num INTEGER, vai dar erro. Pra isso, usa NUMERIC ou FLOAT.

Trabalhando com o tipo TEXT

TEXT serve pra guardar dados em formato de string. Ele é útil quando tu precisa lidar com nomes, descrições ou qualquer outro texto.

Exemplo: mostrando nomes dos estudantes

Nesse exemplo, a gente vai mostrar o nome de todos os estudantes da tabela students.

DO $$
DECLARE
    student_name TEXT; -- Variável pro nome do estudante
BEGIN
    FOR student_name IN SELECT name FROM students LOOP
        RAISE NOTICE 'Nome do estudante: %', student_name; -- Mostra cada nome
    END LOOP;
END;
$$;

Funções úteis pra trabalhar com TEXT:

• UPPER() e LOWER() — transforma pra maiúsculo/minúsculo.
• CONCAT() — junta strings.
• LENGTH() — tamanho da string.

Por exemplo:

DO $$
DECLARE
    full_name TEXT;
BEGIN
    full_name := CONCAT('Alex', ' Min'); -- Junta as strings
    RAISE NOTICE 'Nome completo: %', UPPER(full_name); -- Mostra o nome em maiúsculo
END;
$$;

Trabalhando com o tipo BOOLEAN

BOOLEAN serve pra guardar valores lógicos: TRUE, FALSE e NULL. Esse tipo é muito útil pra checar condições e filtrar dados.

Exemplo: checando se o estudante está ativo

Imagina que tu tem uma tabela students com a coluna is_active, que mostra se o estudante tá ativo.

DO $$
DECLARE
    is_active BOOLEAN; -- Variável pra guardar o valor de ativo
BEGIN
    SELECT is_active INTO is_active FROM students WHERE id = 1; -- Pega o valor da tabela
    IF is_active THEN
        RAISE NOTICE 'Estudante está ativo!';
    ELSE
        RAISE NOTICE 'Estudante NÃO está ativo.';
    END IF;
END;
$$;

Pontos importantes ao usar BOOLEAN:

• Tu pode usar valores lógicos direto nas condições IF e WHILE.
• O valor NULL é considerado "indefinido" na lógica, então fica ligado nisso nas checagens.

Trabalhando com o tipo RECORD

RECORD é um tipo poderoso, usado pra guardar linhas de dados sem estrutura definida antes. Ele é ótimo quando tu trabalha com resultados de queries SQL que retornam várias colunas.

Exemplo: percorrendo todos os registros da tabela

No exemplo abaixo, a gente percorre todos os registros da tabela students e mostra o nome e o ID de cada estudante.

DO $$
DECLARE
    student RECORD; -- Tipo dinâmico pra guardar a linha de dados
BEGIN
    FOR student IN SELECT id, name FROM students LOOP
        RAISE NOTICE 'ID: %, Nome: %', student.id, student.name; -- Acessa as colunas do registro
    END LOOP;
END;
$$;

Pontos importantes ao usar RECORD:

• Variáveis do tipo RECORD só são preenchidas dentro do loop ou usando SELECT INTO.
• Pra acessar as colunas, usa record.nome_coluna.

Tipos de dados ROWTYPE pra trabalhar com tabelas

Se tu quiser guardar um registro inteiro de uma tabela (e ainda ter tipagem certinha), pode usar o tipo ROWTYPE. Ele pega automaticamente a estrutura da linha da tabela.

Exemplo: usando o tipo ROWTYPE

DO $$
DECLARE
    student students%ROWTYPE; -- Variável com a estrutura da linha da tabela students
BEGIN
    SELECT * INTO student FROM students WHERE id = 1; -- Carrega os dados da linha na variável
    RAISE NOTICE 'Nome do estudante: %, Curso: %', student.name, student.course;
END;
$$;

Diferenças entre RECORD e ROWTYPE

Exemplo prático

Bora criar uma função que retorna a quantidade de estudantes ativos e os nomes deles.

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;

Chamando a função:

SELECT * FROM active_students_report();

Erros ao trabalhar com tipos de dados

Às vezes rolam uns erros quando tu mexe com dados. Olha só alguns casos comuns:

• Erro de tipo: tentar colocar uma string numa variável INTEGER (tipo my_var := 'abc';).
• Usar NULL onde espera TRUE ou FALSE.
• Usar RECORD sem inicializar direito.

Como evitar esses erros:

• Sempre define o tipo das variáveis de forma explícita.
• Confere os tipos das colunas nas tabelas antes de gravar.
• Usa comandos de debug, tipo RAISE NOTICE.

Agora tu já sabe como trabalhar com os tipos INTEGER, TEXT, BOOLEAN e RECORD no PL/pgSQL. Com isso, dá pra criar programas bem mais complexos e potentes usando a linguagem procedural do PostgreSQL.