Die 20 wichtigsten PL/SQL-Interviewfragen und Antworten im Jahr 2026

PL/SQL, die prozedurale Spracherweiterung von SQL von Oracle, musst du einfach kennen, wenn du mit Oracle-Datenbanken arbeiten willst. Das gilt für wichtige Rollen wie Datenbankadministrator, Entwickler und Datenanalyst, die alle mit komplexer Geschäftslogik in der Datenbank umgehen müssen.

Ich denke, dass Interviewer die Kandidaten anhand von drei Hauptaspekten beurteilen:

• Begriffliches Verständnis: Grundprinzipien, Datentypen, Kontrollstrukturen und Ausnahmebehandlung.
• Praktische Programmierkenntnisse: Effiziente gespeicherte Prozeduren, Funktionen, Trigger und Pakete schreiben.
• Leistungsaspekte: Optimierung 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 zu helfen, gebe ich dir hier einen Leitfaden zu PL/SQL-Interviewfragen. Ich fange mit den grundlegenden Konzepten an und gehe dann zu fortgeschritteneren Themen wie Massenverarbeitung, dynamischem SQL und Leistungsoptimierung über.

Wenn du die grundlegenden Konzepte der Oracle-Datenbank verstehen willst, empfehle ich dir unseren Kurs „Einführung in Oracle SQL “. Der ist echt wichtig, um zu lernen, wie man mit der Oracle-Datenbank arbeitet und wie die Datenbank PL/SQL zur Verarbeitung von Abfragen nutzt.

Fragen für Anfänger zum Thema PL/SQL im Vorstellungsgespräch

In der ersten Interviewphase kann der Interviewer grundlegende Fragen stellen, um dein Wissen über grundlegende Datenbank- und PL/SQL-Konzepte zu checken. Schau dir diese Fragen mal an und überleg dir 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 das Abrufen von Daten und deren Bearbeitung konzentriert, können Entwickler mit PL/SQL prozedurale Logik implementieren, was es zu einem leistungsstarken Tool für das Schreiben komplexer Geschäftsregeln innerhalb der Datenbank macht. Es unterstützt Variablen, Schleifen, Bedingungen, Ausnahmebehandlung und modulare Programmierung durch Prozeduren, Funktionen und Pakete.

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

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

• DECLARE (Optional): Wird benutzt, um Variablen, Konstanten, Cursor und benutzerdefinierte Typen zu definieren.

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

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

• END;: Zeigt das Ende des Blocks an.

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

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

• Skalare Typen: Einzelwert-Typen wie NUMBER, VARCHAR2, DATE, BOOLEAN.

• Zusammengesetzte Typen: Sammlungen wie RECORD (benutzerdefinierte Strukturen) und TABLE/VARRAY (Arrays).

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

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

PL/SQL hat ein paar Kontrollstrukturen, die beim Verwalten des Programmablaufs helfen:

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

• Bedingte Anweisungen: Dazu gehören die Anweisungen „ IF “ und „ CASE “, die je nach Bedingungen unterschiedliche Code-Blöcke ausführen. Die DECODE()-Funktion ist ein weiteres gutes Beispiel für eine Bedingung, die man sich mal anschauen sollte. 

Fragen für Fortgeschrittene zum Thema PL/SQL im Vorstellungsgespräch

Nachdem wir die grundlegenden Fragen geklärt haben, kommen wir jetzt zu ein paar Interviewfragen zum Thema Datenstrukturen für Fortgeschrittene. Nachdem sie deine Grundkenntnisse geprüft haben, werden die Interviewer jetzt deine technischen Fähigkeiten bei der Umsetzung und Anwendung von PL/SQL-Konzepten testen.

5. Was ist der Unterschied zwischen gespeicherten Prozeduren und Funktionen?

Gespeicherte Prozeduren und Funktionen sind beide wiederverwendbare PL/SQL-Codeblöcke, aber sie haben ziemlich unterschiedliche Zwecke.

Gespeicherte Prozeduren werden benutzt, um Operationen durchzuführen, die keinen Wert zurückgeben, wie zum Beispiel das Einfügen, Aktualisieren oder Löschen von Daten. Sie werden für Aufgaben verwendet, die Daten ändern oder komplizierte Vorgänge ausführen, ohne ein Ergebnis zurückzugeben.

Das folgende Verfahren aktualisiert zum Beispiel die Gehaltsinformationen ( salary ) des Mitarbeiters mit der angegebenen Gehaltsgruppe ( employee_id ), indem es die angegebene Gehaltsstufe ( p_increment ) hinzufügt, sodass sich das Gehalt dynamisch basierend auf den Eingabeparametern ändert.

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

Funktionen hingegen geben nach der Ausführung von Operationen einen Wert zurück. Sie sind super für Berechnungen oder das Abrufen von Daten, bei denen ein Ergebnis rauskommen muss.

Die Funktion unten macht es einfacher, das Gehalt eines Mitarbeiters abzurufen, 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;Bereitgestellt von

6. Was sind PL/SQL-Pakete?

PL/SQL-Pakete sind Sammlungen von Prozeduren, Funktionen und Variablen, die Code zusammenfassen, um ihn besser zu organisieren und wiederverwenden zu können. Die bestehen aus zwei Teilen:

• Paket-Spezifikation: Deklariert öffentliche Elemente (Prozeduren, Funktionen, Variablen).
• Paketinhalt: Enthält die Details zur Umsetzung der in der Spezifikation angegebenen Prozeduren 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, wobei 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;Bereitgestellt von

7. Was sind PL/SQL-Trigger?

Trigger sind PL/SQL-Blöcke, die automatisch bei bestimmten Datenbankereignissen wie Einfügungen, Aktualisierungen oder Löschungen ablaufen. Trigger werden benutzt, um Geschäftsregeln durchzusetzen. Sie werden auch oft für Audits benutzt. Sie sind in folgende Kategorien unterteilt:

• Trigger auf Zeilenebene: Führ das mal für jede betroffene Zeile aus.
• Trigger auf Statement-Ebene: Wird einmal pro SQL-Anweisung ausgeführt, egal wie viele Zeilen betroffen sind.

Die folgende Abfrage erstellt einen Trigger „ AFTER UPDATE “ 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 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;Bereitgestellt von

Schau dir unser Tutorial zu SQL-Triggern an, damit du bereit bist, falls Trigger im Vorstellungsgespräch zur Sprache kommen. 

8. Wie geht man in PL/SQL mit Ausnahmen um?

PL/SQL hat Mechanismen zur Fehlerbehandlung, um Stabilität zu bringen und Abstürze zu vermeiden. Die Arten von Ausnahmen umfassen Folgendes:

• 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 holt zum Beispiel das Gehalt eines Mitarbeiters mit der ID 100 ab, löst eine benutzerdefinierte Ausnahme aus, wenn das Gehalt unter 1000 liegt, und kümmert sich um 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;Bereitgestellt von

Die besten Vorgehensweisen für die Ausnahmebehandlung umfassen Folgendes:

• Rechne immer mit möglichen Ausnahmen.
• Benutz aussagekräftige Fehlermeldungen.
• Ausnahmen für die Prüfung protokollieren.
• Mach den Code für die Ausnahmebehandlung kurz und konzentrier dich auf die Wiederherstellung.

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

Mit dem SQL-Attribut „ %NOTFOUND “ kann man feststellen, ob die Anweisung „ UPDATE “ erfolgreich irgendwelche Datensätze geändert hat. Wenn die letzte ausgeführte SQL-Anweisung keine Auswirkungen auf Zeilen hatte, gibt diese Variable „ TRUE “ zurück.

Die folgende Abfrage aktualisiert zum Beispiel das Gehalt der Mitarbeiter in Abteilung 10, indem es um 10 % erhöht wird, und prüft dann mithilfe des Attributs „ %NOTFOUND “, ob irgendwelche Zeilen von der Anweisung „ UPDATE “ betroffen waren. Wenn keine Zeilen geändert wurden, kommt die Meldung „Keine Zeilen geändert“. Wenn Zeilen aktualisiert wurden, gibt es die Anzahl der betroffenen Zeilen über das Attribut „ SQL%ROWCOUNT “ aus.

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

Fragen für Fortgeschrittene zu PL/SQL im Vorstellungsgespräch

Schauen wir uns jetzt ein paar fortgeschrittene Interviewfragen an, falls du dich für eine höhere Position bewirbst, die mehr Erfahrung erfordert.

10. Wie kann man die Leistung in PL/SQL verbessern?

Die Minimierung von Kontextwechseln zwischen SQL und PL/SQL ist entscheidend für die Optimierung der Leistung. Jeder Wechsel bringt einen Mehraufwand mit sich, der die Ausführungszeiten verlangsamen kann, vor allem wenn man oft zwischen den beiden hin und her wechselt.

11. Wie nutzt man Massenoperationen, um Kontextwechsel zu minimieren?

PL/SQL hat Techniken für die Massenverarbeitung, um die Interaktion zwischen SQL und PL/SQL zu verbessern, indem mehrere Zeilen auf einmal geholt oder geändert werden.

Der folgende PL/SQL-Block holt zum Beispiel alle Mitarbeiter aus Abteilung 10 mit „ BULK COLLECT “ in eine Sammlung und geht sie durch, um den Namen jedes Mitarbeiters auszugeben. Das verbessert die Leistung, weil es weniger Kontextwechsel zwischen SQL und PL/SQL braucht.

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

Außerdem nutzt dieser PL/SQL-Block „ FORALL “ für Massenaktualisierungen, um das Gehalt der Mitarbeiter mit den IDs 101, 102 und 103 um 10 % zu erhöhen.

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

12. Was sind dynamisches SQL und Referenzcursor?

Dynamisches SQL ermöglicht die dynamische Ausführung von SQL-Anweisungen zur Laufzeit, was bei variablen Namen von Tabellen, Spalten oder Abfragestrukturen nützlich ist.

Der folgende PL/SQL-Block zählt mit dynamischem SQL die Zeilen in der Tabelle „ employees ” und zeigt das Ergebnis an. Ich mag diese Art von Ansatz, weil er 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;  Bereitgestellt von

Ref-Cursor sind dynamische Cursor, die zur Laufzeit geöffnet, abgerufen und geschlossen werden können, sodass Abfrageergebnisse zwischen Programmeinheiten ausgetauscht werden können.

Der folgende PL/SQL-Block nutzt eine Abfrage „ REF CURSOR “, um die Namen der Mitarbeiter aus Abteilung 20 abzurufen und auszugeben. Der Cursor wird dynamisch geöffnet, mit einer Schleife durchlaufen und nach der Verarbeitung 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;Bereitgestellt von

13. Wie gehst du mit Fehlern bei der Tabelle um?

Fehler beim Ändern von Tabellen treten auf, wenn ein Trigger versucht, die Tabelle zu ändern, auf der er ausgelöst wird. Ein zusammengesetzter Trigger ermöglicht es, die Triggerausführung in mehrere Phasen aufzuteilen, wie z. B. „ BEFORE “, „ AFTER “ und „ FOR EACH ROW “, um Probleme durch direkte Änderungen zu vermeiden.

Der zusammengesetzte Trigger unten protokolliert Gehaltsänderungen in der Tabelle „ salary_audit “ auf effiziente Weise, indem er vor jeder Zeilenaktualisierung Daten sammelt und nach der Anweisung einen Masseneintrag durchführt, wodurch Kontextwechsel reduziert und die Leistung verbessert werden.

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

14. Was ist Überladung in PL/SQL?

Überladen ermöglicht es, mehrere Prozeduren oder Funktionen mit demselben Namen, aber unterschiedlichen Parametern innerhalb eines Pakets zu definieren. Das macht den Code besser lesbar und pflegeleichter, weil es mehrere Möglichkeiten gibt, ähnliche Vorgänge durchzuführen.

In der folgenden Abfrage macht der Paketkörper zwei überladene Prozeduren namens „ update_salary “ klar: Der eine erhöht das Gehalt eines Mitarbeiters um einen bestimmten Betrag, während der 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;
/Bereitgestellt von

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

15. Was sind die Compiler-Direktiven und Pragmas in PL/SQL?

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

• PRAGMA EXCEPTION_INIT: Ordnet eine benutzerdefinierte Ausnahme einem Oracle-Fehlercode zu.

• PRAGMA SERIALLY_REUSABLE: Optimiert die Nutzung des Paketspeichers für mehr Skalierbarkeit.

Der folgende PL/SQL-Block kümmert sich um das Hinzufügen eines Mitarbeiters 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 angezeigt.

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

16. Was gibt's für verschiedene Methoden, um PL/SQL-Code zu verfolgen und zu debuggen?

PL/SQL hat ein paar eingebaute Pakete, mit denen man die Leistung von Code verfolgen und debuggen kann. Zu den gängigen Methoden gehören die Verwendung von „ DBMS_TRACE “ zur Verfolgung des Ausführungsflusses, „ DBMS_APPLICATION_INFO “ zur Überwachung der Sitzungsaktivität und „ DBMS_SESSION “ zum Sammeln von Diagnoseinformationen auf Sitzungsebene.

Die folgende Abfrage aktiviert erst mal die SQL-Ablaufverfolgung mit „ DBMS_SESSION.set_sql_trace(TRUE) “ und legt dann mit „ DBMS_APPLICATION_INFO.set_client_info() “ die spezifischen Sitzungsinfos für die Überwachung fest. Der PL/SQL-Block wird ausgeführt, der eine Operation „ UPDATE “ simuliert. Schließlich wird die Ablaufverfolgung 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;
/Bereitgestellt von

Szenariobasierte PL/SQL-Interviewfragen

In echten Unternehmensanwendungen wird PL/SQL benutzt, um komplizierte Geschäftslogik zu verarbeiten. Interviewer checken oft, wie gut ein Bewerber PL/SQL in echten Situationen anwenden kann. Hier sind ein paar wichtige Herausforderungen und Strategien, wie man sie lösen kann.

Für den nächsten und letzten Abschnitt würde ich dir empfehlen, dir zu überlegen, wie du Fragen nach diesem Muster beantworten kannst, wenn du ein Vorstellungsgespräch hast. Versuch aber natürlich, deine Antwort auf deine Branche zuzuschneiden oder deine eigenen Erfahrungen einzubringen. Das Gleiche gilt, wenn du ein Vorstellungsgespräch mit einem Bewerber führst und Ideen suchst, wie du Fragen stellen und die Ausführlichkeit der Antworten beurteilen kannst. In diesem Fall hoffe ich, dass dieser Abschnitt dir sowohl für deine Fragen als auch für deine Bewertungskriterien als Inspiration dient .