To identify the steps for designing, debugging, invoking, and bundling PL/SQL subprograms, procedures and functions, and also for handling their exceptions.
- Designing Subprograms - identify the benefits of modularized and layered subprogram design.
- Using Procedures - recognize the steps for creating and calling procedures and passing parameters.
- Handling Exceptions - identify the steps for handling exceptions in procedures and for dropping procedures.
- Creating Functions - recognize the steps for creating and invoking functions.
- Debugging Subprograms - recognize the steps for using SQL Developer to debug PL/SQL subprograms.
- Creating Packages - identify the benefits and components of a package, and recognize the steps for creating one.
- Working with Packages - create a package specification and package body in a given scenario, and invoke the package's constructs.
To recognize the steps for creating and using efficient PL/SQL packages, including Oracle-supplied packages, executing dynamic SQL, and improving the performance of code.
- Working with Packages - recognize the steps for overloading subprograms, using forward declarations, writing package initialization blocks, and maintaining persistent package state.
- Using Oracle-Supplied Packages - identify the steps for using the Oracle-supplied packages DBMS_OUTPUT, UTL_FILE, and UTL_MAIL.
- Using the DBMS_SCHEDULER and HTP Packages - recognize the steps for using Oracle-supplied packages to generate a simple Web page and schedule PL/SQL code for execution.
- Using Dynamic SQL - identify the steps for constructing and executing SQL statements at run time, using native dynamic SQL statements in PL/SQL.
- Using Packages in PL/SQL - alter a package so that it contains overloaded subprograms, use an Oracle-supplied package, and execute dynamic SQL in a given scenario.
- Design Considerations for PL/SQL Code - identify the steps for designing packages so that code is easy to maintain, efficient, and readable, and so that PL/SQL applications perform better.
- Using Bulk Binding and the RETURNING Clause - Identify the steps for binding whole arrays of values in a single operation, and for retrieving information about a row affected by a SQL operation.
To identify the steps for creating, managing, and using database triggers, and for using the new PL/SQL compiler, its initialization parameters, and its compile time warnings.
- Creating Triggers - identify the steps for creating and using database triggers.
- Managing Triggers - recognize the steps for enabling, disabling, testing, managing, and removing database triggers.
- Using Compound, DDL, and Event Database Triggers - identify the steps for creating and using compound, DDL, and event database triggers.
- Working with Triggers - create statement and row triggers, including a trigger for a business rule and a package with triggers that resolve a mutating table issue.
- Using the PL/SQL Compiler - recognize the benefits and capabilities of the PL/SQL compiler and its parameters.
- Using PL/SQL Compiler Parameters and Warnings - recognize the steps for using the PL/SQL compiler initialization parameters, compiling a procedure, and managing compiler warnings.
To identify the steps for performing conditional compilation to selectively use PL/SQL code, wrapping code, and tracking dependencies.
- Managing PL/SQL Code - identify the steps for selectively including PL/SQL source code by using conditional compilation, and for wrapping a PL/SQL unit.
- Tracking Dependencies - recognize the steps for predicting how changing a database object affects procedures and functions by tracking procedural dependencies.
- Exploring Dependencies - recognize the steps for managing remote dependencies and recompiling a PL/SQL program unit.
- Using Packages, Compilation, and Dependencies - use conditional compilation, wrap PL/SQL code, and manage dependencies in a given scenario.