pl sql-ch2

[email protected] Prof. Mukesh N. Tekwani

1 Chap 2. PL/SQL Transactions and Cursors

2. PL/SQL Transactions And Cursors

1. What is a transaction?

A transaction is a series of one or more SQL statements that are logically related or a series of

operations performed on an Oracle table.

This logical unit is treated as an entity by Oracle. All changes to the data table are viewed as a

two-step process. Step 1: Make the changes requested, and Step 2: This must be followed by

the COMMIT statement. A ROLLBACK statement given at the SQL prompt can be used to

undo a part of or the entire transaction.

A transaction begins with the first executable SQL statement after a COMMIT, ROLLBACK,

or connection made to the Oracle engine.

A transaction is a group of events that occur between any of the following events:

1. Connecting to Oracle

2. Disconnecting from Oracle

3. Committing changes to the database table

4. Rollback

Closing transaction: a transaction is closed by either a commit or a rollback statement.

COMMIT statement: This statement ends the current transaction and changes are made

permanent.

Syntax:

COMMIT

ROLLBACK statement: This statement does exactly the opposite of the COMMIT statement.

It ends the transaction but undoes any changes made during the transaction. All transactional

locks are released from the tables.

Syntax:

ROLLBACK [TO [SAVEPOINT] <savepointname>];

SAVEPOINT is optional and is used to roll back a transaction partially.

savepointname is a savepoint ceated during the current transaction.

2. Write a note on ROLLBACK and SAVEPOINT clauses.

ROLLBACK statement: This statement does exactly the opposite of the COMMIT statement.

It ends the transaction but undoes any changes made during the transaction. All transactional

locks are released from the tables.

Syntax:

ROLLBACK [TO [SAVEPOINT] <savepointname>];

SAVEPOINT is optional and is used to roll back a transaction partially.

savepointname is a savepoint ceated during the current transaction.

Creating a SAVEPOINT:

SAVEPOINT is used to mark and save the current point in the processing of a transaction. If a

SAVEPOINT is used with a ROLLBACK statement, parts of a transaction can be undone. An

Prof. Mukesh N Tekwani [email protected]


active SAVEPOINT is one that is specified since the last COMMIT or ROLLBACK.

Syntax:

SAVEPOINT <savepointname>;

A ROLLBACK command can be given even without giving the SAVEPOINT clause.

If the ROLLBACK command is given without the SAVEPOINT option, the following take

place:

1. It ends the current transaction.

2. Undoes all the changes in the current transaction

3. Erases all the savepoints in that transaction

4. Releases the transactional locks.

If the ROLLBACK command is given with the TO SAVEPOINT option, the following take

place:

1. A predetermined portion of the transaction is rolled back

2. Retains the save point rolled to but loses those created after the savepoint.

3. Releases all transactional locks

3 Write a PL/SQL block of code that first withdraws an amount of Rs 1000. Then deposits

an amount of Rs 1,40,000. Update the current balance. Then check to see that the current

balance of all the accounts in the bank does not exceed 2,00,000. If the balance exceeds

2,00,000, then undo the deposit just made.

DECLARE

mBAL NUMBER(8, 2);

BEGIN

/* insert a record into TRANSMSTR for withdrawls */

INSERT INTO TRANSMSTR (TRANSNO, ACCTNO, DT, TYPE, TDETAILS,

DR_CR, AMT, BALANCE);

VALUES (‘T100’, ‘SB10’, ‘07-OCT-2010’, ‘W’, ‘Mobile Bill’, ‘W’, 1000, 30000);

/*Update the current balance of this account no, in the ACCTMSTR table */

UPDATE ACCTMSTR

SET CURBAL = CURBAL – 1000

WHERE ACCTNO = ‘SB10’;

/* Define a savepoint */

SAVEPOINT no_update;

/*insert a record into transactionmaster for deposits */

INSERT INTO TRANSMSTR (TRANSNO, ACCTNO, DT, TYPE, TDETAILS,

DR_CR, AMT, BALANCE);

VALUES (‘T101’, ‘SB10’, ‘07-OCT-2010’, ‘C’, ‘Deposit’, ‘D’, 14000, 171000);

/* update the current balance of account no SB10 in the ACCTMSTR table */

UPDATE ACCTMSTR SET CURBAL = CURBAL + 140000 WHERE ACCTNO =

‘SB10’;

/*store the total current balance from the ACCTMSTR table into a variable */

SELECT SUM(CURBAL) INTO mBAL from acctmstr;



/* Now check if the current balance exceeds 200000 */

IF mBAL > 200000 THEN

/* undo the changes made to the transaction master table */

ROLLBACK TO SAVEPOINT no_update;

END IF;

/* make the changes permanent */

COMMIT;

END;

4 Explain the modes of processing PL/SQL block.

A PL/SQL block can be run in one of the two modes:

1) Batch processing mode in which records are gathered in a table and are manipulated at

regular intervals.

2) Real-time processing – in this, records are manipulated as they are created.

Batch processing is a PL/SQL block that is run at the SQL prompt at regular intervals to

process the table data. This can be done in Oracle using the technique called ‘cursors’.

Processing of SQL statements by Oracle:

Whenever an SQL statement is executed, Oracle engine performs the following tasks:

a) Reserves a private SQL area in memory.

b) Populates this area with data requested in the SQL sentence.

c) Processes the data in this memory area as required.

d) Frees the memory area when the processing of data is completed.

5 What is a cursor? State and explain the different types of cursors.

1. The Oracle engine uses a work area for its internal processing in order to execute an SQL

statement. This work area is private to SQL and is called a cursor.

2. The data that is stored in the cursor is called the active data set.

3. The size of the cursor in memory is the size required to hold the number of rows in the

active data set. But the actual size depends on the Oracle engine’s built in memory

management capabilities and also on the amount of RAM.

4. Oracle has a pre-defined area in main memory and cursors are opened in this area.

5. The values retrieved from a table are held in a cursor in memory by the Oracle Engine. Thi

data is transferred to the client over the network. A cursor is opened at the client end so

that data can be held at the client end.

6. If the number of rows returned by the Oracle engine is more than the area available in the

cursor at the client end, the cursor data and the retrieved data are swapped between the

operating system’s swap area and RAM.

7. When a cursor is loaded with multiple rows, the Oracle engine opens and maintains a row

pointer. This row pointer will be relocated within the cursor area if the user changes the

view.

8. Oracle also maintains multiple cursor variables which indicate the status of processing

being done by the cursor.

TYPES OF CURSORS:

Oracle uses two types of cursors: these are called the implicit cursor and the explicit cursor. If

the Oracle engine opens a cursor for its own internal processing, it is known as the implicit

cursor. A cursor can also be opened on demand and such a cursor is called an explicit cursor.



Attributes of Cursors:

1. When the Oracle engine creates an implicit or explicit cursor, it also creates cursor control

variables.

2. These variables are used to control the execution of the cursor.

3. There are four system variables that keep track of the current status of the cursor. These

cursor variables can be used in a PL/SQL block.

4. The four attributes of all cursors are:

Attribute Name Description

%ISOPEN Returns TRUE if the cursor is open, FALSE otherwise

%FOUND Returns TRUE if record was fetched successfully, FALSE

otherwise

%NOTFOUND Returns TRUE if record was not fetched successfully, FALSE

otherwise

%ROWCOUNT Returns number of records processed from the cursor

6 Write a note on Implicit cursor.

1. The Oracle Engine implicitly opens a cursor on the server to process each SQL statement.

2. This cursor is opened and managed by the Oracle engine internally and therefore the

functions of reserving an area in memory, populating this area with proper data, processing

the data in memory, and releasing the memory when the processing is complete, is taken

care of by the Oracle engine.

3. The resultant (processed) data is then passed to the client through the network.

4. A cursor is now opened in the memory of the client machine to hold the rows returned by

the Oracle engine. The number of rows held in the cursor on the client machine is managed

by the client’s OS and its memory area.

5. Implicit cursor attributes: These can be used to get information about the status of the last

INSERT, UPDATE, DELETE or single row SELECT statements.

6. The values of the cursor attributes always refer to the most recently executed SQL

statement.

7. If an attribute value is to be saved for later use, it must be assigned to a boolean memory

variable.

8. The implicit cursor attributes are as follows:

Attribute Name Description

%ISOPEN The Oracle engine automatically opens and closes the SQL

cursor after executing the INSERT, DELETE, SELECT, or

UPDATE operations. Thus, the SQL%ISOPEN attribute of an

implicit cursor cannot be referenced outside of its SQL

statement. Hence, SQL%ISOPEN always evaluates to FALSE.

%FOUND This evaluates to TRUE if an INSERT, UPDATE, or DELETE

affected one or more rows, or a single-row SELECT returned

one or more rows. Otherwise it evaluates to FALSE. This

attribute can be accessed as follows: SQL%FOUND.

%NOTFOUND This is the logical opposite of the %FOUND attribute. It

evaluates to TRUE if the INSERT, UPDATE or DELETE did

not any rows. Otherwise it evaluates to FALSE.

%ROWCOUNT Returns number of records affected by an INSERT, UPDATE,

or DELETE statements. Syntax is : SQL%ROWCOUNT



Example 1: A bank manager has decided to transfer employees across branches. Write

PL/SQL code to accept an employee number and the branch number followed by updating the

branch number of that employee to which he belongs. Display an appropriate message using

SQL%NOTFOUND based on the non-existence of the record in the EMP_MSTR table.

BEGIN

UPDATE EMP_MSTR SET BRANCH_NO = &BRANCH_NO

WHERE EMPNO = &EMPNO

IF SQL%FOUND THEN

DBMS_OUTPUT.PUT_LINE (“Employee successfully transferred”);

END IF;

IF SQL%NOTFOUND THEN

DBMS_OUTPUT.PUT_LINE (“Employee number does not exist”);

END IF;

END;

Example 2:

The bank manager of Bandra branch decides to activate all those accounts which were

previously marked as inactive for performing no transactions in the last 365 days. Write a

PL/SQL block to update the status of accounts. Display an appropriate message based on the

number of rows affected by the update fired.

DECLARE

Rows_Affected char(4);

BEGIN

UPDATE ACCT_MSTR SET STATUS = ‘A’ WHERE STATUS = ‘S’ AND

BRANCH_NO IN (SELECT BRANCH_NO FROM BRANCH_MSTR WHERE

NAME = ‘Bandra’);

Rows_Affected := TO_CHAR(SQL%ROWCOUNT);

IF SQL%ROWCOUNT > 0 THEN

DBMS_OUTPUT.PUT_LINE(Rows_Affected || ‘accounts activated

successfully’);

ELSE

DBMS_OUTPUT.PUT_LINE(‘Currently there are no inactive accounts in the

Bandra branch’);

END IF;

END;

Example 3: In this code, we use implicit cursors to display a message stating whether or not

employee’s salaries were updated.

DECLARE

var_rows number(5);

BEGIN

UPDATE employee

SET salary = salary + 1000;

IF SQL%NOTFOUND THEN

dbms_output.put_line('None of the salaries where updated');



ELSIF SQL%FOUND THEN

var_rows := SQL%ROWCOUNT;

dbms_output.put_line('Salaries for ' || var_rows || 'employees are updated');

END IF;

END;

7 Write a note on Explicit cursor.

1. Explicit cursors must be created when you are executing a SELECT statement that returns

more than one row. Even though the cursor stores multiple rows (or records), only one row

can be processed at a time and this row is called the current row.

2. When individual records in a table have to be processed inside a PL/SQL code block, a

cursor is used. This cursor will be declared and mapped to a SQL query in the DECLARE

section of the PL/SQL block and used within the executable section. A cursor created in

this way is called an explicit cursor.

3. Steps involved in using an explicit cursor:

a. Declare a cursor mapped to a SQL SELECT statement that retrieves data for

processing.

b. Open the cursor.

c. Fetch data from the cursor, one row at a time into memory variables.

d. Process the data held in the memory variables as required using a loop.

e. Exit from the loop after processing is completed.

f. Close the cursor.

4. Cursor Declaration: A cursor is define din the DECLARE section of the PL/SQL code

block. This is done by naming the cursor and mapping it to a query. When a cursor is

declared, the Oracle engine is informed that a cursor needs to be opened. This declaration

does not allocate memory. The three commands used to control the explicit cursor are :

open, fetch and close.

5. Working of the Open, Fetch and Close commands:

a. The initialization of a cursor takes place through the open statement. This

statement defines a private area named after the cursor name. It also executes the

query associated with the cursor, retrieves the table and populates the area in

memory i.e., it creates the Active Data Set. It also sets the cursor row pointer to the

first record in the Active data Set. Syntax: OPEN cursorname;

b. The fetch statement then moves the data held in the Active Data Set into memory

variables. The fetch statement is placed inside a LOOP…END LOOP structure and

through this data can be fetched into memory variables and processed until all rows

in the Active Data Set are processed. The fetch loop then exits. Syntax: FETCH

cursorname INTO var1, var2, …Note that there must be a variable name for each

column value of the active data set and the data types must match. These variables

used for the fetch statement are declared in the DECLARE section.

c. After the fetch loop exits, the cursor must be closed with the close statement. This

will release the memory occupied by the cursor and its Active Data Set both on the

client and the server. Syntax: CLOSE cursorname. Once a cursor is closed, the

reopen statement is used to reopen the cursor.

6. Syntax of declaring cursor is: CURSOR cursorname IS SELECT statement;

7. Explicit cursor attributes: The four attributes are similar to those used for implicit cursor.

The attributes can be used in PL/SQL block for processing of data or for exiting. The

cursor name is appended to the attribute name when referring to an attribute.

8. The general format of using an explicit cursor is as follows:



DECLARE

variables;

create a cursor;

BEGIN

OPEN cursor;

FETCH cursor;

process the records;

CLOSE cursor;

END;

Example 1: The bank manager has decided to mark all those accounts as inactive (I) on which

there are no transactions performed in the last 365 days. Whenever any such update takes

place, a record for the same is maintained in the INACTIVE_MSTR table which contains the

account number, the opening date and the type of account. Write a PL/SQL block to implement

this.

We first create the INACTIVE_MSTR table as follows:

CREATE TABLE INACTIVE_MSTR

(ACCTNO VARCHAR2(10),

OPENDT DATE,

TYPE VARCHAR2(2));

Now we write the PL/SQL code block:

DECLARE

CURSOR Crsr_NoTrans IS

SELECT ACCTNO, STATUS, OPENDT, TYPE FROM ACCT_MSTR

WHERE ACCTNO IN (SELECT ACCTNO FROM TRANS_MSTR

GROUP BY ACCTNO HAVING MAX(SYSDATE – OPENDT) > 365;

/* declare memory variables to hold data fetched from the cursor */

str_ACCTNO ACCTMSTR.ACCTNO%TYPE;

str_STATUS ACCTMSTR.STATUS%TYPE;

dt_OPENDT ACCTMSTR.OPENDT%TYPE;

str_TYPE ACCTMSTR.TYPE%TYPE;

BEGIN

OPEN Crsr_NoTrans;

/* if the cursor is open, continue with the data processing else display an appropriate

error message */

IF Crsr_NoTrans%ISOPEN THEN

LOOP

FETCH Crsr_NoTrans INTO str_ACCTNO, str_STATUS, dt_OPENDT,

str_TYPE;

EXIT WHEN Crsr_NoTrans%NOTFOUND;

IF Crsr_NoTrans%FOUND THEN

/*update status to ‘I’ and insert each record into the INACTIVE_MSTR

table */

UPDATE ACCTMSTR SET STATUS = ‘I’ WHERE ACCTNO =



str_ACCTNO;

INSERT INTO INACTIVE_MSTR VALUE (str_ACCTNO,

dt_opendt, str_TYPE);

END IF;

END LOOP;

/*make the changes permanent */

COMMIT

ELSE

Dbms_output.put_line (‘Error: Unable to open cursor’);

END IF;

CLOSE Crsr_NoTrans;

END;

In the above example, the %TYPE means that the data type of these variables will be as that

from the table.

Since the query may return more than one row, a loop is created which does the following:

(i) Fetch the data retrieved by the cursor into the variable.

(ii) Check if any data is retrieved

a. Update the status field of the AACT_MSTR table to indicate that the account is

inactive.

b. Insert a record in the INACTIVE_MSTR table

(iii) Repeat the above steps until the data retrieval process is completed.

(iv) Finally, the COMMIT statement is executed to make the changes permanent.

Example 2: Write a PL/SQL block that will display the customer name, the fixed deposit

number and the fixed deposit amount of the first 5 customers holding the highest amount in

fixed deposits.

DECLARE

CURSOR Crsr_HiFD IS

SELECT Fname || ‘ ‘ || LNAME, FDNO, AMT

FROM CUST_MSTR C, ACCT_FD_CUST_DETAILS A, FD_DETAILS F

WHERE C.CUSTNO = A.CUSTNO AND A.FDNO = F.FDSRNO

ORDER BY AMT Desc;

str_NAME VARCHAR2(40);

str_FDNO FD_DETAILS.FDNO%type;

num_AMT FD_DETAILS.AMT%type;

BEGIN

OPEN Crsr_HiFD;

dbms_output.put_line (‘Name FD No. Amount’);

dbms_output.put_line (‘-------------------------------------------------------------’);

LOOP

FETCH Crsr_HiFD INTO str_NAME, str_FDNO, num_AMT;

EXIT WHEN (Crscr_HiFD%ROWCOUNT-1) = 5 OR

Crscr_HiFD%NOTFOUND;

dbms_output.put_line (str_NAME || ‘ ‘ || str_FDNO || ‘ ‘ || num_AMT);



END LOOP;

END;

To retrieve the records, both the tables have to be linked on the basis of common columns

using join as follows:

• C.CUSTNO = A.CUSTNO; this means the CUSTNO field of CUSTMSTR table is

joined with the CUSTNO field of ACCT_FD_CUST_DETAILS table.

8 Explain Cursor For Loops in PL/SQL.

The FOR loop is used in PL/SQL to control the looping in PL/SQL block.

The general syntax of this construct is :

FOR memoryvariable IN cursorname

The keyword FOR automatically creates the memory variable of the %rowtype. Each record

in the opened cursor becomes a value for the memory variable of the %rowtype. We also do

not open, fetch and close the cursor because these functions are done by the FOR statement

automatically.

Thus, the cursor FOR loop does the following automatically:

1. Implicitly declares its loop index as a %rowtype record.

2. Opens a cursor.

3. Fetches a row from the cursor for each loop iteration.

4. Closes the cursor when all the rows have been processed.

The general syntax for using FOR LOOP is :

FOR record_name IN cusror_name

LOOP

process the row...

END LOOP;

Example 1:

DECLARE

CURSOR emp_cur IS

SELECT first_name, last_name, salary FROM emp_tbl;

emp_rec emp_cur%rowtype;

BEGIN

FOR emp_rec IN sales_cur

LOOP

dbms_output.put_line(emp_cur.first_name || ' ' ||emp_cur.last_name || ' '

||emp_cur.salary);

END LOOP;

END;

In the above example, when the FOR loop is processed a record ‘emp_rec’ of structure

‘emp_cur’ gets created, the cursor is opened, the rows are fetched to the record ‘emp_rec’ and

the cursor is closed after the last row is processed. By using FOR Loop in our program, we can

reduce the number of lines in the program.



Example 2: The bank manager has decided to marks all those accounts as inactive (I) on

which there are no transactions performed in the last 365 days. Whenever any such update

takes place, a record for the same is maintained in the INACTIVE_MSTR table. This table

consists of the fields account number, opening date and type of account. Write PL/SQL code

block to do the same.

First we create the INACTIVE_MSTR table.

CREATE TABLE IANCTIVE_MSTR (

ACCTNO VARCHAR2(10),

OPENDT DATE,

ACCTYPE VARCHAR2(2));

Now we write the PL/SQL code block:

DECLARE

CURSOR Crsr_NoTrans IS

SELECT ACCTNO, STATUS, OPENDT, ACCTYPE FROM ACCTMSTR

WHERE ACCTNO IN (SELECT ACCTNO FROM TRANSMSTR

GROUP BY ACCTNO

HAVING MAX(SYSDATE – OPENDT) > 365;

BEGIN

/* we use the cursor FOR loop */

FOR NoTransRec IN Crsr_NoTrans

/* update the inactive status and insert each record into the INACTIVE_MSTR table */

UPDATE ACCT_MSTR SET STATUS = ‘I’

WHERE ACCTNO= NoTransRec.ACCTNO;

INSERT INTO INACTIVE_MSTR VALUES(NoTransRec.ACCTNO, NoTransRec.OPENDATE, NoTransRec.ACCTYPE);

END LOOP;

COMMIT;

END;

Since a FOR loop is used in this example, we did not declare any variables. The cursor closes

automatically when all the records have been processed. This is because there are no more

records left to load into NoTransRec. Finally, the COMMIT statement is fired to make the

changes permanent.

9 What are parameterized cursors?

Parameters provide a way to pass information into and out of a module. PL/SQL allows us to

pass parameters into a cursor.

The reasons for using parameterized cursor are:

• A parameter makes the cursor more reusable. Instead of hardcoding a value into the

WHERE clause of a query to select particular information, we can use a parameter and

then pass different values to the WHERE clause each time a cursor is opened.

• A parameter avoids scoping problems. When we pass parameters instead of hardcoding

values, the result set for that cursor is not tied to a specific variable in a program or

block. If the program has nested blocks, we can define the cursor at a higher-level

(enclosing) block and use it in any of the sub-blocks with variables defined in those



local blocks.

Most commercial applications will require that the query which defines the cursor, be general

in nature and the data that is retrieved from the table be allowed to change according to the

users need. Oracle permits the use of parameterized cursor. The contents of the parameterized

cursor will change depending upon the value passed to its parameter.

Since the cursor accepts user0-defined values into its parameters, thus changing the result set

extracted from the table, it is called as a parameterized cursor.

Declaring a parameterized cursor:

CURSOR cursorname (varname datatype) IS <SELECT statement…>

Opening a parameterized cursor and passing values to it:

OPEN cursorname (vale/variable/expression)

The scope of the cursor parameter is confined to that cursor. You cannot refer to the cursor

parameter outside of the SELECT statement associated with the cursor.

Example 1:

Write a PL/SQL code block that will merge the data available in the newly created table

NEW_BRANCHES with the data available in the table BRANCH_MASTER. If the data in the

first table already exists in the second table, then that data should be skipped.

CREATE TABLE NEW_BRANCHES(

BRANCHNO VARCHAR2(10),

NAME VARCHAR2(30));

INSERT INTO NEW_BRANCHES (BRANCHNO, NAME) VALUES (‘B4’, ‘MAHIM’);

INSERT INTO NEW_BRANCHES (BRANCHNO, NAME) VALUES (‘B5’, ‘MATUNGA’);

INSERT INTO NEW_BRANCHES (BRANCHNO, NAME) VALUES (‘B6’, ‘DADAR’);

INSERT INTO NEW_BRANCHES (BRANCHNO, NAME) VALUES (‘B7’, ‘KHAR’);

Now WE WRITE THE PL/SQL CODE BLOCK:

DECLARE

/* This cursor retrieves all records of NEW_BRANCHES table */

CURSOR Crsr_Newbranches (str_BRANCHNAME VARCHAR2) IS

SELECT * FROM NEW_BRANCHES;

/* this cursor accepts the value of NAME from the current row of the cursor Crsr_Newbranches */

CURSOR Crsr_Branchchk (str_BRANCHNAME varchar2) IS

SELECT BRANCHNO FROM BRANCHMSTR

WHERE NAME = str_BRANCHNAME;

/* we create variables that hold the data from the cursor Crsr_Newbranches */

str_BRANCHNO BRANCH_MSTR.BRANCHNO.%TYPE;

str_BRANCHNNAME BRANCH_MSTR.NAME.%TYPE;

/* we create a variable that holds data from the cursor Crsr_Branchchk */

temp VARCHAR2(10);



BEGIN

/* open the Crsr_Newbranches cursor */

OPEN Crsr_Newbranches;

LOOP

/* fetch the records from the Crsr_Newbranches cursor */

FETCH Crsr_Newbranches INTO str_BRANCHNO, str_BRANCHNAME;

EXIT WHEN Crsr_Newbranches%NOTFOUND;

/* open the Crsr_Branchchk cursor. Note that the value of variable passed to the

CrsrBranchchk cursor is set to the value of NAME in the current row of the cursor

Crsr_Newbranches */

OPEN Crsr_Branchchk(str_BRANCHNAME);

FETCH Crsr_Branchchk INTO temp;

IF Crsr_BRANCHCHK%FOUND THEN

dbms_output.put_line (‘Branch ‘ || str_BRANCHNAME || ‘exists’);

ELSE

dbms_output.put_line (‘Branch ‘ || str_BRANCHNAME || ‘does not exist. Inserting

new branch in database’);

INSERT INTO BRANCH_MSTR VALUES (str_BRANCHNO,

str_BRANCHNAME);

END IF;

CLOSE Crsr_BRANCHCHK;

END LOOP;

CLOSE Crsr_Newbranches;

COMMIT;

END;

pl sql-ch2

Education