Initializing and Referencing Collections
-- (that is, first_name and last_name).
TYPE NameList IS VARRAY(20) OF c1%ROWTYPE; BEGIN
NULL;
END;
/
Example 5–7 VARRAY of Records
This example uses a RECORD type to specify the element type:
DECLARE
TYPE GlossEntry IS RECORD ( term VARCHAR2(20), meaning VARCHAR2(200) ); TYPE Glossary IS VARRAY(250) OF GlossEntry;
BEGIN NULL;
END;
/
Example 5–8 NOT NULL Constraint on Collection Elements
You can also impose a NOT NULL constraint on the element type:
DECLARE
TYPE EmpList IS TABLE OF employees.employee_id%TYPE NOT NULL; my_employees EmpList := EmpList(100, 150, 160, 200);
BEGIN
my_employees(3) := NULL; -- Assigning NULL raises an exception END;
/
Initializing and Referencing Collections
Until you initialize it, a nested table or varray is atomically null: the collection itself is null, not its elements. To initialize a nested table or varray, you use a constructor, a system-defined function with the same name as the collection type. This function "constructs" collections from the elements passed to it.
You must explicitly call a constructor for each varray and nested table variable. (Associative arrays, the third kind of collection, do not use constructors.) Constructor calls are allowed wherever function calls are allowed.
Example 5–9 Constructor for a Nested Table
The following example initializes a nested table using a constructor, which looks like a function with the same name as the collection type:
DECLARE
TYPE Colors IS TABLE OF VARCHAR2(16); rainbow Colors;
BEGIN
rainbow := Colors('Red','Orange','Yellow','Green','Blue','Indigo','Violet'); END;
/
Because a nested table does not have a declared maximum size, you can put as many elements in the constructor as necessary.
5-10 PL/SQL User's Guide and Reference
Initializing and Referencing Collections
Example 5–10 Constructor for a Varray
This example initializes a varray using a constructor, which looks like a function with the same name as the collection type:
DECLARE
--In the varray, we put an upper limit on the number of elements. TYPE Colors IS VARRAY(10) OF VARCHAR2(16);
rainbow Colors;
BEGIN
--Since COLORS is declared as VARRAY(10), we can put up to 10
--elements in the constructor.
rainbow := Colors('Red','Orange','Yellow','Green','Blue','Indigo','Violet');
END;
/
Example 5–11 Collection Constructor Including Null Elements
Unless you impose the NOT NULL constraint in the type declaration, you can pass null elements to a constructor:
DECLARE
TYPE Colors IS TABLE OF VARCHAR2(20); my_colors Colors;
TYPE ColorsNoNulls IS TABLE OF VARCHAR2(20) NOT NULL; BEGIN
my_colors := Colors('Sienna',NULL,'Teal','Umber',NULL);
--If MY_COLORS was of type ColorsNoNulls, we could not include
--null values in the constructor.
END;
/
Example 5–12 Combining Collection Declaration and Constructor
You can initialize a collection in its declaration, which is a good programming practice:
DECLARE
TYPE Colors IS TABLE OF VARCHAR2(20);
my_colors Colors := Colors('Brown','Gray','Beige'); BEGIN
NULL;
END;
/
Example 5–13 Empty Varray Constructor
If you call a constructor without arguments, you get an empty but non-null collection:
DECLARE
TYPE Colors IS VARRAY(100) OF VARCHAR2(20); my_colors Colors;
BEGIN
IF my_colors IS NULL THEN
dbms_output.put_line('Before initialization, the varray is null.');
--While the varray is null, we can't check its COUNT attribute.
--dbms_output.put_line('It has ' || my_colors.COUNT || ' elements.');
ELSE
dbms_output.put_line('Before initialization, the varray is not null.'); END IF;
my_colors := Colors(); -- initialize empty varray
Using PL/SQL Collections and Records 5-11
Initializing and Referencing Collections
IF my_colors IS NULL THEN
dbms_output.put_line('After initialization, the varray is null.'); ELSE
dbms_output.put_line('After initialization, the varray is not null.'); dbms_output.put_line('It has ' || my_colors.COUNT || ' elements.');
END IF; END;
/
In this case, you can call the collection's EXTEND method to add elements later.
Example 5–14 Nested Table Constructor Within a SQL Statement
In this example, you insert several scalar values and a CourseList nested table into the SOPHOMORES table.
BEGIN
INSERT INTO sophomores
VALUES (5035, 'Janet Alvarez', '122 Broad St', 'FT',
CourseList('Econ 2010', 'Acct 3401', 'Mgmt 3100'));
Example 5–15 Varray Constructor Within a SQL Statement
In this example, you insert a row into database table DEPARTMENT. The varray constructor ProjectList() provides a value for column PROJECTS.
BEGIN
INSERT INTO department
VALUES(60, 'Security', 750400,
ProjectList('New Badges', 'Track Computers', 'Check Exits'));
Referencing Collection Elements
Every reference to an element includes a collection name and a subscript enclosed in parentheses. The subscript determines which element is processed. To reference an element, you specify its subscript using the syntax
collection_name(subscript)
where subscript is an expression that yields an integer in most cases, or a VARCHAR2 for associative arrays declared with strings as keys.
The allowed subscript ranges are:
■For nested tables, 1 .. 2**31.
■For varrays, 1 .. size_limit, where you specify the limit in the declaration.
■For associative arrays with a numeric key, -2**31 .. 2**31.
■For associative arrays with a string key, the length of the key and number of possible values depends on the VARCHAR2 length limit in the type declaration, and the database character set.
Example 5–16 Referencing a Nested Table Element By Subscript
This example shows how to reference an element in the nested table NAMES:
DECLARE
TYPE Roster IS TABLE OF VARCHAR2(15);
names Roster := Roster('J Hamil', 'D Caruso', 'R Singh');
5-12 PL/SQL User's Guide and Reference