Las 20 mejores preguntas y respuestas de entrevistas PL/SQL en 2025

PL/SQL, que es la extensión del lenguaje procedimental SQL de Oracle, es algo que debes conocer si vas a trabajar con bases de datos Oracle. Esto es cierto para funciones importantes como administrador de base de datos, desarrollador y analista de datos, todos los cuales necesitan manejar una lógica empresarial compleja dentro de la base de datos.

Creo que los entrevistadores evalúan a los candidatos en tres aspectos clave:

• Comprensión conceptual: Principios básicos, tipos de datos, estructuras de control y tratamiento de excepciones.
• Habilidad Práctica de Codificación: Escribir procedimientos almacenados, funciones, desencadenadores y paquetes eficaces.
• Consideraciones sobre el rendimiento: Optimizar el código PL/SQL para mejorar el tiempo de ejecución, minimizar el consumo de recursos y evitar errores como el cambio excesivo de contexto entre SQL y PL/SQL.

Para ayudarte, te proporciono una guía sobre preguntas de entrevista PL/SQL. Empezaré con los conceptos fundamentales y avanzaré hacia temas más avanzados como el procesamiento masivo, el SQL dinámico y el ajuste del rendimiento.

Si quieres comprender los conceptos fundamentales de la base de datos Oracle, te recomiendo que sigas nuestro curso Introducción a Oracle SQL, que es un recurso realmente importante para aprender a interactuar con la base de datos Oracle y cómo la base de datos utiliza PL/SQL para procesar las consultas.

Preguntas de la entrevista PL/SQL para principiantes

En la fase inicial de la entrevista, el entrevistador puede hacerte preguntas fundamentales para evaluar tus conocimientos sobre conceptos básicos de bases de datos y PL/SQL. Intenta estudiar estas preguntas y respuestas para prepararte para la fase inicial de la entrevista.

1. ¿Qué es PL/SQL?

PL/SQL es la extensión procedimental de Oracle para SQL. A diferencia de SQL, que es declarativo y se centra en la recuperación y manipulación de datos, PL/SQL permite a los desarrolladores implementar lógica procedimental, lo que lo convierte en una potente herramienta para escribir reglas empresariales complejas dentro de la base de datos. Admite variables, bucles, condicionales, manejo de excepciones y programación modular mediante procedimientos, funciones y paquetes.

2. ¿Cuál es la estructura básica de un bloque PL/SQL?

Un bloque PL/SQL es la unidad fundamental de ejecución en PL/SQL, y consta de cuatro secciones principales:

• DECLARE (Opcional): Se utiliza para definir variables, constantes, cursores y tipos definidos por el usuario.

• BEGIN: La sección ejecutable donde se escriben las consultas SQL y las sentencias procedimentales.

• EXCEPTION (Opcional): Gestiona los errores y excepciones en tiempo de ejecución para garantizar una recuperación de errores ágil.

• END;: Marca el final del bloque.

3. ¿Cuáles son los tipos de datos PL/SQL esenciales?

PL/SQL admite varios tipos de datos, clasificados como sigue:

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

• Tipos de compuestos: Colecciones como RECORD (estructuras personalizadas) y TABLE/VARRAY (matrices).

• Tipos de referencia: Punteros a objetos de la base de datos, como REF CURSOR para el procesamiento dinámico de consultas.

4. ¿Cuáles son las estructuras de control básicas en PL/SQL?

PL/SQL incluye varias estructuras de control que ayudan a gestionar el flujo de un programa:

• Bucles: Entre ellas están LOOP, FOR LOOP, y WHILE LOOP, que permiten la ejecución repetitiva de sentencias.

• Declaraciones condicionales: Entre ellas están las sentencias IF y CASE, que ejecutan diferentes bloques de código en función de las condiciones. La función DECODE( ) es otro buen ejemplo de condicional que merece la pena estudiar. 

Preguntas de la entrevista PL/SQL intermedio

Una vez cubiertas las preguntas básicas, pasemos ahora a algunas preguntas de nivel intermedio de la entrevista sobre estructura de datos. Después de comprobar tus conocimientos básicos, los entrevistadores van a comprobar ahora tu competencia técnica en la aplicación y el uso de conceptos PL/SQL.

5. ¿Cuál es la diferencia entre procedimientos almacenados y funciones?

Tanto los procedimientos almacenados como las funciones son bloques de código PL/SQL reutilizables, pero tienen finalidades bastante distintas.

Los procedimientos almacenados se utilizan para realizar operaciones que no devuelven un valor, como insertar, actualizar o eliminar datos. Se utilizan para tareas que modifican datos o realizan operaciones complejas sin devolver un resultado.

Por ejemplo, el procedimiento siguiente actualiza el salary del empleado con el employee_id dado añadiendo el p_increment especificado, de forma que el salario se actualice dinámicamente en función de los 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;

Las funciones, en cambio, devuelven un valor tras realizar operaciones. Son adecuados para cálculos o recuperación de datos que necesitan devolver un resultado.

La siguiente función simplifica la obtención del salario de un empleado, haciéndola reutilizable en consultas SQL u otros procedimientos.

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. ¿Qué son los paquetes PL/SQL?

Los paquetes PL/SQL son colecciones de procedimientos, funciones y variables relacionados que encapsulan el código para una mejor organización y reutilización. Constan de dos partes:

• Especificaciones del paquete: Declara elementos públicos (procedimientos, funciones, variables).
• Cuerpo del paquete: Contiene los detalles de implementación de los procedimientos y funciones declarados en la especificación.

Por ejemplo, la consulta siguiente crea un paquete employee_pkg que define un procedimiento para aumentar el salario de un empleado y una función para recuperar el número total de empleados, cuyas implementaciones se proporcionarán en el cuerpo del paquete.

-- 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. ¿Qué son los disparadores PL/SQL?

Los activadores son bloques PL/SQL que se ejecutan automáticamente en respuesta a eventos específicos de la base de datos, como inserciones, actualizaciones o eliminaciones. Los desencadenantes se utilizan para aplicar reglas de negocio. También se utilizan habitualmente para realizar auditorías. Se clasifican en:

• Desencadenantes a nivel de fila: Ejecutar una vez por cada fila afectada.
• Activadores a nivel de declaración: Ejecutar una vez por sentencia SQL, independientemente del número de filas afectadas.

La siguiente consulta crea un disparador AFTER UPDATE trg_salary_audit en la tabla employees que registra los cambios de salario en salary_audit table, capturando el ID del empleado, el salario antiguo y el nuevo, y la marca de tiempo de actualización.

-- 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;

Estudia nuestro tutorial sobre Triggers SQL para estar preparado en caso de que saquen el tema de los triggers en la entrevista. 

8. ¿Cuáles son los métodos de gestión de excepciones en PL/SQL?

PL/SQL proporciona mecanismos de gestión de errores para la estabilidad y para evitar fallos. Los tipos de excepciones son los siguientes:

• Excepciones predefinidas: Excepciones incorporadas como NO_DATA_FOUND, TOO_MANY_ROWS, y ZERO_DIVIDE.

• Excepciones definidas por el usuario: Las excepciones personalizadas se declaran con EXCEPTION y se plantean con RAISE.

Por ejemplo, el siguiente bloque PL/SQL recupera el salario de un empleado con ID 100, lanza una excepción personalizada si el salario es inferior a 1000 y gestiona los posibles errores, incluidos los registros de empleados que falten y las excepciones 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;

Las mejores prácticas para la gestión de excepciones incluyen lo siguiente:

• Prevé siempre posibles excepciones.
• Utiliza mensajes de error significativos.
• Registra las excepciones para la auditoría.
• Mantén el código de gestión de excepciones conciso y centrado en la recuperación.

9. ¿Cómo puedes verificar si una sentencia UPDATE se ejecuta o no?

El atributo SQL %NOTFOUND puede utilizarse para determinar si la sentencia UPDATE modificó o no con éxito algún registro. Si la última sentencia SQL ejecutada no afectó a ninguna fila, esta variable devuelve TRUE.

Por ejemplo, la siguiente consulta actualiza el salario de los empleados del departamento 10 aumentándolo un 10%, y luego comprueba si alguna fila se ha visto afectada por la sentencia UPDATE utilizando el atributo %NOTFOUND. Si no se actualizó ninguna fila, muestra un mensaje que dice: "No se actualizó ninguna fila". Si se actualizaron filas, indica el número de filas afectadas mediante el 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;
/

Preguntas avanzadas de la entrevista PL/SQL

Exploremos ahora algunas preguntas avanzadas de la entrevista en caso de que solicites un puesto más alto que requiera más experiencia.

10. ¿Cuáles son los métodos para optimizar el rendimiento en PL/SQL?

Minimizar los cambios de contexto entre SQL y PL/SQL es crucial para optimizar el rendimiento. Cada conmutador incurre en una sobrecarga, que puede ralentizar los tiempos de ejecución, especialmente en situaciones que implican transiciones frecuentes entre ambos.

11. ¿Cómo utilizas las operaciones masivas para minimizar los cambios de contexto?

PL/SQL proporciona técnicas de procesamiento masivo para optimizar la interacción SQL-PL/SQL mediante la obtención o modificación de varias filas a la vez.

Por ejemplo, el bloque PL/SQL siguiente recupera todos los empleados del departamento 10 mediante BULK COLLECT en una colección e itera a través de ella para imprimir el nombre de cada empleado, mejorando el rendimiento al minimizar los cambios de contexto entre SQL y 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;

Además, este bloque PL/SQL utiliza FORALL para la actualización masiva, aumentando el salario en un 10% para los empleados con ID 101, 102 y 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. ¿Qué son el SQL dinámico y los cursores de referencia?

El SQL Dinámico permite ejecutar sentencias SQL dinámicamente en tiempo de ejecución, lo que resulta útil cuando se trabaja con nombres de tablas, columnas o estructuras de consulta variables.

El siguiente bloque PL/SQL utiliza SQL dinámico para contar el número de filas de la tabla employees e imprime el resultado. Me gusta este tipo de enfoque porque permite flexibilidad.

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;  

Los cursores de referencia son cursores dinámicos que pueden abrirse, obtenerse y cerrarse en tiempo de ejecución, permitiendo el paso de resultados de consulta entre unidades de programa.

El bloque PL/SQL siguiente utiliza un REF CURSOR para obtener e imprimir los nombres de los empleados del departamento 20. El cursor se abre dinámicamente, se itera mediante un bucle y se cierra después de procesarlo.

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. ¿Cómo se gestionan los errores de la tabla mutante?

Los errores de mutación de tabla se producen cuando un disparador intenta modificar la tabla sobre la que se dispara. Un disparador compuesto permite dividir la ejecución del disparador en varias fases, como BEFORE, AFTER y FOR EACH ROW, para evitar problemas de modificación directa.

El desencadenador compuesto que se muestra a continuación registra los cambios salariales en la tabla salary_audit de forma eficiente, recogiendo datos antes de cada actualización de fila y realizando una inserción masiva después de la sentencia, reduciendo los cambios de contexto y mejorando el rendimiento.

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. ¿Qué es la sobrecarga en PL/SQL?

La sobrecarga permite definir dentro de un paquete varios procedimientos o funciones con el mismo nombre pero diferentes parámetros. Esto mejora la legibilidad y la mantenibilidad del código al proporcionar múltiples formas de realizar operaciones similares.

En la siguiente consulta, el cuerpo del paquete implementa dos procedimientos sobrecargados llamados update_salary: Una aumenta el salario de un empleado en una cantidad determinada, mientras que la otra establece un nuevo salario con una fecha de entrada en vigor, actualizando la tabla employees en consecuencia.

-- 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. ¿Qué son las directivas del compilador y los pragmas en PL/SQL?

PL/SQL proporciona directivas del compilador (PRAGMA) para optimizar el código y gestionar las excepciones. Los pragmas habituales son

• PRAGMA EXCEPTION_INIT: Asocia una excepción definida por el usuario con un código de error de Oracle.

• PRAGMA SERIALLY_REUSABLE: Optimiza el uso de la memoria del paquete para que sea escalable.

El siguiente bloque PL/SQL gestiona la inserción de un empleado con un salario no válido utilizando una excepción personalizada e_invalid_salary asignada al código de error -20001. Si se produce una excepción, imprime un mensaje de error.

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. ¿Cuáles son los distintos métodos para rastrear y depurar código PL/SQL?

PL/SQL proporciona varios paquetes incorporados para rastrear y depurar el rendimiento del código. Entre los métodos habituales se incluyen el uso de DBMS_TRACE para realizar un seguimiento del flujo de ejecución, DBMS_APPLICATION_INFO para controlar la actividad de la sesión y DBMS_SESSION para recopilar información de diagnóstico a nivel de sesión.

La siguiente consulta habilita primero el rastreo SQL mediante DBMS_SESSION.set_sql_trace(TRUE), y luego establece la información de sesión específica del cliente con DBMS_APPLICATION_INFO.set_client_info() para su supervisión. Se ejecuta el bloque PL/SQL, que simula una operación UPDATE. Por último, desactiva el rastreo tras la ejecución utilizando 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;
/

Preguntas de la entrevista PL/SQL basadas en escenarios

En las aplicaciones empresariales del mundo real, PL/SQL se utiliza para manejar lógica empresarial compleja. Los entrevistadores suelen evaluar la capacidad de un candidato para aplicar PL/SQL en escenarios prácticos. A continuación se presentan algunos retos clave, junto con estrategias para resolverlos.

Para esta siguiente y última sección, si te están entrevistando, te animo a que pienses en cómo responder a las preguntas siguiendo esta plantilla, pero intenta, por supuesto, reorientar tu respuesta para tu sector específico o para reflejar tu propia experiencia. Lo mismo ocurre si estás entrevistando a un candidato y quieres ideas sobre cómo formular una pregunta y juzgar lo exhaustiva que es la respuesta, en cuyo caso espero que esta sección te sirva de inspiración tanto para tus preguntas como para tus criterios de evaluación.