Working with Collection in PL/SQL

Question

Hi,
I am new in PL/SQL programming.
I am writing a PL/SQL stored procedure that have a "data collection" output argument. It extracts a list of data items (eg. id, temperature) from a table. The data items are stored in a collection (as the number of items is unknown therefore I am going to use nested table instead of varray). Some of the fields in the data items on the data collection will be transformed (eg. convert temperature from Fahrenheit to Celsius) before it is returned to the caller program.
* Question1:
How can I add data into a nested table (or varray) one at a time? (see sample codes below)
Eg.
I declared a nested table in the spec:
type test_record_t is record (
test_id number,
test_value number);
type test_list_t is table of test_record_t;
test record test_record_t;
test_list test_list_t;
Then in the body:
i := 1;
loop
fetch test_cursor into test_record;
exit when test_cursor%notfound;
test_list(i) := test_record; -- syntax error
i := i+1;
end loop;
All the examples I have seen so far that the list is populated when it is initialised:
Eg.
test_list := test_list_t(test_record1, test_record2);
but not
test_list(1) := test_record1;
test_list(2) := test_record2;
It could be that I am trying to implement the PL/SQL codes with my C/C++ thinking instead of PL/SQL. Do you have any suggestion?
* Question2:
How do you declare a PL/SQL procedure that have a nested table (or varray) output argument?
Eg.
PROCEDURE test_proc(data_list OUT ???);
Thank you very much and best regards,
Phil
PS. I am using Oracle 9.2

Answer 1

Phil, why are you using a collection to pass the data? PL/SQL collections reside in expensive PGA memory. Collections are thus not very scalable. The bigger they are, the less server memory for everyone else on the server. The more processes/sessions using your code, the more collections there are.. and again less server memory to go around for everyone else.
The primary reason for using collections in PL/SQL is to create a buffer that allows you to pass more rows between the PL and SQL engines in a single call. This reduces context switching and increases performance. PL in 10G already does this implicitly for you as bulk fetching/passing data is so critical to performance. PL/SQL collections allow you to explicitly manage this yourself.
Using a PL/SQL collection to "buffer" data for a client application is usually not the best of ideas. It involves using expensive PGA memory. It involves copying data from the inexpensive and scalable buffer cache into PL. It requires PL to crunch that data.
Typically doing all this in SQL is significantly faster and many times more scalable. E.g. using PL to construct the SQL statement that does this data crunching and processing, have PL create a cursor in the SQL engine for that statement, and then pass a reference handle to the client for using that cursor - fetching the data directly from the buffer cache and SQL engine.
Remember that despite the PL being very similar to other procedural languages, the environment it runs in is very different environment. Inside a database server process. With tight integration with the SQL engine.
PL is both a client language (it uses SQL as the server supplying data) and a server language (it is called by clients as a service on the server).
In order to use PL effectively, the very basic design rule is minimise PL/SQL and maximise SQL. Do not do in PL what SQL is perfectly capable of doing.. as the SQL engine will do it better and faster and more scalable than your PL code can ever do it.