As 20 principais perguntas e respostas para entrevistas sobre PL/SQL em 2026

PL/SQL, que é a extensão da linguagem procedural SQL da Oracle, é algo que você precisa saber se vai trabalhar com bancos de dados Oracle. Isso vale para funções importantes, como administrador de banco de dados, desenvolvedor e analista de dados, que precisam lidar com lógicas de negócios complexas dentro do banco de dados.

Acho que os entrevistadores avaliam os candidatos em três pontos principais:

• Compreensão conceitual: Princípios básicos, tipos de dados, estruturas de controle e tratamento de exceções.
• Habilidade prática de codificação: Escrever procedimentos armazenados, funções, gatilhos e pacotes eficientes.
• Considerações sobre desempenho: Otimizar o código PL/SQL pra melhorar o tempo de execução, minimizar o consumo de recursos e evitar erros como a troca excessiva de contexto entre SQL e PL/SQL.

Pra ajudar, tô mandando um guia com perguntas pra entrevista sobre PL/SQL. Vou começar com os conceitos básicos e depois passar para assuntos mais avançados, como processamento em massa, SQL dinâmico e ajuste de desempenho.

Se você quer entender os conceitos básicos do banco de dados Oracle, recomendo fazer nosso curso Introdução ao Oracle SQL, que é um recurso super importante pra aprender a interagir com o banco de dados Oracle e como ele usa PL/SQL pra processar consultas.

Perguntas para entrevistas para iniciantes em PL/SQL

Na fase inicial da entrevista, o entrevistador pode fazer perguntas básicas para avaliar seus conhecimentos sobre conceitos básicos de banco de dados e PL/SQL. Tenta estudar essas perguntas e respostas pra se preparar pra fase inicial da entrevista.

1. O que é PL/SQL?

PL/SQL é a extensão procedural da Oracle para SQL. Diferente do SQL, que é declarativo e foca na recuperação e manipulação de dados, o PL/SQL permite que os desenvolvedores implementem lógica procedural, tornando-o uma ferramenta poderosa para escrever regras de negócios complexas dentro do banco de dados. Ele suporta variáveis, loops, condicionais, tratamento de exceções e programação modular por meio de procedimentos, funções e pacotes.

2. Qual é a estrutura básica de um bloco PL/SQL?

Um bloco PL/SQL é a unidade básica de execução no PL/SQL e tem quatro partes principais:

• DECLARE (Opcional): Usado para definir variáveis, constantes, cursores e tipos definidos pelo usuário.

• BEGIN: A parte executável onde as consultas SQL e as instruções procedimentais são escritas.

• EXCEPTION (Opcional): Lida com erros de tempo de execução e exceções para garantir uma recuperação suave dos erros.

• END;: Marca o fim do bloco.

3. Quais são os tipos de dados essenciais do PL/SQL?

O PL/SQL suporta vários tipos de dados, categorizados da seguinte forma:

• Tipos escalares: Tipos de valor único como NUMBER, VARCHAR2, DATE, BOOLEAN.

• Tipos compostos: Coleções como RECORD (estruturas personalizadas) e TABLE/VARRAY (matrizes).

• Tipos de referência: Ponteiros para objetos de banco de dados, como REF CURSOR para processamento dinâmico de consultas.

4. Quais são as estruturas de controle básicas em PL/SQL?

O PL/SQL tem várias estruturas de controle que ajudam a gerenciar o fluxo de um programa:

• Loops: Isso inclui LOOP, FOR LOOP e WHILE LOOP, que permitem a execução repetitiva de instruções.

• Declarações condicionais: Isso inclui as instruções ` IF ` e ` CASE `, que executam diferentes blocos de código com base em condições. A função DECODE() é outro bom exemplo de uma condição que vale a pena estudar. 

Perguntas intermediárias sobre PL/SQL para entrevistas

Depois de falar das perguntas básicas, vamos passar para algumas perguntas de nível intermediário sobre estrutura de dados. Depois de testar seus conhecimentos básicos, os entrevistadores vão agora testar sua proficiência técnica na implementação e utilização dos conceitos PL/SQL.

5. Qual é a diferença entre procedimentos armazenados e funções?

Os procedimentos armazenados e as funções são blocos de código PL/SQL reutilizáveis, mas têm finalidades bem diferentes.

Os procedimentos armazenados são usados para fazer operações que não devolvem um valor, como inserir, atualizar ou excluir dados. São usadas para tarefas que modificam dados ou fazem operações complexas sem devolver um resultado.

Por exemplo, o procedimento abaixo atualiza o salary do funcionário com o employee_id fornecido, adicionando o p_increment especificado, de modo que o salário seja atualizado dinamicamente com base nos parâmetros de entrada.

CREATE PROCEDURE update_salary(p_emp_id NUMBER, p_increment NUMBER) AS  
BEGIN  
    -- Update the salary of the employee with the given ID  
    UPDATE employees  
    SET salary = salary + p_increment  
    WHERE employee_id = p_emp_id;  
END;

Já as funções devolvem um valor depois de fazerem as operações. São bons para cálculos ou recuperação de dados que precisam dar um resultado.

A função abaixo simplifica a obtenção do salário de um funcionário, tornando-a reutilizável em consultas SQL ou outros procedimentos.

CREATE FUNCTION get_employee_salary(p_emp_id NUMBER) RETURN NUMBER AS  
    v_salary NUMBER;  
BEGIN  
    -- Retrieve the salary for the given employee ID  
    SELECT salary INTO v_salary  
    FROM employees  
    WHERE employee_id = p_emp_id;  
    
    -- Return the retrieved salary  
    RETURN v_salary;  
END;

6. O que são pacotes PL/SQL?

Os pacotes PL/SQL são conjuntos de procedimentos, funções e variáveis relacionados que juntam o código para facilitar a organização e reutilização. Eles têm duas partes:

• Especificações da embalagem: Declara elementos públicos (procedimentos, funções, variáveis).
• Corpo da embalagem: Tem os detalhes de como implementar os procedimentos e funções declarados na especificação.

Por exemplo, a consulta abaixo cria um pacote employee_pkg que define um procedimento para aumentar o salário de um funcionário e uma função para recuperar o número total de funcionários, com suas implementações a serem fornecidas no corpo do pacote.

-- Create a package named 'employee_pkg'
CREATE PACKAGE employee_pkg AS  

    -- Procedure to increase an employee's salary by a percentage  
    PROCEDURE raise_salary(p_emp_id NUMBER, p_percent NUMBER);  

    -- Function to return the total number of employees  
    FUNCTION get_total_employees RETURN NUMBER;  

END employee_pkg;

7. O que são gatilhos PL/SQL?

Os gatilhos são blocos PL/SQL que funcionam automaticamente quando acontecem certas coisas no banco de dados, tipo inserir, atualizar ou apagar dados. Os gatilhos são usados para fazer valer as regras de negócio. Eles também são comumente usados para realizar auditorias. Eles são divididos em:

• Gatilhos no nível da linha: Execute uma vez para cada linha afetada.
• Gatilhos no nível da instrução: Execute uma vez por instrução SQL, independentemente do número de linhas afetadas.

A consulta abaixo cria um gatilho AFTER UPDATE trg_salary_audit na tabela employees que registra as alterações salariais no salary_audit table, capturando o ID do funcionário, o salário antigo e o novo, e o carimbo de data/hora da atualização.

-- Create or replace a trigger 'trg_salary_audit'
CREATE OR REPLACE TRIGGER trg_salary_audit  
AFTER UPDATE OF salary ON employees  -- Fires after salary updates in 'employees' table
FOR EACH ROW  -- Executes for each updated row
BEGIN  
    -- Inserts old and new salary details into 'salary_audit' table
    INSERT INTO salary_audit (employee_id, old_salary, new_salary, change_date)  
    VALUES (:OLD.employee_id, :OLD.salary, :NEW.salary, SYSDATE);  
END;

Dá uma olhada no nosso tutorial sobre Triggers SQL pra você estar pronto caso eles apareçam na entrevista. 

8. Quais são os métodos de tratamento de exceções no PL/SQL?

O PL/SQL oferece mecanismos de tratamento de erros para garantir a estabilidade e evitar falhas. Os tipos de exceções incluem o seguinte:

• Exceções pré-definidas: Exceções integradas como NO_DATA_FOUND, TOO_MANY_ROWS e ZERO_DIVIDE.

• Exceções definidas pelo usuário: As exceções personalizadas são declaradas usando EXCEPTION e levantadas usando RAISE.

Por exemplo, o bloco PL/SQL a seguir pega o salário de um funcionário com ID 100, gera uma exceção personalizada se o salário for menor que 1000 e lida com possíveis erros, incluindo registros de funcionários ausentes e exceções inesperadas.

DECLARE  
    v_salary NUMBER;  -- Variable to store the employee's salary  
    e_low_salary EXCEPTION;  -- Custom exception for low salary  

BEGIN  
    -- Retrieve salary of employee with ID 100  
    SELECT salary INTO v_salary FROM employees WHERE employee_id = 100;  

    -- Raise exception if salary is below 1000  
    IF v_salary < 1000 THEN  
        RAISE e_low_salary;  
    END IF;  

EXCEPTION  
    WHEN NO_DATA_FOUND THEN  -- Handle case where employee ID is not found  
        DBMS_OUTPUT.PUT_LINE('Employee not found.');  
    WHEN e_low_salary THEN  -- Handle custom low salary exception  
        DBMS_OUTPUT.PUT_LINE('Salary is below the allowed threshold.');  
    WHEN OTHERS THEN  -- Handle any other unexpected errors  
        DBMS_OUTPUT.PUT_LINE('An unexpected error occurred: ' || SQLERRM);  

END;

As melhores práticas para o tratamento de exceções incluem o seguinte:

• Esteja sempre atento a possíveis exceções.
• Use mensagens de erro que façam sentido.
• Registre exceções para auditoria.
• Mantenha o código de tratamento de exceções conciso e focado na recuperação.

9. Como você pode verificar se uma instrução UPDATE foi executada ou não?

O atributo SQL %NOTFOUND pode ser usado para ver se a instrução UPDATE conseguiu alterar algum registro. Se a última instrução SQL executada não afetou nenhuma linha, essa variável retorna um TRUE.

Por exemplo, a consulta abaixo atualiza o salário dos funcionários do departamento 10, aumentando-o em 10%, e depois verifica se alguma linha foi afetada pela instrução ` UPDATE ` usando o atributo ` %NOTFOUND `. Se nenhuma linha foi atualizada, aparece uma mensagem dizendo: “Nenhuma linha foi atualizada”. Se as linhas foram atualizadas, ele mostra o número de linhas que foram afetadas usando o atributo “ SQL%ROWCOUNT ”.

DECLARE
    -- Declare a variable to store the number of rows updated
    rows_updated INTEGER;
BEGIN
    -- Perform an UPDATE statement on the 'employees' table
    UPDATE employees
    SET salary = salary * 1.1
    WHERE department_id = 10;

    -- Check if any rows were updated by using %NOTFOUND
    IF SQL%NOTFOUND THEN
        -- If no rows were updated, print a message
        DBMS_OUTPUT.PUT_LINE('No rows were updated.');
    ELSE
        -- If rows were updated, print how many rows were affected
        rows_updated := SQL%ROWCOUNT;  -- Store the number of rows updated
        DBMS_OUTPUT.PUT_LINE(rows_updated || ' rows were updated.');
    END IF;
END;
/

Perguntas avançadas sobre PL/SQL para entrevistas

Vamos agora explorar algumas perguntas avançadas para entrevistas, caso você esteja se candidatando a um cargo mais sênior que exija mais experiência.

10. Quais são os métodos para otimizar o desempenho em PL/SQL?

Minimizar as trocas de contexto entre SQL e PL/SQL é essencial para otimizar o desempenho. Cada mudança gera uma sobrecarga, que pode deixar a execução mais lenta, principalmente quando tem muitas transições entre as duas.

11. Como você usa operações em massa pra minimizar as trocas de contexto?

O PL/SQL oferece técnicas de processamento em massa para otimizar a interação entre SQL e PL/SQL, buscando ou modificando várias linhas de uma vez só.

Por exemplo, o bloco PL/SQL abaixo pega todos os funcionários do departamento 10 usando um BULK COLLECT e em uma coleção e faz uma iteração por ela para imprimir o nome de cada funcionário, melhorando o desempenho ao minimizar as trocas de contexto entre SQL e PL/SQL.

DECLARE  
    -- Define a table-type collection based on the 'employees' table structure  
    TYPE emp_table IS TABLE OF employees%ROWTYPE;  
    v_emps emp_table;  -- Declare a variable of this type  

BEGIN  
    -- Bulk fetch employees from department 10 into the collection  
    SELECT * BULK COLLECT INTO v_emps FROM employees WHERE department_id = 10;  

    -- Loop through the collection and print employee names  
    FOR i IN 1..v_emps.COUNT LOOP  
        DBMS_OUTPUT.PUT_LINE('Employee: ' || v_emps(i).employee_name);  
    END LOOP;  

END;

Além disso, esse bloco PL/SQL usa FORALL para atualização em massa, aumentando o salário em 10% para os funcionários com os IDs 101, 102 e 103.

DECLARE  
    -- Define a table-type collection for employee IDs  
    TYPE t_emp_ids IS TABLE OF employees.employee_id%TYPE;  
    -- Initialize collection with specific employee IDs  
    v_emp_ids t_emp_ids := t_emp_ids(101, 102, 103);  

BEGIN  
    -- Bulk update salaries by 10% for specified employee IDs  
    FORALL i IN 1..v_emp_ids.COUNT  
        UPDATE employees SET salary = salary * 1.10 WHERE employee_id = v_emp_ids(i);  

END;

12. O que são SQL dinâmico e cursores de referência?

O SQL dinâmico permite executar instruções SQL de forma dinâmica em tempo de execução, o que é útil quando se lida com nomes de tabelas, colunas ou estruturas de consulta variáveis.

O bloco PL/SQL a seguir usa SQL dinâmico para contar o número de linhas na tabela ` employees ` e imprime o resultado. Gosto desse tipo de abordagem porque permite flexibilidade.

DECLARE  
    v_table_name VARCHAR2(50) := 'employees';  -- Store table name  
    v_count NUMBER;  -- Variable to hold row count  

BEGIN  
    -- Dynamically count rows in the specified table  
    EXECUTE IMMEDIATE 'SELECT COUNT(*) FROM ' || v_table_name INTO v_count;  

    -- Print the total count  
    DBMS_OUTPUT.PUT_LINE('Total Employees: ' || v_count);  

END;  

Os cursores de referência são cursores dinâmicos que podem ser abertos, buscados e fechados em tempo de execução, permitindo a passagem de resultados de consultas entre unidades de programa.

O bloco PL/SQL abaixo usa uma instrução ` REF CURSOR ` para buscar e imprimir os nomes dos funcionários do departamento 20. O cursor é aberto de forma dinâmica, iterado usando um loop e fechado após o processamento.

DECLARE  
    -- Define a REF CURSOR type  
    TYPE emp_ref_cursor IS REF CURSOR;  
    v_cursor emp_ref_cursor;  -- Declare a cursor variable  
    v_name employees.employee_name%TYPE;  -- Variable to store employee name  

BEGIN  
    -- Open the cursor for employees in department 20  
    OPEN v_cursor FOR SELECT employee_name FROM employees WHERE department_id = 20;  

    -- Fetch and print employee names in a loop  
    LOOP  
        FETCH v_cursor INTO v_name;  
        EXIT WHEN v_cursor%NOTFOUND;  
        DBMS_OUTPUT.PUT_LINE('Employee: ' || v_name);  
    END LOOP;  

    -- Close the cursor  
    CLOSE v_cursor;  

END;

13. Como você lida com erros de mutação de tabelas?

Erros de mutação de tabela acontecem quando um gatilho tenta mexer na tabela em que ele foi acionado. Um gatilho composto permite dividir a execução do gatilho em várias fases, como BEFORE, AFTER e FOR EACH ROW, para evitar problemas de modificação direta.

O gatilho composto abaixo registra as alterações salariais na tabela salary_audit de forma eficiente, coletando dados antes de cada atualização de linha e fazendo uma inserção em massa após a instrução, reduzindo as trocas de contexto e melhorando o desempenho.

CREATE OR REPLACE TRIGGER trg_salary_audit  
FOR UPDATE OF salary ON employees  -- Trigger fires on salary updates  
COMPOUND TRIGGER  

    -- Declare an associative array to store audit records  
    TYPE t_salary_audit IS TABLE OF salary_audit%ROWTYPE INDEX BY PLS_INTEGER;  
    v_audit_data t_salary_audit;  
    v_idx PLS_INTEGER := 0;  

    -- Before updating each row, store old and new salary details  
    BEFORE EACH ROW IS  
    BEGIN  
        v_idx := v_idx + 1;  
        v_audit_data(v_idx).employee_id := :OLD.employee_id;  
        v_audit_data(v_idx).old_salary := :OLD.salary;  
        v_audit_data(v_idx).new_salary := :NEW.salary;  
        v_audit_data(v_idx).change_date := SYSDATE;  
    END BEFORE EACH ROW;  

    -- After the statement, insert all audit records in bulk  
    AFTER STATEMENT IS  
    BEGIN  
        FORALL i IN 1..v_idx  
            INSERT INTO salary_audit VALUES v_audit_data(i);  
    END AFTER STATEMENT;  

END trg_salary_audit;

14. O que é sobrecarga em PL/SQL?

A sobrecarga permite que vários procedimentos ou funções com o mesmo nome, mas parâmetros diferentes, sejam definidos dentro de um pacote. Isso melhora a legibilidade e a manutenção do código, oferecendo várias maneiras de fazer operações parecidas.

Na consulta abaixo, o corpo do pacote implementa dois procedimentos sobrecarregados chamados ` update_salary`: Um aumenta o salário de um funcionário em um valor específico, enquanto o outro define um novo salário com uma data de vigência, atualizando a tabela employees de acordo.

-- Create the package specification
CREATE OR REPLACE PACKAGE emp_pkg AS  
    -- Procedure to increment salary by a specified amount  
    PROCEDURE update_salary(p_emp_id NUMBER, p_increment NUMBER);

    -- Overloaded procedure to set a new salary with an effective date  
    PROCEDURE update_salary(p_emp_id NUMBER, p_new_salary NUMBER, p_effective_date DATE);
END emp_pkg;
/

-- Create the package body
CREATE OR REPLACE PACKAGE BODY emp_pkg AS  

    -- Procedure to increment salary by a specified amount  
    PROCEDURE update_salary(p_emp_id NUMBER, p_increment NUMBER) AS  
    BEGIN  
        UPDATE employees  
        SET salary = salary + p_increment  
        WHERE employee_id = p_emp_id;  
    END update_salary;  

    -- Overloaded procedure to set a new salary with an effective date  
    PROCEDURE update_salary(p_emp_id NUMBER, p_new_salary NUMBER, p_effective_date DATE) AS  
    BEGIN  
        UPDATE employees  
        SET salary = p_new_salary, last_update = p_effective_date  
        WHERE employee_id = p_emp_id;  
    END update_salary;  

END emp_pkg;
/

15. O que são as diretivas do compilador e pragmas em PL/SQL?

O PL/SQL tem diretivas de compilador (PRAGMA) pra otimizar o código e lidar com exceções. Os pragmas comuns incluem:

• PRAGMA EXCEPTION_INIT: Associa uma exceção definida pelo usuário a um código de erro Oracle.

• PRAGMA SERIALLY_REUSABLE: Otimiza o uso da memória do pacote para escalabilidade.

O bloco PL/SQL abaixo lida com a inserção de um funcionário com um salário inválido usando uma exceção personalizada e_invalid_salary mapeada para o código de erro -20001. Se a exceção for levantada, ela vai mostrar uma mensagem de erro.

DECLARE  
    e_invalid_salary EXCEPTION;  -- Declare custom exception for invalid salary  
    PRAGMA EXCEPTION_INIT(e_invalid_salary, -20001);  -- Associate exception with error code -20001  
BEGIN  
    -- Attempt to insert an employee with invalid salary  
    INSERT INTO employees (employee_id, salary) VALUES (999, -1000);  
EXCEPTION  
    -- Handle the custom exception and print a message  
    WHEN e_invalid_salary THEN  
        DBMS_OUTPUT.PUT_LINE('Invalid salary detected!');  
END;  

16. Quais são os diferentes métodos para rastrear e depurar código PL/SQL?

O PL/SQL oferece vários pacotes integrados para rastrear e depurar o desempenho do código. Os métodos comuns incluem o uso de DBMS_TRACE para rastrear o fluxo de execução, DBMS_APPLICATION_INFO para monitorar a atividade da sessão e DBMS_SESSION para coletar informações de diagnóstico no nível da sessão.

A consulta abaixo primeiro habilita o rastreamento SQL usando DBMS_SESSION.set_sql_trace(TRUE) e, em seguida, define informações de sessão específicas do cliente com DBMS_APPLICATION_INFO.set_client_info() para monitoramento. O bloco PL/SQL é executado, simulando uma operação de UPDATE. Por fim, desativa o rastreamento após a execução usando DBMS_SESSION.set_sql_trace(FALSE).

-- Enable tracing for the current session using DBMS_SESSION
BEGIN
   -- Start session-level tracing
   DBMS_SESSION.set_sql_trace(TRUE);
END;
/

-- Set application information using DBMS_APPLICATION_INFO
BEGIN
   -- Set the application name and action for session monitoring
   DBMS_APPLICATION_INFO.set_client_info('Trace Debug Session');
   DBMS_APPLICATION_INFO.set_action('Debugging PL/SQL Code');
END;
/

-- Example PL/SQL block that simulates a process for debugging
DECLARE
   v_employee_id NUMBER := 100;
BEGIN
   -- Example query to fetch employee details
   FOR rec IN (SELECT first_name, last_name FROM employees WHERE employee_id = v_employee_id) LOOP
      DBMS_OUTPUT.put_line('Employee: ' || rec.first_name || ' ' || rec.last_name);
   END LOOP;
   
   -- Simulate some logic that could be traced
   IF v_employee_id = 100 THEN
      DBMS_OUTPUT.put_line('Employee ID is 100');
   END IF;
END;
/

-- Disable tracing after the session is complete
BEGIN
   -- Stop session-level tracing
   DBMS_SESSION.set_sql_trace(FALSE);
END;
/

Perguntas de entrevista sobre PL/SQL baseadas em cenários

Em aplicações empresariais reais, o PL/SQL é usado para lidar com lógicas de negócios complexas. Os entrevistadores costumam avaliar a capacidade do candidato de usar PL/SQL em situações reais. Abaixo estão alguns dos principais desafios, junto com estratégias para resolvê-los.

Nesta próxima e última seção, se você estiver em uma entrevista, recomendo que pense em como responder às perguntas seguindo este modelo, mas tente, é claro, reorientar sua resposta para o seu setor específico ou para refletir sua própria experiência. O mesmo vale se você estiver entrevistando um candidato e quiser ideias sobre como fazer uma pergunta e avaliar a profundidade da resposta. Nesse caso, espero que esta seção sirva de inspiração tanto para suas perguntas quanto para seus critérios de avaliação.