Die 20 besten PL/SQL-Interview-Fragen und Antworten im Jahr 2025

PL/SQL, die prozedurale Erweiterung von SQL durch Oracle, musst du kennen, wenn du mit Oracle-Datenbanken arbeitest. Das gilt für wichtige Rollen wie Datenbankadministratoren, Entwickler und Datenanalysten, die alle komplexe Geschäftslogik in der Datenbank verarbeiten müssen.

Ich glaube, dass Interviewer die Bewerber nach drei wichtigen Aspekten beurteilen:

• Konzeptuelles Verständnis: Grundprinzipien, Datentypen, Kontrollstrukturen und Ausnahmebehandlung.
• Praktische Kodierfähigkeiten: Effiziente gespeicherte Prozeduren, Funktionen, Trigger und Pakete schreiben.
• Überlegungen zur Leistung: Optimieren von PL/SQL-Code, um die Ausführungszeit zu verbessern, den Ressourcenverbrauch zu minimieren und Fehler wie übermäßige Kontextwechsel zwischen SQL und PL/SQL zu vermeiden.

Um dir dabei zu helfen, stelle ich dir einen Leitfaden für PL/SQL-Interviewfragen zur Verfügung. Ich beginne mit den grundlegenden Konzepten und gehe dann zu fortgeschritteneren Themen wie Massenverarbeitung, dynamisches SQL und Leistungsoptimierung über.

Wenn du die grundlegenden Konzepte der Oracle-Datenbank verstehen willst, empfehle ich dir unseren Kurs Einführung in Oracle SQL, in dem du lernst, wie man mit der Oracle-Datenbank interagiert und wie die Datenbank PL/SQL zur Verarbeitung von Abfragen verwendet.

PL/SQL-Interview-Fragen für Anfänger

In der ersten Interviewphase kann der Interviewer grundlegende Fragen stellen, um dein Wissen über grundlegende Datenbank- und PL/SQL-Konzepte zu beurteilen. Studiere diese Fragen und Antworten, um dich auf die erste Phase des Vorstellungsgesprächs vorzubereiten.

1. Was ist PL/SQL?

PL/SQL ist die prozedurale Erweiterung von SQL durch Oracle. Im Gegensatz zu SQL, das deklarativ ist und sich auf die Abfrage und Bearbeitung von Daten konzentriert, können Entwickler mit PL/SQL prozedurale Logik implementieren, was es zu einem leistungsstarken Werkzeug für das Schreiben komplexer Geschäftsregeln innerhalb der Datenbank macht. Sie unterstützt Variablen, Schleifen, Bedingungen, Ausnahmebehandlung und modulare Programmierung durch Prozeduren, Funktionen und Pakete.

2. Wie ist die Grundstruktur eines PL/SQL-Blocks?

Ein PL/SQL-Block ist die grundlegende Ausführungseinheit in PL/SQL und besteht aus vier Hauptabschnitten:

• DECLARE (Optional): Dient zur Definition von Variablen, Konstanten, Cursorn und benutzerdefinierten Typen.

• BEGIN: Der ausführbare Teil, in dem SQL-Abfragen und prozedurale Anweisungen geschrieben werden.

• EXCEPTION (Optional): Behandelt Laufzeitfehler und Ausnahmen, um eine sichere Fehlerbehebung zu gewährleisten.

• END;: Markiert das Ende des Blocks.

3. Was sind die wichtigsten PL/SQL-Datentypen?

PL/SQL unterstützt verschiedene Datentypen, die wie folgt kategorisiert sind:

• Skalare Typen: Einwertige Typen wie NUMBER, VARCHAR2, DATE, BOOLEAN.

• Komposit-Typen: Sammlungen wie RECORD (eigene Strukturen) und TABLE/VARRAY (Arrays).

• Referenztypen: Zeiger auf Datenbankobjekte, wie REF CURSOR für die dynamische Abfrageverarbeitung.

4. Was sind die grundlegenden Kontrollstrukturen in PL/SQL?

PL/SQL enthält mehrere Kontrollstrukturen, die dabei helfen, den Ablauf eines Programms zu steuern:

• Loops: Dazu gehören LOOP, FOR LOOP und WHILE LOOP, die eine wiederholte Ausführung von Anweisungen ermöglichen.

• Bedingte Anweisungen: Dazu gehören die Anweisungen IF und CASE, die je nach Bedingung verschiedene Codeblöcke ausführen. Die Funktion DECODE() ist ein weiteres gutes Beispiel für eine Bedingung, die es wert ist, studiert zu werden. 

PL/SQL-Interview-Fragen für Fortgeschrittene

Nachdem wir uns mit den grundlegenden Fragen beschäftigt haben, kommen wir nun zu den Fragen zu Datenstrukturen auf mittlerem Niveau. Nachdem dein Grundwissen geprüft wurde, testen die Interviewer nun deine technischen Fähigkeiten bei der Implementierung und Anwendung von PL/SQL-Konzepten.

5. Was ist der Unterschied zwischen Stored Procedures und Funktionen?

Stored Procedures und Funktionen sind beides wiederverwendbare PL/SQL-Codeblöcke, aber sie dienen ganz unterschiedlichen Zwecken.

Stored Procedures werden verwendet, um Operationen durchzuführen, die keinen Wert zurückgeben, wie z.B. das Einfügen, Aktualisieren oder Löschen von Daten. Sie werden für Aufgaben verwendet, die Daten verändern oder komplexe Operationen durchführen, ohne ein Ergebnis zurückzugeben.

Die folgende Prozedur aktualisiert zum Beispiel die salary des Mitarbeiters mit der angegebenen employee_id, indem sie die angegebene p_increment hinzufügt, so dass das Gehalt dynamisch auf der Grundlage der Eingabeparameter aktualisiert wird,

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;

Funktionen hingegen geben nach der Durchführung von Operationen einen Wert zurück. Sie eignen sich für Berechnungen oder Datenabfragen, die ein Ergebnis liefern müssen.

Die folgende Funktion vereinfacht das Abrufen des Gehalts eines Mitarbeiters und kann in SQL-Abfragen oder anderen Prozeduren wiederverwendet werden.

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. Was sind PL/SQL-Pakete?

PL/SQL-Pakete sind Sammlungen zusammengehöriger Prozeduren, Funktionen und Variablen, die den Code zur besseren Organisation und Wiederverwendbarkeit kapseln. Sie bestehen aus zwei Teilen:

• Verpackungsspezifikation: Deklariert öffentliche Elemente (Prozeduren, Funktionen, Variablen).
• Paketkörper: Enthält die Implementierungsdetails der in der Spezifikation angegebenen Verfahren und Funktionen.

Die folgende Abfrage erstellt zum Beispiel ein Paket employee_pkg, das eine Prozedur zum Erhöhen des Gehalts eines Mitarbeiters und eine Funktion zum Abrufen der Gesamtzahl der Mitarbeiter definiert, deren Implementierungen im Paketkörper bereitgestellt werden.

-- 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. Was sind PL/SQL-Trigger?

Trigger sind PL/SQL-Blöcke, die automatisch als Reaktion auf bestimmte Datenbankereignisse, wie z.B. Einfügungen, Aktualisierungen oder Löschungen, ausgeführt werden. Auslöser werden verwendet, um Geschäftsregeln durchzusetzen. Sie werden auch häufig zur Durchführung von Prüfungen verwendet. Sie werden in folgende Kategorien eingeteilt:

• Auslöser auf Zeilenebene: Einmal für jede betroffene Zeile ausführen.
• Auslöser auf Statement-Ebene: Wird einmal pro SQL-Anweisung ausgeführt, unabhängig von der Anzahl der betroffenen Zeilen.

Die folgende Abfrage erstellt einen AFTER UPDATE Trigger trg_salary_audit für die Tabelle employees, der Gehaltsänderungen in der Tabelle salary_audit table protokolliert und dabei die Mitarbeiter-ID, das alte und das neue Gehalt sowie den Zeitstempel der Aktualisierung erfasst.

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

Lies unser Tutorial über SQL-Trigger, damit du für den Fall, dass Trigger im Vorstellungsgespräch angesprochen werden, vorbereitet bist. 

8. Welche Methoden der Ausnahmebehandlung gibt es in PL/SQL?

PL/SQL bietet Mechanismen zur Fehlerbehandlung, um Stabilität zu gewährleisten und Abstürze zu verhindern. Zu den Arten von Ausnahmen gehören die folgenden:

• Vordefinierte Ausnahmen: Eingebaute Ausnahmen wie NO_DATA_FOUND, TOO_MANY_ROWS, und ZERO_DIVIDE.

• Benutzerdefinierte Ausnahmen: Benutzerdefinierte Ausnahmen werden mit EXCEPTION deklariert und mit RAISE ausgelöst.

Der folgende PL/SQL-Block ruft zum Beispiel das Gehalt eines Mitarbeiters mit der ID 100 ab, löst eine benutzerdefinierte Ausnahme aus, wenn das Gehalt unter 1000 liegt, und behandelt mögliche Fehler wie fehlende Mitarbeiterdatensätze und unerwartete Ausnahmen.

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;

Zu den besten Praktiken für die Behandlung von Ausnahmen gehören die folgenden:

• Rechne immer mit möglichen Ausnahmen.
• Verwende aussagekräftige Fehlermeldungen.
• Protokolliere Ausnahmen für Audits.
• Halte den Code für die Ausnahmebehandlung kurz und konzentriere dich auf die Wiederherstellung.

9. Wie kannst du überprüfen, ob eine UPDATE-Anweisung ausgeführt wird oder nicht?

Das Attribut SQL %NOTFOUND kann verwendet werden, um festzustellen, ob die Anweisung UPDATE erfolgreich Datensätze geändert hat. Wenn die zuletzt ausgeführte SQL-Anweisung keine Zeilen betroffen hat, gibt diese Variable TRUE zurück.

Die folgende Abfrage aktualisiert zum Beispiel das Gehalt der Angestellten in Abteilung 10, indem sie es um 10% erhöht, und prüft dann mithilfe des Attributs %NOTFOUND, ob irgendwelche Zeilen von der Anweisung UPDATE betroffen waren. Wenn keine Zeilen aktualisiert wurden, wird die Meldung "Keine Zeilen wurden aktualisiert" ausgegeben. Wenn Zeilen aktualisiert wurden, wird die Anzahl der betroffenen Zeilen über das Attribut SQL%ROWCOUNT ausgegeben.

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

Erweiterte PL/SQL-Interview-Fragen

Lass uns nun einige fortgeschrittene Interviewfragen untersuchen, falls du dich für eine höhere Position bewirbst, die mehr Erfahrung erfordert.

10. Welche Methoden gibt es, um die Leistung in PL/SQL zu optimieren?

Die Minimierung von Kontextwechseln zwischen SQL und PL/SQL ist entscheidend für die Optimierung der Leistung. Jeder Wechsel verursacht Overhead, der die Ausführungszeiten verlangsamen kann, vor allem in Situationen, in denen häufig zwischen den beiden Wechseln gewechselt wird.

11. Wie kannst du Bulk-Operationen verwenden, um Kontextwechsel zu minimieren?

PL/SQL bietet Massenverarbeitungstechniken, um die SQL-zu-PL/SQL-Interaktion zu optimieren, indem mehrere Zeilen auf einmal abgerufen oder geändert werden.

Der folgende PL/SQL-Block zum Beispiel ruft alle Mitarbeiter der Abteilung 10 mit BULK COLLECT in einer Sammlung ab und durchläuft diese, um den Namen jedes Mitarbeiters zu drucken. Dadurch wird die Leistung verbessert, da die Kontextwechsel zwischen SQL und PL/SQL minimiert werden.

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;

Außerdem verwendet dieser PL/SQL-Block FORALL für die Massenaktualisierung und erhöht das Gehalt für Angestellte mit den IDs 101, 102 und 103 um 10%.

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. Was sind dynamisches SQL und Ref Cursors?

Dynamic SQL ermöglicht es, SQL-Anweisungen dynamisch zur Laufzeit auszuführen. Das ist nützlich, wenn du mit variablen Tabellennamen, Spalten oder Abfragestrukturen arbeitest.

Der folgende PL/SQL-Block verwendet dynamisches SQL, um die Anzahl der Zeilen in der Tabelle employees zu zählen und gibt das Ergebnis aus. Ich mag diese Art von Ansatz, weil sie Flexibilität ermöglicht.

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;  

Ref Cursors sind dynamische Cursors, die zur Laufzeit geöffnet, abgerufen und geschlossen werden können und so die Weitergabe von Abfrageergebnissen zwischen Programmeinheiten ermöglichen.

Der folgende PL/SQL-Block verwendet eine REF CURSOR, um die Namen der Mitarbeiter aus Abteilung 20 zu holen und zu drucken. Der Cursor wird dynamisch geöffnet, in einer Schleife durchlaufen und nach der Bearbeitung wieder geschlossen.

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. Wie gehst du mit Fehlern in mutierenden Tabellen um?

Mutationstabellenfehler treten auf, wenn ein Trigger versucht, die Tabelle zu ändern, auf die er ausgelöst wurde. Ein zusammengesetzter Trigger ermöglicht es, die Ausführung des Triggers in mehrere Phasen aufzuteilen, z. B. BEFORE, AFTER und FOR EACH ROW, um Probleme mit direkten Änderungen zu vermeiden.

Der unten stehende Compound Trigger protokolliert Gehaltsänderungen in der Tabelle salary_audit effizient, indem er vor jeder Zeilenaktualisierung Daten sammelt und nach der Anweisung eine Masseneinfügung durchführt, was Kontextwechsel reduziert und die Leistung verbessert.

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. Was ist Überladen in PL/SQL?

Durch Überladen können mehrere Prozeduren oder Funktionen mit demselben Namen, aber unterschiedlichen Parametern innerhalb eines Pakets definiert werden. Dies verbessert die Lesbarkeit und Wartbarkeit des Codes, da es mehrere Möglichkeiten gibt, ähnliche Vorgänge auszuführen.

In der folgenden Abfrage implementiert der Paketkörper zwei überladene Prozeduren namens update_salary: Die eine erhöht das Gehalt eines Angestellten um einen bestimmten Betrag, während die andere ein neues Gehalt mit einem Gültigkeitsdatum festlegt und die Tabelle employees entsprechend aktualisiert.

-- 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. Was sind die Compilerdirektiven und Pragmas in PL/SQL?

PL/SQL bietet Compiler-Direktiven (PRAGMA), um Code zu optimieren und Ausnahmen zu behandeln. Zu den gängigen Pragmas gehören:

• PRAGMA EXCEPTION_INIT: Verknüpft eine benutzerdefinierte Ausnahme mit einem Oracle-Fehlercode.

• PRAGMA SERIALLY_REUSABLE: Optimiert die Speichernutzung des Pakets für Skalierbarkeit.

Der folgende PL/SQL-Block behandelt das Einfügen eines Angestellten mit einem ungültigen Gehalt, indem er eine benutzerdefinierte Ausnahme e_invalid_salary verwendet, die dem Fehlercode -20001 zugeordnet ist. Wenn die Ausnahme ausgelöst wird, wird eine Fehlermeldung ausgegeben.

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. Welche verschiedenen Methoden gibt es, um PL/SQL-Code zu verfolgen und zu debuggen?

PL/SQL bietet mehrere eingebaute Pakete für das Tracing und Debugging der Codeleistung. Übliche Methoden sind DBMS_TRACE, um den Lernpfad zu verfolgen, DBMS_APPLICATION_INFO, um die Sitzungsaktivität zu überwachen, und DBMS_SESSION, um Diagnoseinformationen auf Sitzungsebene zu sammeln.

Die folgende Abfrage aktiviert zunächst das SQL-Tracing mit DBMS_SESSION.set_sql_trace(TRUE) und setzt dann mit DBMS_APPLICATION_INFO.set_client_info() kundenspezifische Sitzungsinformationen für die Überwachung. Der PL/SQL-Block wird ausgeführt, der eine UPDATE Operation simuliert. Schließlich wird das Tracing nach der Ausführung mit DBMS_SESSION.set_sql_trace(FALSE) deaktiviert.

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

Szenariobasierte PL/SQL-Interviewfragen

In realen Unternehmensanwendungen wird PL/SQL verwendet, um komplexe Geschäftslogik zu verarbeiten. Interviewer bewerten oft die Fähigkeit eines Bewerbers, PL/SQL in praktischen Szenarien anzuwenden. Im Folgenden findest du einige wichtige Herausforderungen und Strategien, um sie zu lösen.

Wenn du ein Vorstellungsgespräch führst, würde ich dich ermutigen, darüber nachzudenken, wie du die Fragen nach dieser Vorlage beantworten kannst, aber versuche natürlich, deine Antwort auf deine Branche oder deine eigenen Erfahrungen abzustimmen. Das Gleiche gilt, wenn du ein Vorstellungsgespräch führst und Ideen brauchst, wie du eine Frage stellen und die Gründlichkeit der Antwort beurteilen kannst. In diesem Fall hoffe ich, dass dieser Abschnitt als Inspiration für deine Fragen und Bewertungskriterien dient .