Following Example shows a cursor named all_depts, and a record named dept that is based on that cursor.

Declaring a Record to Match a Cursor

1: DECLARE
2: CURSOR all_depts is
3: SELECT dept_id, dept_name
4: FROM department
5: ORDER BY dept_name;
6:
7: dept all_depts%ROWTYPE;
8: BEGIN
9: OPEN all_depts;
10:
11: LOOP
12: EXIT WHEN all_depts%NOTFOUND;
13: FETCH all_depts INTO dept;
14: DBMS_OUTPUT.PUT_LINE(dept.dept_name);
15: END LOOP;
16:
17: CLOSE all_depts;
18: END;
19: /

The cursor all_depts is declared in lines 2–5. In line 7, a record variable named
dept is declared based on the definition of the cursor. Because the variable dept
matches the cursor exactly, the FETCH statement in line 13 can fetch the results of the SELECT statement directly into the record. If at some point in the future you need to add columns to the select list, that change will automatically ripple through to the record definition,and the FETCH statement will continue to operate.

Here’s an example:

DECLARE
dept department%ROWTYPE;
BEGIN
SELECT * INTO dept
FROM department
WHERE dept_id = 502;
…
END;
/
You don’t have to use %ROWTYPE when you do this, and you don’t have to use SELECT * either. The Following Example  shows the dept record being declared without the use of %ROWTYPE,

Example

selects for department 452. If you don’t have that department,replace 452 with a valid number for your database.

Selecting Directly into a Record

1: DECLARE
2: TYPE dept_type IS RECORD
3: (
4: dept_id department.dept_id%type,
5: dept_name department.dept_name%type,
6: no_of_emps department.no_of_emps%type
7: );
8:
9: dept dept_type;
10: BEGIN
11: SELECT * INTO dept
12: FROM department
13: WHERE dept_id = 452;
14: END;
15: /

A record type named dept_type is defined in lines 2–7. The declaration in line 9
declares a variable named dept to be of type dept_type. Because the fields in the
dept_type record match exactly the fields in the Department table, the SELECT statement in lines 11–13 will work.

The Following example shows a SELECT statement other than SELECT *.

Selecting a Specific List of Fields into a Record

1: DECLARE
2: TYPE dept_type IS RECORD
3: (
4: dept_id department.dept_id%type,
5: dept_name department.dept_name%type,
6: no_of_emps department.no_of_emps%type
7: );
8:
9: dept dept_type;
10: BEGIN
11: SELECT dept_id, dept_name, no_of_emps INTO dept
12: FROM department
13: WHERE dept_id = 452;
14: END;
15: /
The three fields in the Department table are enumerated in the SELECT list.
Because the number of fields (and their datatypes) corresponds with the definition of the dept_type record, you are able to retrieve the data directly into a variable of  type dept_type.

The key thing to keep in mind when selecting data directly into a record is that the columns and datatypes represented in the SELECT list must correspond exactly to the fields and datatypes in the record definition. The column names and field names do not need to match, as Oracle assigns column values to fields in a record based on position,but the datatypes must match.

If you are using SELECT * to retrieve values from a table,you are safest using %ROWTYPE when declaring the record.

table_name%ROWTYPE;

where table_name is the name of the table. %ROWTYPE is a keyword that tells Oracle that the record should have one field for each column in the table, and that the datatypes of the fields should exactly match the datatypes of the columns.

The following example declares the variable dept so that it matches the definition of the Department table:

DECLARE
dept department%ROWTYPE;
…

The beauty of this is that a change to the table definition automatically ripples through to your PL/SQL code. You don’t need to manually hunt down and change record definitions.

Adding a column to a table would be transparent to your PL/SQL code, as
would certain types of datatype changes. However, if you drop a table column
that your code is using, you need to visit that code and make some
changes.

As with any other record, you use dot notation to reference a specific field. As far as PL/SQL is concerned, using department%ROWTYPE has the same effect as if you had declared the record like this:

DECLARE
TYPE dept_type IS RECORD
(
dept_id department.dept_id%type,
dept_name department.dept_name%type,
no_of_emps department.no_of_emps%type
);

dept dept_type;

If you’re working with all or most of the fields in a table, use %ROWTYPE to declare your records. You’ll save typing, and you’ll insulate your code somewhat from changes to the table.

By using records, you can group like data into one structure and then manipulate this structure as one entity or logical unit. This helps reduce coding and keeps the code easier to maintain and understand.

Declaring a Record Variable

In order to use a record, you must define the record by declaring a record type. Then,you must declare one or more PL/SQL variables to be of that type.

You declare a record type in the declaration portion of a PL/SQL block, subprogram, or package.

The following example declares a record type named emp_pay_salary:

TYPE emp_pay_salary IS RECORD –record declaration
(emp_id INTEGER(10),
emp_name VARCHAR2(32),
emp_sal NUMBER(9,2),
sal_type CHAR(1)
);

With the record type defined, you can then declare variables of that type, as in the following

example:
DECLARE
…
emp emp_pay_info;
…
BEGIN
…
After you have a record variable declared, you can use dot notation to reference the individual fields within the record. In the following example, the pay_type field in the emp record is referenced in an IF statement:

IF emp.sal_type = ‘S’ THEN…

Having related fields grouped together in a record allows you to more easily keep things together when you are passing those values as parameters to other program units.

This example shows the declaration for a procedure that takes a record of type emp_pay_info as a parameter:

procedure calculate_check (emp IN emp_pay_info) IS
…
Passing related values as a record not only makes your code more readable, but it makes it more maintainable as well. If you need to add another field to the emp_pay_info record, you only need to change the record definition, and that new value will be passed around everywhere that the record goes. If you were dealing with separate variables, you would have to change the header for every procedure and function that used the record.

Using the %TYPE Attribute in Records

If you’re declaring a record, and you want some of the field definitions to match definitions of columns in a database table, you can use the %TYPE attribute.To declare a variable to match a column definition, place an entry such as this in the declaration section of the PL/SQL block:

variable_name table_name.column_name%TYPE;

The %TYPE following the table and column name tells Oracle that you want the variable being declared to inherit its datatype and length from the definition of the named column.

The following example shows another way to define the emp_pay_info record
shown in the previous section:

TYPE emp_pay_salary IS RECORD
(emp_id employee.emp_id%TYPE,
emp_name employee.emp_name%TYPE,
sal_rate employee.pay_rate%TYPE,
sal_type employee.pay_type%TYPE
);

Using %TYPE like this helps insulate your PL/SQL code from changes in the underlying database columns. In the next section you’ll learn an even easier technique, using %ROWTYPE, that you can use when you want the record to contain fields for all columns in a table.