Cts Oracle PDF

Oracle 9i
Version: ORACLE/HANDOUT/0704/1.0
Date: 27-07-04
Cognizant Technology Solutions

500 Glen Pointe Center West
Teaneck, NJ 07666
Ph: 201-801-0233
www.cognizant.com
©Copyright 2004, Cognizant Academy, All Rights Reserved

Oracle
TABLE OF CONTENTS
Introduction ........................................................................................................................6
About this Module ...............................................................................................................6
Target Audience .................................................................................................................6
Module Objectives ..............................................................................................................6

Pre-requisite.......................................................................................................................6
Chapter 1: ORACLE SQL ......................................................................................................7
Learning Objectives ............................................................................................................7

Understand the features of SQL ...........................................................................................7
Learn SQL*Plus ..................................................................................................................7
Use Select Statements ...................................................................................................... 10

Handle NULL Values ......................................................................................................... 10
Use Column Alias ............................................................................................................. 11
What does the Column Alias do? ....................................................................................... 11

Eliminate Duplicate Rows .................................................................................................. 11
Use Where Clause............................................................................................................ 11
Use Operators .................................................................................................................. 12

Sort Rows ........................................................................................................................ 13
Use Single Row Functions ................................................................................................. 15
Use Aggregate Functions .................................................................................................. 16

Understand Joins .............................................................................................................. 17
Understand Equi-Joins ...................................................................................................... 17
Understand Outer-Joins .................................................................................................... 18

Understand Self Joins ....................................................................................................... 18
Learn Sub Query .............................................................................................................. 18
Learn Co Related Sub Query ............................................................................................. 19

Understand DDL Statements ............................................................................................. 20
Create Tables ................................................................................................................... 20
Understand DML statements ............................................................................................. 21

Understand Implicit Transaction Processing........................................................................ 21
Understand the State of data after COMMIT ....................................................................... 21
State of data after ROLLBACK ........................................................................................... 22
©Copyright 2004, Cognizant Academy, All Rights Reserved 2

Oracle
Understand Read Consistency........................................................................................... 22

SUMMARY ....................................................................................................................... 22
Test Your Understanding ................................................................................................... 23

Chapter 2: PL/SQL Fundamentals....................................................................................... 24
Learning Objectives .......................................................................................................... 24
PL/SQL Features .............................................................................................................. 24

PL/SQL Block Structure..................................................................................................... 24
Identifiers ......................................................................................................................... 25
Variables .......................................................................................................................... 25
Data Types ....................................................................................................................... 25
Composite Types .............................................................................................................. 25
PL/SQL Statements .......................................................................................................... 26

Oracle Supplied Packages................................................................................................. 26
Expressions and Operators ............................................................................................... 28
Conditional and Loop Constructs ....................................................................................... 29

SUMMARY ....................................................................................................................... 31
Test your Understanding ................................................................................................... 31
Chapter 3: Cursors and Exceptions.................................................................................... 32

Understand Cursors .......................................................................................................... 32
Fetch Cursor..................................................................................................................... 33
Close Cursor .................................................................................................................... 34
Understanding Exceptions ................................................................................................. 38
Predefined Exceptions....................................................................................................... 38
User Defined Exception ..................................................................................................... 39
PRAGMA EXCEPTION_INIT ............................................................................................. 40
RAISE_APPLICATION_ERROR ........................................................................................ 40
SUMMARY ....................................................................................................................... 40
Chapter 4: Procedures, Functions and Packages............................................................... 42

Understand Procedures ..................................................................................................... 42
Creating Procedures ......................................................................................................... 42

Oracle
Passing Parameters .......................................................................................................... 43

Creating Functions ............................................................................................................ 44
Implementing Packages .................................................................................................... 45

SUMMARY ....................................................................................................................... 46
Chapter 5: Triggers............................................................................................................. 47
Appreciate Database Triggers............................................................................................ 47
Components of Triggers .................................................................................................... 47

Types of Triggers .............................................................................................................. 48
Create Triggers ................................................................................................................. 48
Order of Trigger Firing ....................................................................................................... 50

SUMMARY ....................................................................................................................... 50
Chapter 6: PL/SQL Collection ............................................................................................. 51

Understand Collections ..................................................................................................... 51
Types of Collection............................................................................................................ 51
Define and Declare Collection ............................................................................................ 52
Use Collection Methods ..................................................................................................... 53
Learn Multi Level Collection ............................................................................................... 54

SUMMARY ....................................................................................................................... 54
Chapter 7: Dynamic SQL..................................................................................................... 55

Understand Dynamic SQL ................................................................................................. 55
Use of Dynamic SQL......................................................................................................... 55

Execute Dynamic SQL ...................................................................................................... 55
Understand Bulk Operations .............................................................................................. 57
Understand FOR ALL ........................................................................................................ 58

Understand BULK COLLECT............................................................................................. 59
Appreciate the difference between Soft Parse and Hard Parse ............................................ 59
SUMMARY ....................................................................................................................... 60

Oracle

REFERENCES ..................................................................................................................... 61
WEBSITES....................................................................................................................... 61
BOOKS ............................................................................................................................ 61
STUDENT NOTES: .............................................................................................................. 62

Oracle
Introduction
About this Module
The module tells the student about the basics of PL/SQL statements in Oracle.
Target Audience
Entry Level Trainees
Module Objectives
Upon completion of this module, the student would be able to:
?? Understand and write PL/SQL statements

?? Use DDL, DML and TCL statements
?? Write queries using all clauses and fetch data from one or more tables or views
?? Write queries using all kinds of Joins
?? Write simple and complex sub queries
?? Write queries in ANSI syntax
?? Write Static and Dynamic SQL statements
?? Create procedures, functions, packages and triggers
?? Use static and dynamic cursors in PL/SQL blocks
Pre-requisite
The student needs to have an idea of the following:
?? General Programming and Logic
?? Structured Query Language
?? Relational DBMS

Oracle
Chapter 1: ORACLE SQL
Learning Objectives
Upon Completion of this chapter the student shall be able to:

?? Understand & write SQL statements
Understand the features of SQL

What is SQL?
The Sequential Query Language (SQL) is a set of statements with which all programs and users
access data in an Oracle Database.
Who Developed SQL and When?

IBM developed the SQL, popularly pronounced as “SEQUEL” and implemented it in 1979.
Actually, in doing so, IBM implemented the model on Relational Database Management Systems
(RDBMS) developed by Dr. E.F. Codd. Today, SQL is the most popular RDBMS language.
What can SQL do?

With SQL*Plus, you can execute SQL commands and PL/SQL blocks, additionally you can
perform the following tasks:
Enter, edit, store, retrieve and run SQL commands and PL/SQL blocks
Format, perform calculations on, store, print and create web output of query results
List column definitions for any table
Access and copy data between SQL databases
Send messages to and accept responses from an end user
Perform database administration
Learn SQL*Plus
Logging in:
?? Ensure that Oracle is installed in your computer
?? Type SQLPLUS at the command prompt and press Enter

?? SQL Plus asks for your username and password
?? Enter your Username and Password

?? SQL prompt appears indicating that it is prepared to work
Exiting SQL Plus

To exit SQL Plus, simply type Exit at the command Prompt
Entering Commands

Oracle
To tell SQL Plus what to do, simply enter the command you wish to use. Commands can either
be in Lower or Upper case, for the sake of clarity, all table names, column names, and
commands in this Guide appear in capital letters.
You can enter three kinds of commands at the command prompt:
?? SQL commands, for working with information in the database

?? PL/SQL blocks, also for working with information in the database
?? SQL*Plus commands, for formatting query results, setting options, and editing
and storing SQL commands and PL/SQL blocks
Getting Help
Type HELP at the command prompt followed by the name of the command to get online help for
SQL*Plus commands. For example:
SQL>HELP ACCEPT
Executing Commands
After you enter the command and direct SQL*Plus to execute it, SQL*Plus processes
the command and re-displays the command prompt, indicating that you can enter
another command.
Running SQL Commands
Entering a SQL Command

In this example, you will enter and execute a SQL command to display the
employee number, name, job, and salary of each employee in the sample table EMP.
1. At the command prompt, enter the first line of the command:
SQL> SELECT EMPNO, ENAME, JOB, SAL
2. SQL*Plus will display a "2", the prompt for the second line. Enter the second
line of the command:
2 FROM EMP WHERE SAL < 2500;
The above command shall display the salaries below Rs. 2500 for all employees
Dividing a SQL Command into Separate Lines

You can divide your SQL command into separate lines at any points you wish, as long as
individual words are not split between lines. The point has been shown in the following example:

Oracle
SQL> SELECT EMPNO, ENAME, JOB, SAL FROM EMP WHERE SAL < 2500;
Can also be entered in the following form:
SQL> SELECT
2 EMPNO, ENAME, JOB, SAL
3 FROM EMP
4 WHERE SAL < 2500;
Ending an SQL Command

You can end an SQL command in one of three ways:
With a semicolon (;)
With a slash (/) on a line by itself
With a blank line
Creating Stored Procedures

Stored procedures are PL/SQL functions, packages, or procedures. You use SQL CREATE
commands to create stored procedures; The following SQL CREATE commands are used to create
stored procedures:
CREATE FUNCTION
CREATE LIBRARY
CREATE PACKAGE
CREATE PACKAGE BODY
CREATE PROCEDURE
CREATE TRIGGER
CREATE TYPE
Learn the rules for writing SQL statements

SQL statements may be broken down into multiple lines.
A SQL statement may be terminated with a semi-colon (;) or a forward slash (/).
The forward slash must be given in a new line after the SQL statement.
For re-executing the last SQL statement in the buffer use a forward slash instead of rewriting it.
SQL commands may be on one or many lines
Clauses are usually placed on separate lines
Tabulation can be used
Command words cannot be split across lines
SQL commands are not case sensitive (unless indicated otherwise

Oracle
An SQL command is entered at the SQL prompt and the subsequent lines are numbered. This is
called SQL buffer
Use Select Statements
What is the SELECT statement?

The SELECT statement is an SQL statement that specifies which rows and columns to fetch from
one or more tables or views.
What does the Select statement do?
The SELECT statement is very helpful in finding filtered records from a database. If the database
happens to be very large, the SELECT statement, used with the right parameters, can work
wonders in finding the right information.
An example of the usage of SELECT statement
The following SELECT statement returns an employee’s name, job title, and salary
from the emp database table:
SELECT ename, job, sal INTO my_ename, my_job, my_sal FROM emp
WHERE empno = my_empno;
In the following example, the SQL engine loads the entire empno and ename
database columns into nested tables before returning the tables to the PL/SQL:
DECLARE
TYPE NumTab IS TABLE OF emp.empno%TYPE;
TYPE NameTab IS TABLE OF emp.ename%TYPE;
enums NumTab; -- no need to initialize
names NameTab;
BEGIN
SELECT empno, ename BULK COLLECT INTO enums, names FROM emp;
...
END;
Handle NULL Values
What is a Null value?

The NULL value means inaction or nothing. It just passes control on to the next statement.
What does the NULL value do?

Although NULL value means inaction, it can, however, improve readability. In a construct
allowing alternative actions, the NULL statement serves as a placeholder. It tells
readers that the associated alternative has not been overlooked, but that indeed no
action is necessary.
An example of the usage of NULL value

In the following example, the NULL statement shows that no action is taken for unnamed
exceptions:
EXCEPTION
WHEN ZERO_DIVIDE THEN
ROLLBACK;

Oracle
WHEN VALUE_ERROR THEN
INSERT INTO errors VALUES...
COMMIT;
WHEN OTHERS THEN
NULL;
END;
Use Column Alias

What is a Column Alias?
In SQL, alias is a temporary name assigned to a table, view, column, or value within a SQL
statement used to refer to that item later in the same statement or in associated
SQL*Plus commands.
What does the Column Alias do?

Column Alias is usually used for distinguishing two column names. If two or more tables have
some column names in common, you must qualify column names with names of tables. It is
always a good idea to qualify table and column references explicitly.
Eliminate Duplicate Rows

Duplicate Rows can be removed using the ROWID field. The ROWID is guaranteed unique.
There are many variations on this theme, but the logic is to delete all but one record for each key
value. The following example shows the deletion of Duplicate Rows:
delete from EMP E
where not E.ROWID = (
select min(F.ROWID)
from EMP F
where F.EMP_ID = E.EMP_ID
);
Use Where Clause

Following are the features of a Where Clause:
?? Used for applying conditions to filter rows.

?? Appears immediately after the SELECT and FROM clause.
?? Alias names are not allowed.
?? Works on row levels.
Syntax:
SELECT <COLUMN NAME (S)/*
FROM EMP
WHERE <CONDITION>
The following four elements can be used with the WHERE clause:
?? Column name
?? Comparison Operators
?? Constants

Oracle
?? List of values
Example:
SELECT EMPNO, ENAME, SAL
FROM EMP
WHERE SAL > 2500;
Use Operators
What is an Operator?
An operator manipulates individual data items and returns a result. The data items
are called operands or arguments. Operators are represented by special characters or
by keywords. For example, an asterisk represents the multiplication operator
(*) and the operator that tests for nulls is represented by the keywords IS NULL.
There are various kinds of Operators in PL/SQL:
Unary:
A unary operator operates on only one operand. A unary operator typically appears with its
operand in this format:
operator operand
Binary:
A binary operator operates on two operands. A binary operator appears with its operands in this
format:
operand1 operator operand2
Arithmetic Operators
You can use an arithmetic operator in an expression to negate, add, subtract, multiply, and divide
numeric values. The result of the operation is also a numeric value. Some of these operators are
also used in date arithmetic. An example of arithmetic operators is given in the following:
SELECT * FROM orders

WHERE qtysold = -1;
SELECT * FROM emp
WHERE -sal < 0;
Concatenation Operator

Oracle
The concatenation operator manipulates character strings. The following example shows the use
of Concatenation operators:
SELECT ’Name is ’ || ename

FROM emp;
This selects character strings with ‘Name is’ from the database emp.
Comparison Operators
Comparison operators compare one expression with another. The result of such a comparison
can be TRUE, FALSE, or UNKNOWN. Example of a Comparison Operator is given below:
SELECT * FROM emp

WHERE sal > 1500;
The Comparison operator above shall select all salaries that are higher than 1500 in the emp
database.
Logical Operators
A logical operator combines the results of two component conditions to produce a
single result based on them or to invert the result of a single condition. An example of a logical
operator is given below:
SELECT *
FROM emp
WHERE job = ’CLERK’
AND deptno = 10;
Set Operators
Set operators combine the results of two component queries into a single result.
Queries containing set operators are called compound queries.
Sort Rows
The ORDER BY Clause
ORDER BY clause is used to arrange the output
Default order is ascending (ASC)
For arranging in descending order, DESC is used
ORDER BY should be the last clause in a SELECT statement
Can be arranged in multiple columns
Example

Oracle
SELECT EMPNO, ENAME, SAL, DEPTNO

FROM EMP
ORDER BY DEPTNO, SAL DESC;
DESC specifies a descending order
ASC specifies an ascending order. This is also the default order

–Numeric Values Lowest First
–Date Values earliest first
–Character Values alphabetically
Example
select ename, job, hiredate
from emp
order by hiredate desc;
Ordering By Many Columns

In the order by clause, specify the columns to order by, separated by commas. If any or all are to
be reversed, specify DESC after any or each column
Null values are displayed last for ascending sequences, and are reported first when rows are
sorted in descending order.
Example
select ename, job, deptno
from emp
order by deptno, sal desc;
Understand Functions
Functions are similar to operators in that they manipulate data items and return a result.
Functions differ from operators in the format of their arguments. This format allows them to
operate on zero, one, two, or more arguments. Basically, there are two kinds of Functions:
SQL functions
SQL functions are built into Oracle and are available for use in various appropriate
SQL statements.
User Defined Functions

You can write user-defined functions in PL/SQL or Java to provide functionality that is not
available in SQL or SQL functions. User functions can appear in a SQL statement anywhere SQL
functions can appear, that is, wherever an expression can occur.
For example, user functions can be used in the following:
The select list of a SELECT statement

Oracle
The condition of a WHERE clause

CONNECT BY, START WITH, ORDER BY, and GROUP BY clauses
The VALUES clause of an INSERT statement
The SET clause of an UPDATE statement
Use Single Row Functions
Single Row Functions are of the following types:

?? Character
?? Number
?? Date
?? Conversion
?? List
?? General Functions
Can be used with the following clauses:

?? SELECT
?? WHERE
?? ORDER BY
The DUAL Table features:

?? System generated table.
?? Contains one row and one column only.
?? Used as a dummy table to display information.
Example:
SELECT LOWER (‘ORACLE’) FROM DUAL;
Single row functions and data type conversions are an area where the SQL used be different
DBMS vendors varies greatly.
Thus, the operations described here will work only for ORACLE databases.
We will describe some basic ORACLE functions to:

Perform specific computational operations on numeric, character, and/or data fields, or to
Convert data from one type to another

Oracle
Use Aggregate Functions
Operates on sets of rows to give one result per group
?? SUM
?? AVG
?? MAX
?? MIN
?? COUNT (*)
?? COUNT (column name)
All group functions except COUNT (*) ignore NULL

MAX and MIN functions can be used for any datatype
GROUP BY Clause
?? Query results can be summarized using the GROUP BY clause.
?? Multiple columns can be used in GROUP BY clause.
Following can be used with GROUP BY clause:

?? Constant
?? Function without parameters (SYSDATE, USER)
?? Group functions
Example
SELECT DEPTNO, SUM (SAL)
FROM EMP
GROUP BY DEPTNO;
The HAVING Clause

?? Used for restricting groups
Sequence:
?? Rows are first grouped
?? The group function is applied

?? Groups matching the HAVING clause is then displayed
Example:
SELECT DEPTNO, SUM (SAL)
FROM EMP
GROUP BY DEPTNO
HAVING SUM (SAL) > 10000;

Oracle
Understand Joins
A join is a query that combines rows from two or more tables, views, or materialized views
("snapshots"). Oracle performs a join whenever multiple tables appear in the query’s FROM
clause. The query’s select list can select any columns from any of these tables. If any two of
these tables have a column name in common, you must qualify all references to these columns
throughout the query with table names to avoid ambiguity.
Understand Equi-Joins
What is an Equi-join?
?? Is defined as a join in which more than one tables are joined together with the help of
a common column that exists in both the tables
?? In this type of join the relationship between the tables are specified in the where
clause, by using an equal (=) symbol
?? EQUI Joins are also called simple joins and inner joins
Example
SELECT EMPNO, ENAME, DNAME
FROM EMP, DEPT
WHERE DEPT.DEPTNO = EMP.DEPTNO
Removing Ambiguity
?? When more than one column joined, and if one column exists in both the tables and
that column needs to be displayed in the output, it must be preceded by the table
name followed by a period (.)
?? Otherwise an ambiguity will occur because SQL will not understand from which table
the said column to display
Example
SELECT DEPT.DEPTNO, EMPNO FROM EMP, DEPT WHERE
EMP.DEPTNO=DEPT.DEPTNO
Table Aliases
?? Should not be more than 30 characters long, but the shorter it is the better.
?? The table alias should be substituted for the table name throughout the SELECT
statement.
?? Valid only for the current SELECT statement.
?? Should be meaningful.
Example:
SELECT E.DEPTNO, ENAME, DNAME

Oracle
FROM EMP E, DEPT D

WHERE D.DEPTNO = E.DEPTNO;
Understand Outer-Joins
An outer join extends the result of a simple join. An outer join returns all rows that satisfy the join
condition and those rows from one table for which no rows from the other satisfy the join
condition. A simple join does not return such rows. To write a query that performs an outer join of
tables A and B and returns all rows from A, apply the outer join operator (+) to all columns of B in
the join condition. For all rows in A that have no matching rows in B, Oracle returns NULL for any
select list expressions containing columns of B.
Outer join queries are subject to the following rules and restrictions:
?? The (+) operator can appear only in the WHERE clause or, in the context of left
correlation (that is, when specifying the TABLE clause) in the FROM clause, and can
be applied only to a column of a table or view.
?? If A and B are joined by multiple join conditions, you must use the (+) operator in all
of these conditions. If you do not, Oracle will return only the rows resulting from a
simple join, but without a warning or error to advise you that you do not have the
results of an outer join.
?? The (+) operator can be applied only to a column, not to an arbitrary expression.
However, an arbitrary expression can contain a column marked with the (+) operator.
Understand Self Joins

?? When one row of one table is to be compared with another row of the same table,
then self-join is used.
?? Logical tables need to be created from the same table temporarily.
Example:
SELECT E.ENAME, E.SAL, F.ENAME, F.SAL
FROM EMP E, EMP F
WHERE E.SAL = F.SAL AND E.EMPNO < F.EMPNO;
Learn Sub Query

?? A sub query is a select statement that is nested within another select statement
?? The result of the inner one is passed as an argument to the outer one
Sub queries may be:

?? Single Row Sub query (single row comparison operators can be used e.g. =, <, >, <=,
>= etc.)

Oracle
?? Multiple row sub query (Multi row comparison operator e.g. IN,SOME/ANY or ALL
operators)
Example
SELECT EMPNO, ENAME, SAL
FROM EMP
WHERE SAL=(SELECT MAX (SAL) FROM EMP);
EXISTS Operator
?? Exists returns a value TRUE if the sub-query that follows it returns at least one row
Example
SELECT EMPNO, ENAME, DEPTNO FROM EMP WHERE EXISTS
(SELECT COUNT (*) FROM EMP WHERE DEPTNO=30
HAVING COUNT (*) > 5)
ORDER BY DEPTNO;
ANY Operator
?? Compares with any of the values returned by the inner query
Example
SELECT EMPNO, ENAME, SAL FROM EMP
WHERE SAL > ANY
(SELECT SAL FROM EMP WHERE DEPTNO = 10);
ALL Operators
?? Compares with all the values returned by the inner query
Example
SELECT EMPNO, ENAME, SAL FROM EMP
WHERE SAL > ALL
(SELECT SAL FROM EMP WHERE DEPTNO = 10);
Learn Co Related Sub Query
?? Each execution of the outer query will ensure the inner query to be executed for all of
its values
Example
Select ename, deptno
from dept
where 4> (select COUNT(*)

Oracle
from emp
where dept.deptno= emp.deptno);
Steps of execution of Correlated Sub queries

?? Get candidate row (fetched by outer query)
?? Execute Inner query using candidate row’s value.
?? Use Value(s) resulting from inner query to qualify or disqualify candidate.
?? Repeat until no candidate row remains
Understand DDL Statements

?? Data Definition Language is a set of SQL commands used to create, modify and
delete database structures
?? The CREATE TABLE is used to create and define a new relational table
?? The DROP TABLE is used to delete a table and all data within the specified table
?? The ALTER TABLE is used to change an existing table definition
?? Cannot delete an existing column
?? Cannot change an existing table constraint definition
?? The TRUNCATE TABLE is used to delete all the rows within the specified table
Create Tables
Rules for naming a table
?? The name must begin with a letter, A-Z or a-z.
?? May contain letters, numeric and special character _(underscore). The $ and # are
also legal but discouraged;
?? The name is the same whether upper or lower case letters are used
?? It may be up to 30 char length
?? The name must not duplicate the name of any other object in your account.
?? The name must not be a sequel reserved word
Data type Description

VARCHAR2(W) Variable length char value up to width w
CHAR(W) Fixed length char values
NUMBER Floating point number value
NUMBER(W) Integer numbers of precision w
NUMBER(W,S) Numbers with a precision w and scale s
DATE date values
LONG store variable-length character data with a
maximum length of 2^31 - 1
(2,147,483,647) bytes
RAW Equivalent to varchar2 but stores binary data
LONG RAW Equivalent to Long but stores binary data

Oracle
Example
CREATE TABLE EMP

(EMPNO NUMBER (4) CONSTTRAINT EMP_PRIM PRIMARY KEY,
ENAME VARCHAR2 (10) CONSTRAINT ENAME_CONS
CHECK(ENAME=UPPER(ENAME)),
JOB VARCHAR2 (10),
MGR NUMBER (4) CONSTRAINT EMP_MGR
REFERENCES EMP(EMPNO),
HIREDATE DATE DEFAULT SYSDATE
SAL NUMVER(7,2) CONSTRAINT SAL_CONS NOT NULL,
COMM NUMBER(7,2),
DEPTNO NUMBER(2) CONSTRAINT DEPTNO_CONS NOT NULL,
CONSTRAINT EMP_DEPT FOREIGN KEY(DEPTNO)
REFERENCES DEPT(DEPTNO))
Understand DML statements
INSERT
Use INSERT INTO to insert a new row in table
UPDATE
Use UPDATE to update a single row/multiple rows in table
DELETE
Use DELETE to delete a single row/multiple rows from table
Understand Implicit Transaction Processing
An automatic COMMIT occurs when:

?? DDL statement is issued
?? DCL statement is issued
?? Normal exit from SQL*PLUS without issuing explicit COMMIT or ROLLBACK
An automatic ROLLBACK occurs under an abnormal termination of SQL *PLUS or due to system
failure
Understand the State of data after COMMIT

Oracle
?? The previous state of data can be recovered.

?? The current user can review the results of the DML operations by using the SELECT
statement.
?? Other users cannot view the results of the DML statements by the current user.
?? The affected rows are locked; other users cannot change the data within the affected
row.
?? Data changes are made permanent in the database.
?? The previous state of data is permanently lost.
?? All users can view the results.
?? All save points are erased.
State of data after ROLLBACK
?? Discard all pending changes by suing the ROLLBACK statement.

?? Data changes are undone
?? Previous state of the data is released.
Understand Read Consistency

?? Read Consistency guarantees a consistent view of the data at all times
?? Changes made by one user do not conflict with changes made by another user.
?? Ensures that:
?? Readers do not wait for readers.
?? Write do not wait for writers.
?? Each users sees the data as it existed at the last COMMIT, before DML operation is
started
SUMMARY
?? SQL is an English-like, non-procedural language
?? SQL is used in creating, modifying and deleting database objects
?? SQL is used in inserting, updating and deleting rows in a table
?? SQL is used in controlling access to the database and database objects
?? SQL *PLUS is an Oracle tool. It recognizes and submits SQL statements residing in
the SQL buffer (memory area) for execution to the Oracle server
?? SQL *PLUS has its own sets of commands
?? SELECT Statement is used to retrieve data from the database either selectively or
collectively
?? The WHERE clause is used to apply conditions to filter rows
?? SQL provides a set of built-in functions, namely Single Row Functions and Aggregate
functions
?? Data from multiple tables can be queried using SQL Join. They are of three types,
Equi Join, Outer Join and Self Join
?? Sub-queries is a select statement that is nested within another select statement
?? Oracle provides DDL statements for Creating, Altering, Dropping and Truncating
Tables
?? Oracle provides DML statements to insert, update and delete rows

Oracle
?? COMMIT makes permanent any database changes you made during the current
transaction. Until you commit your changes, other users cannot see them.
?? ROLLBACK ends the current transaction and undoes any changes made since the
transaction began
Test Your Understanding

?? Display the number, name and job of those employees who are hired between
February 1, 1981 and May 1, 1981.
?? Find out the names of the employees who has worked for more than 20 years
?? Find out the day of your date of birth
?? Display the total salary earned by the employees for each job type. Display only
those job types for which the total salary exceeds 5000
?? Can a constraint be added which doesn’t have a user-defined name?

Oracle
Chapter 2: PL/SQL Fundamentals

Learning Objectives
Upon completion of this chapter, you will be able to

?? Understand and write PL/SQL Statements
PL/SQL Features
PL/SQL stands for Procedural Language/SQL
PL/SQL extends SQL by adding constructs found in other procedural languages

?? Variables and types
?? Control Structures (IF-THEN-ELSE)
?? Procedures and Functions
?? Object types and methods
PL/SQL Block Structure
?? PL/SQL is a block-structured language

?? PL/SQL program is made up of a series of statements. A statement is terminated with
a semicolon (;), not with the physical end of a line
?? It has three parts, Declarative part, an Executable part and an Exception Handling
part
Syntax
DECLARE
/*Declarative Section - PL/SQL variables,
cursors and types */
BEGIN
/* Executable section - procedural and SQL statements */
EXCEPTION
/* Exception handling section - error handling statements */
END;
Anonymous Blocks
Declare
/* variables*/
Begin
/*SQL statements */
Exception
/* Error handling */
End;

Oracle
Identifiers
?? Must start with a letter
?? Up to 30 characters in length
?? May include a $ (dollar sign), _ (underscore), and # (pound sign)
?? Cannot contain embedded spaces
Variables
?? Variables are memory locations, which can store data values
?? Information from database can be assigned to a variable, or the contents of a
variable can be inserted into the database
?? The variables are declared in the declarative section of the block
?? Every variable has a specific type which describes what kind of information it can
store
Variable Declarations
Declaration Syntax
variable_name type [CONSTANT][NOT NULL][:=value]
Example
DECLARE
v_Description VARCHAR2(50);
v_NumberSeats NUMBER := 45;
v_Counter BINARY_INTEGER DEFAULT 0;
Data Types
?? BINARY_INTEGER
?? DEC
?? DECIMAL
?? DOUBLE PRECISION
?? FLOAT
?? INT
?? INTEGER
?? NATURAL
?? NUMBER
?? NUMERIC
?? POSITIVE
?? REAL
?? SMALLINT
Composite Types
PL/SQL Record
?? A record is similar to “C” structure
?? Record provide a way to deal with separate but related variables as Unit
?? To use, developer must define the type, then declare variables of that type
?? To refer to a field within a record , dot notation is used

Oracle
PL/SQL Record
Following declarative section can be replaced by PL/SQL Record
Example
DECLARE
v_StudentID NUMBER(5);
v_FirstName VARCHAR2(20);
v_LastName VARCHAR2(20);
DECLARE
TYPE t_studentRec IS RECORD (
StudentID NUMBER(5),
FirstName VARCHAR2(20),
LastName VARCHAR2(20));
v_studentInfo t_StudentRec;
PL/SQL Record
?? Use the %ROWTYPE attribute to declare a record based upon a collection of
database columns from a table or view
?? The fields within the record take their names and data types from the columns of the
table or view
?? Declare the record in the DECLARE section along with any other required variables
and constants
Example
DECLARE
REC1 EMP%ROWTYPE;
REC2 EMP%ROWTYPE
PL/SQL Statements
Statements in PL/SQL
?? The INTO clause must be used to store a table column value into a variable declared
in the DECLARATION section of PL/SQL block
SELECT ENAME INTO MEMNAME FROM EMP WHERE EMPNO=101176;
?? Multiple column values can be assigned to equal number of memory variables using
single INTO
SELECT ENAME, SAL INTO MEMNAME, MEMSAL FROM EMP WHERE
EMPNO=101176;
Oracle Supplied Packages

What is a Package?
A package is an encapsulated collection of related program objects stored together in the
database. Program objects are procedures, functions, variables, constants, cursors, and
exceptions.
Packages have many advantages over stand-alone procedures and functions, for instance, they:

Oracle
?? Let you organize your application development more efficiently.

?? Let you grant privileges more efficiently.
?? Let you modify package objects without recompiling dependent schema objects.
?? Enable Oracle to read multiple package objects into memory at once.
?? Let you overload procedures or functions. Overloading means creating multiple
procedures with the same name in the same package, each taking arguments of
different number or datatype.
?? Can contain global variables and cursors that are available to all procedures and
functions in the package
What are the packages supplied by Oracle?

Presented below are some important packages provided by Oracle and their Description:
Package Description
Calendar Provides calendar maintenance functions
Provides support for the asynchronous notification of database
DBMS_ALERT events.
Lets you register an application name with the database for

DBMS_APPLICATION_INFO auditing or performance tracking purposes.
DBMS_AQ Lets you add a message (of a predefined object type) onto a
queue or to dequeue a message
Lets you perform administrative functions on a queue or queue
DBMS_AQADM table for messages of a predefined object type.
Provides access to some SQL DDL statements from stored

DBMS_DDL procedures, and provides special administration operations not
available as DDLs.
A PL/SQL API to the PL/SQL debugger layer, Probe, in the

DBMS_DEBUG
Oracle server.
Provides the user interface to a replicated transactional deferred

DBMS_DEFER
remote procedure call facility. Requires the Distributed Option.
Permits querying the deferred remote procedure calls (RPC)

DBMS_DEFER_QUERY
queue data that is not exposed through views. Requires the
Distributed Option
Provides the system administrator interface to a replicated
DMBS_DEFER_SYS transactional deferred remote procedure call facility. Requires the
Distributed Option.

Oracle
Expressions and Operators
Operator:
An operator is used to manipulate individual data items and return a result. These items are
called operands or arguments. Operators are represented by special characters or by keywords.
For example, the multiplication operator is represented by an asterisk (*) and the operator that
tests for nulls is represented by the keywords IS NULL. The main SQL operators are described
below:
Unary and Binary Operators:
A unary operator operates on only one operand. A unary operator typically appears with its
operand in this format: operator operand
A binary operator operates on two operands. A binary operator appears with its operands in this
format: operand1 operator operand2
Precedence:
An important property of an operator is its precedence. Precedence is the order in which Oracle
evaluates different operators in the same expression. When evaluating an expression containing
multiple operators, Oracle evaluates operators with higher precedence before evaluating those
with lower precedence. Oracle evaluates operators with equal precedence from left to right within
an expression.
Arithmetic Operators:
You can use an arithmetic operator in an expression to negate, add, subtract, multiply, and divide
numeric values. The result of the operation is also a numeric value. Some of these operators are
also used in date arithmetic. Some examples of arithmetic operators are:
+, -, *, / etc.
Character Operators:
Character operators are used in expressions to manipulate character strings. Following is an
example of a character operator:
Operator Purpose Example

II Concatenates Character Strings SELECT ‘Name is’ II ename FROM emp
Comparison Operators:
Comparison operators are used in conditions that compare one expression to another. The result
of comparing one expression to another can be TRUE, FALSE, or UNKNOWN. Below is given
an example of a comparison Operator:
Operator Purpose Example

+ Equality Test SELECT * FROM emp WHERE sal=1500
Logical Operators:
A logical operator combines the results of two component conditions to produce a single result
based on them or to invert the result of a single condition. The main comparison operators are:
AND, Not and OR Below is given an example of a comparison Operator:
Operator Function Example
NOT Returns TRUE if the following condition is FALSE. Returns SELECT *

Oracle
FALSE if it is TRUE. If it is UNKNOWN, it remains FROM emp
UNKNOWN WHERE NOT
(sal BETWEEN
1000 AND 2000)
Set Operators:
Set operators combine the results of two component queries into a single result. Queries
containing set operators are called compound queries. The main set operators are: UNION,
UNION ALL, INTERSECT and MINUS
Expression:
An expression is a sequence of variables and literals, separated by operators. The most basic
operator is assignment.
Syntax
Variable: = expression
Variable is PL/SQL variable and expression is PL/SQL expression
PL/SQL expression is: 3 + 5 * 7

Concatenation operator (||) attaches two or more strings together. For example, the
expression ‘Hello ’||’World’ evaluates to ‘Hello World’.
Conditional and Loop Constructs

Conditionals:
A conditional statement executes a code segment based on a condition, such as an equality test
(a = b), a comparison test (a > b), or a Boolean test. PL/SQL has three conditional structures: IF-
THEN, IF-THEN-ELSE, and IF-THEN-ELSIF-THEN-...-ELSE.
The IF-THEN format executes a code block if the condition is TRUE. For example:
IF line_count > LINES_PER_PAGE
THEN
line_count: = 0;
DBMS_SQL.PUT_LINE ('--------');
END IF;
The IF-THEN-ELSE format has two code blocks. If the condition is TRUE, the first block is
executed; otherwise, the second block is executed. For example:
IF items_sold > get_employee_target (emp_id)
THEN
over_quota_count: = over_quota_count + 1;
give_raise (emp_id);
ELSE
give_talking_to (emp_id);
END IF;

Oracle
The IF-THEN-ELSIF-THEN-...-ELSE, PL/SQL's equivalent of the CASE or SWITCH statement,

can contain multiple conditions. The statement executes the code block associated with the first
TRUE condition. Here's an example:
IF is_number (current_char)
OR is_letter (current_char)
THEN
new_char: = current_char;
ELSIF current_char = ' '
THEN
new_char: = '+';
ELSE
new_char := convert_to_hex (current_char);
END IF;
Loops:
Looping, or iteration, causes the block between the keywords LOOP and END LOOP to be
repeatedly executed. The loop ends, or terminates, when an exit condition is met. Once a loop
terminates, program control is returned to the first line after the END LOOP keyword. There are
three looping structures: simple, WHILE, and FOR.
In the simple loop, the exit condition is embedded inside the loop body. The EXIT command
terminates the loop immediately, and is usually embedded inside an IF...THEN statement. EXIT
WHEN combines EXIT with a conditional to form a more compact syntax. Here are two
constructions of a simple loop. The first example uses EXIT:
LOOP
COUNT: = COUNT + 1;
IF COUNT > 10
THEN
EXIT;
END IF;
END LOOP;
The second example uses EXIT WHEN:

LOOP
COUNT: = COUNT + 1;
EXIT WHEN COUNT > 10;
END LOOP;
In the second kind of loop, the WHILE loop, the exit condition is outside the body of the loop. The
code within the body of the loop iterates while the loop condition is true. The loop terminates
when the condition is false, for example:
WHILE (COUNT <= 10)
Oracle
LOOP
COUNT: = COUNT + 1;
END LOOP;
The last kind of loop, the FOR loop, iterates a predetermined number of times. For example, the
number of loops needed to process each month in the year does not depend on a complex
condition; it always requires 12 passes through the loop. A FOR loop is controlled by an index
variable that ranges from a lower bound to an upper bound. The index variable begins at the
lower bound. Each pass through the loop increments it. The loop terminates when the index
reaches the upper bound, for example:
FOR month_index IN 1.. 12
LOOP
process_month_sales (month_index);
END LOOP;
SUMMARY
?? PL/SQL extends SQL by adding constructs found in other procedural languages like
conditional constructs, looping, variables data types, procedures, functions etc.
?? Data types can be Scalar types and Composite types.
?? Composite Types can be PL/SQL Record and PL/SQL Tables
?? A Record is like a ‘C’ structure. The %ROWTYPE attribute is used to declare a
record based upon a collection of database columns from a table or view
?? A table is like a ‘C’ array. A Table can have only one primary key
(BINARY_INTEGER) and a column
??
Test your Understanding
Write a PL/SQL block to print the Department wise Employee Details, with Total for each
department as well as Grand Total. The report should look like this,
DEPT No: 10 dname: Accounts

Deptno Emono Ename Job Sal
--- --- --- --- --
--- --- --- --- --
Total for Deptno 10

Oracle
Chapter 3: Cursors and Exceptions
Learning Objectives
Upon completion of this Chapter, you will be able to:

?? Understand & write cursors
Understand Cursors
A cursor is a mechanism by which you can assign a name to a "select statement" and
manipulate the information within that SQL statement. In other words, A cursor is a SELECT
statement that is defined within the declaration section of your PLSQL code. We'll take a look at
three different syntaxes for cursors. There are two types of cursors: Implicit and Explicit. An
Implicit cursor is used for all other SQL statements. Implicit Cursors gives less programmatic
control. In explicit cursor the cursor name is explicitly attached to a select statement
The four PL/SQL steps necessary for explicit cursor processing are as follows:
?? Declare the cursor
?? Open the cursor
?? Fetch the results into PL/SQL variables
?? Close the cursor
?? To use a cursor, it must be declared first
Syntax
CURSOR cursor_name IS SELECT_statement;
A cursor without parameters

CURSOR comp IS SELECT compid FROM company;
A cursor with parameters

CURSOR comp (mcompid IN NUMBER) IS SELECT name FROM
company WHERE compid = mcomid;
Open Cursors:
Once you've declared your cursor, the next step is to open the cursor
The basic syntax to OPEN the cursor is:
OPEN cursor_name;
For example, you could open a cursor called c1 with the following command:
OPEN c1;

Oracle
Below is a function that demonstrates how to use the OPEN statement:

CREATE OR REPLACE Function FindCourse
( name_in IN varchar2 )
RETURN number
IS
cnumber number;
CURSOR c1
IS
SELECT course_number
from courses_tbl
where course_name = name_in;
BEGIN
open c1;
fetch c1 into cnumber;
if c1%notfound then
cnumber := 9999;
end if;
close c1;
RETURN cnumber;
END;
Fetch Cursor
The purpose of using a cursor, in most cases, is to retrieve the rows from your cursor so that
some type of operation can be performed on the data. After declaring and opening your cursor,
the next step is to FETCH the rows from your cursor.
The basic syntax for a FETCH statement is:

FETCH cursor_name INTO <list of variables>;
For example, you could have a cursor defined as:
CURSOR c1
IS
from courses_tbl
The command that would be used to fetch the data from this cursor is:
FETCH c1 into cnumber;
This would fetch the first course_number into the variable called cnumber;

Oracle
Close Cursor
The final step of working with cursors is to close the cursor once you have finished using it.
The basic syntax to CLOSE the cursor is:
CLOSE cursor_name;
For example, you could close a cursor called c1 with the following command:
CLOSE c1;
Below is a function that demonstrates how to use the CLOSE statement:

RETURN number
IS
cnumber number;
CURSOR c1
IS
from courses_tbl
BEGIN
open c1;
if c1%notfound then
cnumber := 9999;
end if;
close c1;
RETURN cnumber;
END;
Cursor Attributes:
While dealing with cursors, you may need to determine the status of your cursor. The
following is a list of the cursor attributes that you can use:
Attributes Explanation
%ISOPEN Returns TRUE if the cursor is open, FALSE if the cursor is closed
Returns INVALID_CURSOR if cursor is declared, but not open; or if
cursor has been closed.
Returns NULL if cursor is open, but fetch has not been executed.
%FOUND
Returns TRUE if a successful fetch has been executed.
Returns FALSE if no row was returned.

%NOTFOUND

Oracle
Return NULL if cursor is open, but fetch has not been executed.
Returns FALSE if a successful fetch has been executed.
Returns TRUE if no row was returned.

%ROWCOUNT
Returns the number of rows fetched.
Below is an example of how you might use the %NOTFOUND attribute.

RETURN number
IS
cnumber number;
CURSOR c1
IS
from courses_tbl
BEGIN
open c1;
if c1%notfound then
cnumber := 9999;
end if;
close c1;
RETURN cnumber;
END;
Cursor Examples:
The Following example shows a procedure that outputs a dynamic PLSQL cursor. The
example states a problem and shows how to solve it.
Question: In Oracle, I have a table called "wine" and a stored procedure that outputs a cursor
based on the "wine" table.
I've created an HTML Form where the user can enter any combination of three values to retrieve
results from the "wine" table. My problem is that I need a general "select" statement that will work
no matter what value(s), the user enters.
Example:
parameter_1= "Chianti"
parameter_2= "10"

Oracle
parameter_3= wasn't entered by the user but I have to use in the select statement. And
this is my problem. How to initialize this parameter to get all rows for column3?
SELECT * FROM wine

WHERE column1 = parameter_1
AND column2 = parameter_2
AND column3 = parameter_3;.
The output of my stored procedure must be a cursor.
Answer: To solve your problem, you will need to output a dynamic PLSQL cursor in Oracle.
Let's take a look at how we can do this. We've divided this process into 3 steps.
Step 1 - Table Definition

First, we need a table created in Oracle called "wine". Below is the create statement for the wine
table.
create table wine
( col1 varchar2(40),
col2 varchar2(40),
col3 varchar2(40)
);
We've made this table definition very simple, for demonstration purposes.
Step 2 - Create package

Next, we've created a package called "winepkg" that contains our cursor definition. This needs to
be done so that we can use a cursor as an output parameter in our stored procedure.
create or replace PACKAGE winepkg
IS
/* Define the REF CURSOR type. */
TYPE wine_type IS REF CURSOR RETURN wine%ROWTYPE;
END winepkg;
This cursor will accept all fields from the "wine" table.
Step 3 - Create stored procedure

Our final step is to create a stored procedure to return the cursor. It accepts three parameters
(entered by the user on the HTML Form) and returns a cursor (c1) of type "wine_type" which was
declared in Step 2.
The procedure will determine the appropriate cursor to return, based on the value(s) that have
been entered by the user (input parameters).
create or replace procedure find_wine2
(col1_in in varchar2,
col2_in in varchar2,
col3_in in varchar2,
c1 out winepkg.wine_type)
as
BEGIN
/* all columns were entered */
IF (length(col1_in) > 0) and (length(col2_in) > 0) and (length(col3_in) > 0)
THEN
OPEN c1 FOR

Oracle
select *
from wine
where wine.col1 = col1_in
and wine.col2 = col2_in
and wine.col3 = col3_in;
/* col1 and col2 were entered */
ELSIF (length(col1_in) > 0) and (length(col2_in) > 0) and (length(col3_in) = 0)
THEN
OPEN c1 FOR
select *
from wine
/* col1 and col3 were entered */
ELSIF (length(col1_in) > 0) and (length(col2_in) = 0) and (length(col3_in) > 0)
THEN
OPEN c1 FOR
select *
from wine
/* col2 and col3 where entered */
ELSIF (length(col1_in) = 0) and (length(col2_in) > 0) and (length(col3_in) > 0)
THEN
OPEN c1 FOR
select *
from wine
/* col1 was entered */
ELSIF (length(col1_in) > 0) and (length(col2_in) = 0) and (length(col3_in) = 0)
THEN
OPEN c1 FOR
select *
from wine
where wine.col1 = col1_in;
ELSIF (length(col1_in) = 0) and (length(col2_in) > 0) and (length(col3_in) = 0)
THEN
OPEN c1 FOR
select *
from wine
ELSIF (length(col1_in) = 0) and (length(col2_in) = 0) and (length(col3_in) > 0)
THEN
OPEN c1 FOR
select *
from wine
END IF;
END find_wine2;

Oracle
Understanding Exceptions
What is an Exception?
Exceptions are errors raised whenever there is any in a particular PL/SQL block. This causes a
termination in the program by Oracle. Control then is transferred to the separate exception
section of the program, if one exists, to handle the exception.
Types of Exceptions:
?? Predefined Exception
?? User Defined Exception
Predefined Exceptions
Oracle has a list of Predefined exceptions. They are generated mostly with the SELECT
statement. They are generated implicitly at runtime. Following is a list of the predefined
exceptions that Oracle recognises:
Oracle Exception Name Oracle Explanation

Error
DUP_VAL_ON_INDEX ORA- You tried to execute an INSERT or UPDATE
00001 statement that has created a duplicate value in a
field restricted by a unique index.
TIMEOUT_ON_RESOURCE ORA- You were waiting for a resource and you timed out.
00051
TRANSACTION_BACKED_OUT ORA- The remote portion of a transaction has rolled
00061 back.
INVALID_CURSOR ORA- You tried to reference a cursor that does not yet
01001 exist. This may have happened because you’ve
executed a FETCH cursor or CLOSE cursor before
opening the cursor.
NOT_LOGGED_ON ORA- You tried to execute a call to Oracle before logging
01012 in.
LOGIN_DENIED ORA- You tried to log into Oracle with an invalid
01017 username/password combination.
NO_DATA_FOUND ORA- You tried one of the following:
01403 1. You executed a SELECT INTO statement and
no rows were returned.
2. You referenced an uninitialized row in a table.
3. You read past the end of file with the UTL_FILE
package.
TOO_MANY_ROWS ORA- You tried to execute a SELECT INTO statement
01422 and more than one row was returned.

Oracle
ZERO_DIVIDE ORA- You tried to divide a number by zero.

01476
User Defined Exception

Sometimes, it is necessary for programmers to name and trap their own exceptions - ones that
aren't defined already by PL/SQL. These are called Named Programmer or User-Defined
Exceptions.
The syntax for the Named Programmer-Defined Exception in a procedure is:
CREATE [OR REPLACE] PROCEDURE procedure_name
[ (parameter [,parameter]) ]
IS
[declaration_section]
exception_name EXCEPTION;
BEGIN
executable_section
RAISE exception_name ;
EXCEPTION
WHEN exception_name THEN
[statements]
WHEN OTHERS THEN
[statements]
END [procedure_name];
The syntax for the Named Programmer-Defined Exception in a function is:
CREATE [OR REPLACE] FUNCTION function_name
[(parameter [, parameter])]
RETURN return_datatype
IS | AS
exception_name EXCEPTION;
BEGIN
executable_section
RAISE exception_name ;
EXCEPTION
WHEN exception_name THEN
[statements]
WHEN OTHERS THEN
[statements]
END [function_name];
Here is an example of a procedure that uses a Named Programmer-Defined Exception:

CREATE OR REPLACE PROCEDURE add_new_order
(order_id_in IN NUMBER, sales_in IN NUMBER)
IS
no_sales EXCEPTION;
BEGIN
IF sales_in = 0 THEN
RAISE no_sales;
ELSE
INSERT INTO orders (order_id, total_sales )
VALUES ( order_id_in, sales_in );
END IF;

Oracle
EXCEPTION
WHEN no_sales THEN
raise_application_error (-20001,'You must have sales in order to submit the
order.');
WHEN OTHERS THEN
raise_application_error (-20002,'An error has occurred inserting an order.');
END;
PRAGMA EXCEPTION_INIT
The pragma EXCEPTION_INIT associates an exception name with an Oracle error number. That
lets you refer to any internal exception by name and to write a specific handler for it instead of
using the OTHERS handler.
Syntax
PRAGMA EXCEPTION_INIT (EXCEPTION, ERROR_NUMBER);
Example
DECLARE
MYEXP EXCEPTION;
PRAGMA EXCEPTION_INIT (MYEXP, -1422);
RAISE_APPLICATION_ERROR
What is RAISE_APPLICATION_ERROR?
The RAISE_APPLICATION_ERROR is a procedure that communicates application-specific
errors from the server side (usually a database trigger) to the client-side application. This built-in
procedure is the only mechanism available for communicating a server-side, programmer-defined
exception to the client side in such a way that the client process can handle the exception. Error
number should be of the range between –20000 and –20999. Error messages should be less
than 512 characters.
Syntax
RAISE_APPLICATION_ERROR (error_number in NUMBER, error_msg in VARCHAR2);
Example
IF age < 18 THEN
RAISE_APPLICATION_ERROR (-20001, ‘Must be eighteen years of age.');
END IF;
SUMMARY
?? Explicit cursor handling requires Declaring, Opening, Fetching and Closing cursor
?? Oracle raises ERRORS whenever any abnormal situation arises in a PL/SQL block
and performs an illegal termination of the execution of the program
?? PL/SQL traps and responds to errors using an architecture of EXCEPTION handler
?? Pre-defined exceptions are already defined in the STANDARD package
?? Exceptions can be pre-defined(built-in) and user-defined

Oracle
1. Create a cursor to print empno, ename, job, sal, hiredate and the increment amount for
all employees. Increment amount depends on the day of joining
Day of Joining Increment in %
Friday 20
Wednesday 18
Thursday 17
For all others 15

Oracle
Chapter 4: Procedures, Functions and Packages
Learning Objectives
On completion of this Chapter, you will be able to:
?? Understand & Write Procedures
Understand Procedures
What is a Procedure?
It is a sub program in the PL/SQL block, which can perform a specific task when invoked explicitly
with or without parameter. A Procedure has two parts: Specification and Body
Specification: This section begins with the keyword Procedure followed by its name and
Parameter list (optional)
Body: Procedure Body begins with the keyword IS/AS and ends with the keyword END followed
by the procedure name (optional)
Syntax
CREATE OR REPLACE PROCEDURE <PROCEDURE_NAME>
(<PARAMETER> [MODE] <DATA TYPE>,)
IS/AS
[LOCAL VARIABLE DECLARATION]
BEGIN
PL/SQL EXECUTABLE STATEMENT
[EXCEPTION]
[EXCEPTION HANDLERS]
END [PROGRAM UNIT NAME];
Creating Procedures
In Oracle, you can create your own procedures.
The syntax for a procedure is:
CREATE [OR REPLACE] PROCEDURE procedure_name

[(parameter [, parameter])]
IS
BEGIN
executable_section
[EXCEPTION
exception_section]
END [procedure_name];

Oracle
Passing Parameters
When you create a procedure or function, you may define parameters. There are three types of
parameters that can be declared:
IN
The parameter can be referenced by the procedure or function. The value of the parameter
cannot be overwritten by the procedure or function.
OUT
The parameter cannot be referenced by the procedure or function, but the value of the parameter
can be overwritten by the procedure or function.
Example of Procedure with Parameter

CREATE OR REPLACE PROCEDURE CALC_BONUS (
EMP_ID IN INTEGER,
BONUS OUT NUMBER) IS
MJOB EMP.JOB%TYPE;
BEGIN
SELECT SAL*0.10 INTO BONUS FROM EMP WHERE EMPNO = EMP_ID;
IF MJOB = ‘MANAGER’ THEN
BONUS: = 0;
END IF;
END CALC_BONUS;
Executing The Procedure

DECLARE
BON NUMBER;
ECODE NUMBER;
BEGIN
ECODE: = &EMPLOYEE_NO;
CALC_BONUS(ECODE, BON);
DBMS_OUTPUT.PUT_LINE(‘The Bonus for the employee’ || ECODE || ‘ is’ || BON);
END;
Example of Procedure with INOUT Parameter

CREATE OR REPLACE PROCEDURE FORMAT_PHONE_NO (V_PHONE IN OUT
VARCHAR2)
IS
BEGIN
V_PHONE: = ‘(‘ || SUBSTR (V_PHONE, 1,3) || ‘)’ || SUBSTR (V_PHONE, 4,3) || -‘ ’ ||
SUBSTR (V_PHONE, 7);
END FORMAT_PHONE_NO;
/

Oracle
Creating Functions
In Oracle, you can create your own functions.
The syntax for a function is:
CREATE [OR REPLACE] FUNCTION function_name
[ (parameter [,parameter]) ]
RETURN return_datatype
IS | AS
BEGIN
executable_section
[EXCEPTION
exception_section]
END [function_name];
When you create a procedure or function, you may define parameters. There are three types of
parameters that can be declared:
1. IN
The parameter can be referenced by the procedure or function. The value of the parameter
cannot be overwritten by the procedure or function.
2. OUT
The parameter can not be referenced by the procedure or function, but the value of the parameter
3. IN OUT
The parameter can be referenced by the procedure or function and the value of the parameter
The following is a simple example of a function:

RETURN number
IS
cnumber number;
cursor c1 is
select course_number
from courses_tbl
BEGIN
open c1;
if c1%notfound then
cnumber := 9999;
end if;
close c1;
RETURN cnumber;
EXCEPTION
WHEN OTHERS THEN
raise_application_error(-20001,'An error was encountered - '||SQLCODE||' -

Oracle
ERROR- '||SQLERRM);
END;
This function is called FindCourse. It has one parameter called name_in and it returns a
number. The function will return the course number if it finds a match based on course name.
Otherwise, it returns a 99999.
You could then reference your new function in an SQL statement as follows:
select course_name, FindCourse(course_name) as course_id
from courses
where subject = 'Mathematics';
Implementing Packages
What is a Package?
A package is a collection of Functions, Procedures, Global variables and cursors stored in server
in compiled form. A package consists of 2 parts:
Package Specification: This acts as an interface to the user applications. This part declares the,
PL/SQL types, variables, constants, exception, cursor & sub-programs (Functions and
procedures). This part is created using CREATE PACKAGE command
Package Body: It implements the specifications by defining the cursors and sub-programs. This
part is created using CREATE PACKAGE BODY command.
Oracle stores package specification and body separately in the data dictionary. A package
specification can exists without a package body but not vice versa.
An element of a package, whether it is a variable or a module, can either be

Public
When defined in the specification a public element can be referenced from other programs and
PL/SQL blocks
Private
When defined only in the body of the package, but does not appear in the specification. A private
element cannot be referenced outside of the package. It can only be referenced by other
elements within the package
The sub-programs that are present inside a package cannot exist separately as database objects.
A package cannot be called by itself. Only the procedures and functions from within the package
can be called with reference to the package using the dot (.) operator. When one sub-program is
called, then all other sub-programs are also loaded into the memory, hence the subsequent call
for any other modules becomes fast.

Oracle
SUMMARY
?? A package is a compiled database objects logically groups PL/SQL types, sub-
programs etc. It consists of two parts: specification and body
?? The specification is the interface to your applications; it declares the types, variables,
constants, exceptions, cursors, and subprograms available for use. The body fully
defines cursors and subprograms, and so implements the specification

1. Create a procedure that will accept a percentage and JOB, and will show the
reflection on the total salary. Calculate the total salary before the increment for the
particular JOB and show the difference.
2. Create a procedure that will accept the LOAN amount and EMPNO as input and
display the installment amount and number of installments to be paid. (Max loan
amount will be his current salary * total number of years of service. Loan will be paid
in equal monthly installment. Installment amount will be 1/10th of monthly salary)

Oracle
Chapter 5: Triggers
Learning Objectives
Upon Completion of this chapter you will be able to:

?? Understand & write Database Triggers
Appreciate Database Triggers
What is a Database Trigger?

A database trigger is a stored program unit associated with a database table. Triggers are used
to overcome the limitations of constraints and to supplement the declarative referential integrity
while implementing complex business rules or to audit changes to data.
Features of Database Triggers:

?? These are stored procedures that gets implicitly executed when some database-
related event occurs
?? Can be applied on any Table/View
?? Can be applied before the instruction is executed as well as after the execution
?? Can work for any DML statements like INSERT, UPDATE and DELETE but not for
SELECT
?? Can be used to overcome the limitation of CHECK constraints
Syntax
CREATE OR REPLACE TRIGGER <TRIGGER_NAME>
[BEFORE/AFTER] [INSERT/UPDATE/DELETE]
ON <TABLE_NAME>
[FOR EACH ROW [WHEN triggering_condition]]
trigger_body;
Components of Triggers
The main components of Database Triggers are the following:
?? Trigger Timing
It means when a trigger should fire. The possible trigger timing are BEFORE, AFTER
?? Trigger Event
The trigger event can be INSERT, UPDATE or DELETE
?? Trigger Type
The type of trigger can be Statement or Row

?? Trigger Body

Oracle
This section specifies the action need to be performed by the trigger i.e. it is the PL/SQL block
that gets executed
Types of Triggers
There are two kinds of triggers in Oracle:
?? Row Level
–The action specified with the row level trigger will be executed for each affected row
by the instruction for which the trigger is invoked
–These triggers will fire for every INSERT/UPDATE/DELETE on the table depending
on the number of rows affected by by the triggering event
–Should specify the keyword FOR EACH ROW
?? Statement Level
–They get fired in the table level once for each trigger event
–These triggers will fire for every INSERT/UPDATE/DELETE on the table irrespective
of the number of rows affected by the triggering event
–To define a statement level trigger omit the FOR EACH ROW keyword in the trigger
specification
Create Triggers
Insert Triggers:
BEFORE INSERT Trigger:
A BEFORE INSERT Trigger means that Oracle will fire this trigger before the INSERT operation
is executed.
The syntax for a BEFORE INSERT Trigger is:
CREATE or REPLACE TRIGGER trigger_name
BEFORE INSERT
ON TABLE
[FOR EACH ROW ]
DECLARE
-- variable declarations
BEGIN
-- trigger code
EXCEPTION
WHEN ...
-- exception handling
END;
AFTER INSERT Trigger:

An AFTER INSERT Trigger means that Oracle will fire this trigger after the INSERT operation is
executed.
The syntax for an AFTER INSERT Trigger is:
AFTER INSERT
ON TABLE
[ FOR EACH ROW ]
DECLARE
BEGIN

Oracle
-- trigger code
EXCEPTION
WHEN ...
END;
Update Triggers:
BEFORE UPDATE Trigger:
A BEFORE UPDATE Trigger means that Oracle will fire this trigger before the UPDATE operation
is executed.
The syntax for a BEFORE UPDATE Trigger is:
BEFORE UPDATE
ON TABLE
[ FOR EACH ROW ]
DECLARE
BEGIN
-- trigger code
EXCEPTION
WHEN ...
END;
AFTER UPDATE Trigger:
An AFTER UPDATE Trigger means that Oracle will fire this trigger after the UPDATE operation is
executed.
The syntax for an AFTER UPDATE Trigger is:
AFTER UPDATE
ON TABLE
[ FOR EACH ROW ]
DECLARE
BEGIN
-- trigger code
EXCEPTION
WHEN ...
END;
Delete Triggers:
BEFORE DELETE Trigger:
A BEFORE DELETE Trigger means that Oracle will fire this trigger before the DELETE operation
is executed.
The syntax for a BEFORE DELETE Trigger is:
BEFORE DELETE
ON TABLE
[ FOR EACH ROW ]
DECLARE
BEGIN

Oracle
-- trigger code
EXCEPTION
WHEN ...
END;
AFTER DELETE Trigger:

An AFTER DELETE Trigger means that Oracle will fire this trigger after the DELETE operation is
executed.
The syntax for an AFTER DELETE Trigger is:
AFTER DELETE
ON TABLE
[ FOR EACH ROW ]
DECLARE
BEGIN
-- trigger code
EXCEPTION
WHEN ...
END;
Order of Trigger Firing

?? Execute the BEFORE statement level trigger, if present
?? For each row affected by the statement,
–Execute the BEFORE row-level trigger, if present.

–Execute the statement itself.
–Execute the AFTER row-level trigger, if present.
?? Execute the after statement-level trigger, if present
SUMMARY
?? Triggers are stored procedures that gets implicitly executed when some database-
related event occurs
?? Can work for any DML statements like INSERT, UPDATE and DELETE but not for
SELECT
?? Triggers can be row level and statement level. The action specified with the row level
trigger will be executed for each affected row by the instruction for which the trigger is
invoked
?? The statement level triggers will fire for every INSERT/UPDATE/DELETE on the table
irrespective of the number of rows affected by by the triggering event
1.Write a trigger on the EMP table, so that after each insertion of new record, or updation of old
one, the NOE column of the dept table gets updated. Add a column NOE to the dept table, which
will record the number of rows for each department. In case of record updation the NOE of one
department should be reduced and another should be incremented.

Oracle
Chapter 6: PL/SQL Collection
Learning Objectives

?? Understand & write PL/SQL collection
Understand Collections
What is a Collection?
A collection is an ordered group of elements, all of the same type
Features of Collection:
?? It is a general concept that encompasses list, arrays and other familiar datatypes
?? Each element has a unique subscript that determines its position in the collection
?? Collections work like the arrays found in most third-generation programming

language
Types of Collection
PL/SQL has two collection types:
?? Tables
?? Varrays
Tables comes in two flavors

Index by tables (formerly called PL/SQL tables):
Also known as associative arrays, it lets you look up elements using arbitrary numbers and
strings for subscript values. They are similar to one-dimensional arrays and are referenced like
arrays of records. Since Index-By tables can be passed as parameters, they can be used to move
columns of data into and out of database tables or between client-side applications and stored
subprograms
Nested Tables
Nested tables hold an arbitrary number of elements. They use sequential numbers as subscripts.
Within the database, nested tables can be considered one-column database tables. Oracle stores
the rows of a nested table in no particular order. When the nested table is retrieve into a PL/SQL
variable, the rows are given consecutive subscripts starting at 1. That gives array-like access to
individual rows.

Oracle
Varrays
Items of type VARRAY are called Varrays.Allow to associate a single identifier with an entire
collection. Manipulate the collection as a whole and reference individual elements easily. To
reference an element, use standard subscripting syntax.
Define and Declare Collection

Define a collection type and declare variables of that type
Syntax for Index-by tables:
TYPE type_name IS TABLE OF element_type [NOT NULL]
INDEX BY [BINARY_INTEGER | PLS_INTEGER | VARCHAR2 (size_limit)];
INDEX BY key_type;
Type_name is a type specifier used later to declare collections.
Element_type is any PL/SQL datatype.
Key_type can be numeric, either BINARY_INTEGER or PLS_INTEGER.
It can also be VARCHAR2 or one of its subtypes VARCHAR, STRING, or LONG.
You mustSpecify the size. (Varchar2 (1000);)
Syntax for Nested tables:
TYPE type_name IS TABLE OF element_type [NOT NULL];
type_name is a type specifier used later to declare collections
element_type is any PL/SQL datatype.
Syntax for Varrays:
TYPE type_name IS {VARRAY | VARYING ARRAY} (size_limit)
OF element_type [NOT NULL];
type_name and element_type are the same as for nested tables.size_limit is a
positive integer literal representing the maximum number of elements in the array
When defining a VARRAY type, must specify its maximum size.
Example, of a type that stores up to 366 dates:
DECLARETYPE Calendar IS VARRAY (366) OF DATE;
Example of Index- by Tables
DECLARE
TYPE EmpTabTyp IS TABLE OF emp%ROWTYPE /* Create a type */
INDEX BY BINARY_INTEGER;
emp_tab EmpTabTyp; /* Declaration of variable of collection type */
TYPE typ_number IS TABLE OF NUMBER INDEX BY BINARY_INTEGER;
empid_tab typ_number; /* Declaration of variable of collection type */
BEGIN /* Retrieve employee record. */
SELECT * INTO emp_tab(7468) FROM emp WHERE empno = 7468;
SELECT EMPID
BULK COLLECT INTO empid_tab
FROM EMP;
IF empid_tab.last > 0 THEN
FORALL I in 1.. empid_tab.last

Oracle
LOOP
Dbms_output.put_line(‘Empid: ‘||empid_tab(i)) END LOOP
END IF;
END;
Example of Nested Tables:

CREATE TYPE CourseList AS TABLE OF VARCHAR2(10) -- define type
/
CREATE TYPE Student AS OBJECT ( -- create object
id_num INTEGER(4),
name VARCHAR2 (25),
address VARCHAR2 (35),
status CHAR(2),
courses CourseList) -- declare nested table as attribute
/
Example of Varrays
CREATE TYPE ProjectList AS VARRAY (50) OF VARCHAR2 (16);
/
CREATE TABLE department ( -- create database table
dept_id NUMBER(2),
name VARCHAR2(15),
budget NUMBER(11,2),
-- Each department can have up to 50 projects.
projects ProjectList)
/
Use Collection Methods

The following collection methods are used:
?? FIRST - Returns the index of the first element in the collection.
?? LAST - Returns the index of the last element in the collection.
?? PRIOR (n) - Returns the index of the element prior to the specified element
?? NEXT (n) - Returns the index of the next element after the specified element.
?? EXTEND - Appends a single null element to the collection.
?? EXTEND (n) - Appends n null elements to the collection.
?? EXTEND (n1, n2) - Appends n1 copies of the n2th element to the collection
?? TRIM - Removes a single element from the end of the collection.
?? TRIM (n) - Removes n elements from the end of the collection.
?? DELETE - Removes all elements from the collection.

?? DELETE (n) - Removes element n from the collection.
?? DELETE (n1, n2) - Removes all elements from n1 to n2 from the collection

Oracle
Learn Multi Level Collection
A Multi Level Collection is a collection within collections. Nested table of Varrays, Varrays of
varrays etc are examples of Multi Level Collection
Multilevel VARRAY Example

declare
type t1 is varray(10) of integer;
type nt1 is varray(10) of t1; -- multilevel
va t1 := t1(2,3,5);
-- initialize multilevel varray
nva nt1 := nt1(va, t1(55,6,73), t1(2,4),
i integer;
va1 t1;
begin
-- Multilevel access
i := nva(2)(3); -- i will get value 73
dbms_output.put_line(i);
SUMMARY
?? A collection is a ordered group of elements, all of the same type
?? Each element has a unique subscript that determines its position in the collection
?? PL/SQL has two collection types: Tables, Varrays
?? Tables comes in two flavors Index by tables (formerly called PL/SQL tables) and
Nested Tables
Study the following code:

CREATE TYPE CourseList AS TABLE OF VARCHAR2(10) -- define type
/
CREATE TYPE Student AS OBJECT ( -- create object
id_num INTEGER(4),
name VARCHAR2(25),
address VARCHAR2(35),
status CHAR(2),
courses CourseList) -- declare nested table as attribute
/
If courses . DELETE(2); deletes element 2 and courses . DELETE(7,7) delete element 7Then
courses. DELETE(6,3) delete which element?

Oracle
Chapter 7: Dynamic SQL

Learning Objectives
?? Understand and write dynamic SQL
Understand Dynamic SQL
What is Dynamic SQL?

Dynamic SQL is an advanced programming technique that adds flexibility and functionality to
applications. Dynamic SQL allows you to write SQL that will then write and execute more SQL for
you. This can be a great time saver because you can:
?? Automate repetitive tasks.
?? Write code that will work in any database or server.
?? Write code that dynamically adjusts itself to changing conditions
Features of Dynamic SQL:
?? Dynamic SQL enables to write programs that reference SQL statements whose full
text is not known until runtime
?? Before discussing dynamic SQL in detail, a clear definition of static SQL may provide
a good starting point for understanding dynamic SQL
?? Static SQL statements do not change from execution to execution. The full text of
static SQL statements are known at Compilation time that is not there in case of
Dynamic SQL
Use of Dynamic SQL

Following are the uses of Dynamic SQL:
?? Dynamic SQL lets execute SQL statements that are not supported in static SQL
Programs, data definition language (DDL) statements such as CREATE, data control
Statement such as GRANT and session control statement such as ALTER SESSION
?? Dynamic SQL should be used in cases where static SQL does not support the
operation you want to perform or in cases you do not know the exact SQL statements
that must be executed by a PL/SQL procedure i.e. at Runtime
Execute Dynamic SQL

The EXECUTE IMMEDIATE Statement:
The EXECUTE IMMEDIATE statement prepares (parses) and immediately executes a dynamic
SQL statement or an anonymous PL/SQL block

Oracle
Syntax
EXECUTE IMMEDIATE dynamic_string
[INTO {define_variable[, define_variable]... | record}]
[USING [IN | OUT | IN OUT] bind_argument

[, [IN | OUT | IN OUT] bind_argument]...];
–where dynamic_string is a string expression that represents a SQL statement or PL/SQL block.
–define_variable is a variable that stores a SELECTed column value, record is a user-defined or

%ROWTYPE record that stores a SELECTed row.
–bind_argument is an expression whose value is passed to the dynamic SQL statement or

PL/SQL block.
–The INTO clause, useful only for single-row queries, specifies the variables or Record into which
column values are fetched. For each column value returned by the query, there must be a
corresponding, type-compatible variable or field in the INTO clause
–Every bind argument must be put in the USING clause. If no parameter mode is specified, it
defaults to IN. At run time, any bind arguments in the USING clause replace corresponding
placeholders in the SQL statement or PL/SQL block. So, every placeholder must be associated
with a bind argument in the USING clause. Numeric, character, and string literals are allowed in
the USING clause, but Boolean literals (TRUE, FALSE, NULL) are not. To pass nulls to the
dynamic string, a workaround must be used. Dynamic SQL supports all the SQL datatypes.
–So, for example, define variables and bind arguments can be collections, LOBs, instances of an
object type, and REFs
Example using EXECUTE IMMEDIATE
DECLARE
sql_stmt VARCHAR2(100);
plsql_block VARCHAR2(200);
my_deptno NUMBER(2) := 50;
my_dname VARCHAR2(15) := ’PERSONNEL’;
my_loc VARCHAR2(15) := ’DALLAS’;
emp_rec emp%ROWTYPE;
BEGIN
sql_stmt := ’INSERT INTO dept VALUES (:1, :2, :3)’;
EXECUTE IMMEDIATE sql_stmt USING my_deptno, my_dname,
my_loc;
sql_stmt := ’SELECT * FROM emp WHERE empno = :id’;
EXECUTE IMMEDIATE sql_stmt INTO emp_rec USING 7788;
EXECUTE IMMEDIATE ’DELETE FROM dept

Oracle
WHERE deptno = :n’ USING my_deptno;

plsql_block := ’BEGIN emp_stuff.raise_salary(:id, :amt); END;’;
EXECUTE IMMEDIATE plsql_block USING 7788, 500;
EXECUTE IMMEDIATE ’CREATE TABLE bonus (id NUMBER, amt NUMBER)’;
sql_stmt := ’ALTER SESSION SET SQL_TRACE TRUE’;
EXECUTE IMMEDIATE sql_stmt;
END;
Example using the DBMS SQL package

CREATE PROCEDURE insert_into_table (
Table_name VARCHAR2,
Deptnumber NUMBER,
Deptname VARCHAR2,
Location VARCHAR2) IS
Cur_hdl INTEGER;
Stmt_str VARCHAR2(200);
Rows_processed BINARY_INTEGER;
BEGIN
Stmt_str := 'INSERT INTO ' || Table_name || ' VALUES
(:deptno, :dname, :loc)';
-----Open cursor
cur_hdl := dbms_sql.open_cursor;
---- Parse cursor
dbms_sql.parse(cur_hdl, stmt_str,dbms_sql.native);
----- Supply binds
dbms_sql.bind_variable (cur_hdl, ':deptno', deptnumber);
dbms_sql.bind_variable (cur_hdl, ':dname', deptname);
dbms_sql.bind_variable (cur_hdl, ':loc', location);
---- Execute cursor
rows_processed := dbms_sql.execute(cur_hdl);
---- Close cursor
dbms_sql.close_cursor(cur_hdl);
END;
Understand Bulk Operations

What is the meaning of Bulk Operations?
?? PL/SQL is very tightly integrated with the Oracle database SQL engine, but this tight
integration does not mean that there isn’t any overhead associated with executing
SQL statements from PL/SQL
?? When a PL/SQL program executes, the procedural portions are executed by the
PL/SQL engine, but all SQL statement are passed to SQL layer for execution, then
data is passed back to the procedural engine

Oracle
?? The transfer of data back and forth from PL/SQL to SQL and back again is called
context switching. The more switches occur the more performance degrades. Two
new enhancements
?? BULK COLLECT and the FORALL statements allows to bulk together all of the
context switches into a single switch and pass that to the SQL engine
Understand FOR ALL

What is the meaning of FOR ALL?
?? A variation on the classic FOR LOOP that bundles together multiple DML statements
based on a collection
?? Bulk DML using the FORALL statement will also take advantage of turning multiple
context switches into a single context switch.
The FORALL statement must follow these simple rules:
The body of the FORALL statement must contain a single DML operation.
?? The DML must reference collection elements, indexed by the index_row variable in
the FORALL statement. The scope of the index_row variable is the FORALL
statement only; you may not reference it outside of that statement
?? Do not declare an INTEGER variable for index_row. It is declared implicitly by the
PL/SQL engine
?? The lower and upper bounds must specify a valid range of consecutive index
numbers for the collection(s) referenced in the SQL statement.
Example of FOR ALL:
PROCEDURE proc_bulk_collect IS
CURSOR cur_emp IS
SELECT emono
FROM emp;
TYPE tt_empno IS TABLE OF emp.empno%TYPE INDEX BY
BINARY_INTEGER;
tab_emono tt_empno;
BEGIN
OPEN cur_emp;
FETCH cur_emp INTO BULK COLLECT tab_emono;
close cur_emp;
FORALL i IN tab_emono.FIRST..tab_emono.LAST LOOP
DELETE FROM new_emp
WHERE empno = tab_emono(i);
END LOOP;
end;

Oracle
Understand BULK COLLECT

BULK COLLECT is an enhancement to explicit and implicit cursor query operation that allows the
transfer of multiple rows of data in one trip to the SQL engine. Given Below is an example of
BULK COLLECT:
PROCEDURE proc_bulk_collect IS
CURSOR cur_emp IS
SELECT emono,ename
FROM emp;
TYPE tt_empno IS TABLE OF emp.empno%TYPE INDEX BY
BINARY_INTEGER;
tab_emono tt_empno;
TYPE tt_ename IS TABLE OF emp.ename%TYPE INDEX BY
BINARY_INTEGER;
tab_ename tt_ename;
BEGIN
OPEN cur_emp;
FETCH cur_emp INTO BULK COLLECT tab_emono,tab_ename;
close cur_emp;
END;
Appreciate the difference between Soft Parse and Hard Parse

Soft parse : It is a Statement, which is parsed and already in the shared pool, those statements
for re-execution need not require parsing if it is found in the shared Pool. A shorter process to
getting the query result
Hard parse : It is a statement, which is parsed every time during the execution is called hard
parse. If we have to Hard Parse a large percentage of our queries, our system will function slowly
and in some cases. Hard parse can be avoided by using bind variable in subprogram.

Oracle
SUMMARY
?? Dynamic SQL enables to write programs that reference SQL statements whose full
text is not known until runtime
?? Dynamic SQL lets execute SQL statements that are not supported in static SQL
Programs
?? The EXECUTE IMMEDIATE statement prepares (parses) and immediately executes
a dynamic SQL statement or an anonymous PL/SQL block
?? BULK COLLECT and the FORALL statements allows to bulk together all of the
context switches into a single switch and pass that to the SQL engine

The following are the two Dynamic SQL statements. What is the main difference between these
two statements in the respect of execution?
Begin
EXECUTE IMMEDIATE 'CREATE TABLE X(A DATE)';
End;
/
CREATE OR REPLACE PROCEDURE CREATE_TABLE2 AS
cur integer;
rc integer;
BEGIN cur := DBMS_SQL.OPEN_CURSOR;
DBMS_SQL.PARSE(cur, 'CREATE TABLE X (Y DATE)', DBMS_SQL.NATIVE);
rc := DBMS_SQL.EXECUTE(cur);
DBMS_SQL.CLOSE_CURSOR(cur);
END;

Oracle
REFERENCES
WEBSITES
?? http://otn.oracle.com
?? http://www.docnmail.com/learn/Oracle.htm
BOOKS
Oracle 9i Complete Reference

?? Vin Loney, George Koch, Oracle Press
Oracle Pl/ SQL 101

?? Christopher Allen, Oracle Press
Oracle8 PL/ SQL Programming

?? Scott Urman, Wendy Rinaldi

Oracle
STUDENT NOTES:

Cts Oracle PDF

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Cts Oracle PDF

Hochgeladen von

Copyright:

Verfügbare Formate

Oracle 9i

Cognizant Technology Solutions

©Copyright 2004, Cognizant Academy, All Rights Reserved

Module Objectives ..............................................................................................................6

Learning Objectives ............................................................................................................7

Use Select Statements ...................................................................................................... 10

What does the Column Alias do? ....................................................................................... 11

Use Operators .................................................................................................................. 12

Use Aggregate Functions .................................................................................................. 16

Understand Outer-Joins .................................................................................................... 18

Learn Co Related Sub Query ............................................................................................. 19

Understand DML statements ............................................................................................. 21

State of data after ROLLBACK ........................................................................................... 22

©Copyright 2004, Cognizant Academy, All Rights Reserved 2

Understand Read Consistency........................................................................................... 22

Test Your Understanding ................................................................................................... 23

PL/SQL Features .............................................................................................................. 24

PL/SQL Statements .......................................................................................................... 26

Conditional and Loop Constructs ....................................................................................... 29

Chapter 3: Cursors and Exceptions.................................................................................... 32

Chapter 4: Procedures, Functions and Packages............................................................... 42

Creating Procedures ......................................................................................................... 42

©Copyright 2004, Cognizant Academy, All Rights Reserved 3

Passing Parameters .......................................................................................................... 43

Implementing Packages .................................................................................................... 45

Components of Triggers .................................................................................................... 47

Order of Trigger Firing ....................................................................................................... 50

Chapter 6: PL/SQL Collection ............................................................................................. 51

Learn Multi Level Collection ............................................................................................... 54

Chapter 7: Dynamic SQL..................................................................................................... 55

Use of Dynamic SQL......................................................................................................... 55

Understand FOR ALL ........................................................................................................ 58

©Copyright 2004, Cognizant Academy, All Rights Reserved 4

Test Your Understanding ................................................................................................... 60

©Copyright 2004, Cognizant Academy, All Rights Reserved 5

Upon completion of this module, the student would be able to:

?? Understand and write PL/SQL statements

©Copyright 2004, Cognizant Academy, All Rights Reserved 6

Chapter 1: ORACLE SQL

Upon Completion of this chapter the student shall be able to:

Understand the features of SQL

Who Developed SQL and When?

What can SQL do?

?? Type SQLPLUS at the command prompt and press Enter

?? Enter your Username and Password

Exiting SQL Plus

©Copyright 2004, Cognizant Academy, All Rights Reserved 7

You can enter three kinds of commands at the command prompt:

?? SQL commands, for working with information in the database

Running SQL Commands

Entering a SQL Command

1. At the command prompt, enter the first line of the command:

SQL> SELECT EMPNO, ENAME, JOB, SAL

2 FROM EMP WHERE SAL < 2500;

Dividing a SQL Command into Separate Lines

©Copyright 2004, Cognizant Academy, All Rights Reserved 8

Can also be entered in the following form:

Ending an SQL Command

Creating Stored Procedures

Learn the rules for writing SQL statements

©Copyright 2004, Cognizant Academy, All Rights Reserved 9

Use Select Statements

What is the SELECT statement?