What are Cursors?
https://www.computersprofessor.com/2017/09/what-are-cursors.html?m=0
What are Cursors:
A cursor is a temporary work area created in the system memory
when a SQL statement is executed. A cursor contains information on a select
statement and the rows of data accessed by it.
This temporary work area is used to store the data retrieved
from the database, and manipulate this data. A cursor can hold more than one
row, but can process only one row at a time. The set of rows the cursor holds
is called the active set.
There
are two types of cursors in PL/SQL:
mplicit cursors
These
are created by default when DML statements like, INSERT, UPDATE, and DELETE
statements are executed. They are also created when a SELECT statement that
returns just one row is executed.
Explicit cursors
They
must be created when you are executing a SELECT statement that returns more
than one row. Even though the cursor stores multiple records, only one record
can be processed at a time, which is called as current row. When you fetch a
row the current row position moves to next row.
Both
implicit and explicit cursors have the same functionality, but they differ in
the way they are accessed.
|
Implicit Cursors: Application
When
you execute DML statements like DELETE, INSERT, UPDATE and SELECT statements,
implicit statements are created to process these statements.
Oracle
provides few attributes called as implicit cursor attributes to check the
status of DML operations. The cursor attributes available are %FOUND,
%NOTFOUND, %ROWCOUNT, and %ISOPEN.
For
example, When you execute INSERT, UPDATE, or DELETE statements the cursor
attributes tell us whether any rows are affected and how many have been
affected.
When a SELECT... INTO statement is executed in a PL/SQL Block, implicit cursor attributes can be used to find out whether any row has been returned by the SELECT statement. PL/SQL returns an error when no data is selected.
The
status of the cursor for each of these attributes are defined in the below
table.
Attributes
|
Return
Value
|
Example
|
%FOUND
|
The
return value is TRUE, if the DML statements like INSERT, DELETE and UPDATE
affect at least one row and if SELECT ….INTO statement return at least one
row.
|
SQL%FOUND
|
The
return value is FALSE, if DML statements like INSERT, DELETE and UPDATE do
not affect row and if SELECT….INTO statement do not return a row.
|
||
%NOTFOUND
|
The
return value is FALSE, if DML statements like INSERT, DELETE and UPDATE at
least one row and if SELECT ….INTO statement return at least one row.
|
SQL%NOTFOUND
|
The
return value is TRUE, if a DML statement like INSERT, DELETE and UPDATE do
not affect even one row and if SELECT ….INTO statement does not return a row.
|
||
%ROWCOUNT
|
Return
the number of rows affected by the DML operations INSERT, DELETE, UPDATE,
SELECT
|
SQL%ROWCOUNT
|
For Example: Consider the PL/SQL
Block that uses implicit cursor attributes as shown below:
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;
In the
above PL/SQL Block, the salaries of all the employees in the ‘employee’ table
are updated. If none of the employee’s salary are updated we get a message
'None of the salaries where updated'. Else we get a message like for example,
'Salaries for 1000 employees are updated' if there are 1000 rows in ‘employee’
table.
Explicit Cursors
An explicit
cursor is defined in the declaration section of the PL/SQL Block. It
is created on a SELECT Statement which returns more than one row. We can
provide a suitable name for the cursor.
General Syntax for
creating a cursor is as given below:
CURSOR cursor_name IS select_statement;
cursor_name – A suitable name for the cursor.
select_statement – A
select query which returns multiple rows.
How to use Explicit Cursor?
There are four steps in using an Explicit Cursor.
- DECLARE the
cursor in the declaration section.
- OPEN the cursor
in the Execution Section.
- FETCH the data
from cursor into PL/SQL variables or records in the Execution Section.
- CLOSE the cursor
in the Execution Section before you end the PL/SQL Block.
1) Declaring a Cursor in the Declaration Section:
·
DECLARE
·
CURSOR emp_cur IS
·
SELECT *
·
FROM emp_tbl
·
WHERE salary > 5000;
In the above example we are creating a cursor ‘emp_cur’ on a
query which returns the records of all the employees with salary greater than 5000. Here ‘emp_tbl’ in the table which
contains records of all the employees.
2) Accessing the records in the cursor:
Once the cursor is created in the declaration section we can access the cursor in the execution section of the PL/SQL program.
Once the cursor is created in the declaration section we can access the cursor in the execution section of the PL/SQL program.
How to access an Explicit
Cursor?
These are the three steps in accessing the cursor.
1) Open the cursor.
2) Fetch the records in the cursor one at a time.
3) Close the cursor.
General
Syntax to open a cursor is:
OPEN cursor_name;
General Syntax to fetch records from a cursor
is:
FETCH cursor_name INTO record_name;
OR
FETCH cursor_name INTO variable_list;
General Syntax to close a cursor is:
CLOSE cursor_name;
When a cursor is opened, the first row becomes the current row.
When the data is fetched it is copied to the record or variables and the
logical pointer moves to the next row and it becomes the current row. On every
fetch statement, the pointer moves to the next row. If you want to fetch after
the last row, the program will throw an error. When there is more than one row
in a cursor we can use loops along with explicit cursor attributes to fetch all
the records.
Points
to remember while fetching a row:
· We can fetch the rows in a cursor to a PL/SQL Record or a list
of variables created in the PL/SQL Block.
· If you are fetching a cursor to a PL/SQL Record, the record should have the same structure as the cursor.
· If you are fetching a cursor to a list of variables, the variables should be listed in the same order in the fetch statement as the columns are present in the cursor.
General Form of using an explicit cursor is:
·
DECLARE
·
variables;
·
records;
·
create a cursor;
·
BEGIN
·
OPEN cursor;
·
FETCH cursor;
·
process the records;
·
CLOSE cursor;
·
END;
Explicit Cursor, Lets
Look at the example below
Example 1:
·
1> DECLARE
·
2> emp_rec emp_tbl%rowtype;
·
3> CURSOR emp_cur IS
·
4> SELECT *
·
5> FROM
·
6> WHERE salary > 10;
·
7> BEGIN
·
8> OPEN emp_cur;
·
9> FETCH emp_cur INTO emp_rec;
·
10> dbms_output.put_line (emp_rec.first_name ||
' ' || emp_rec.last_name);
·
11> CLOSE emp_cur;
·
12> END;
In the above example, first we are creating a record ‘emp_rec’
of the same structure as of table ‘emp_tbl’ in line no 2. We can also create a
record with a cursor by replacing the table name with the cursor name. Second,
we are declaring a cursor ‘emp_cur’ from a select query in line no 3 - 6.
Third, we are opening the cursor in the execution section in line no 8. Fourth,
we are fetching the cursor to the record in line no 9. Fifth, we are displaying
the first_name and last_name of the employee in the record emp_rec in line no
10. Sixth, we are closing the cursor in line no 11.