Convert normalized query to procedure to function

Question

Hi,
I have a table with this structure:
CREATE TABLE TRANS
  ITEM_ID    VARCHAR2(8 BYTE),
  ITEM_TYPE  VARCHAR2(20 BYTE),
  ITEM_YEAR  NUMBER,
  JAN        FLOAT(126),
  FEB        FLOAT(126),
  MAR        FLOAT(126),
  APR        FLOAT(126),
  MAY        FLOAT(126),
  JUN        FLOAT(126),
  JUL        FLOAT(126),
  AUG        FLOAT(126),
  SEP        FLOAT(126),
  OCT        FLOAT(126),
  NOV        FLOAT(126),
  DEC        FLOAT(126)
)I wrote the following PL/SQL to normalize the data into a few columns. Now I need help converting this to a package procedure, and this is where I am stuck.
DECLARE
   TYPE c IS REF CURSOR;
   cur    c;
   TYPE r IS RECORD (
      itm   trans.item_id%TYPE,
      mth   VARCHAR2 (3),
      val   FLOAT
   rec    r;
   stmt   VARCHAR2 (200);
   item   VARCHAR (8)    := 'AB054240';
BEGIN
   FOR i IN 1 .. 12
   LOOP
-- calls function to return abbreviated month name
      stmt :=
            'SELECT item_id,  get_month_abbrev ('
         || i
         || '), '
         || get_month_abbrev (i)
         || ' FROM trans t WHERE t.item_id = '''
         || item
         || '''';
      OPEN cur FOR stmt;
      LOOP
         FETCH cur
          INTO rec;
         EXIT WHEN cur%NOTFOUND;
-- test
         DBMS_OUTPUT.put_line ( rec.itm || chr(9) || rec.mth || chr(9) || rec.val);
      END LOOP;
   END LOOP;
   CLOSE cur;
END;In searching online, I got the idea of creating an Object Type for the 'record' type and a Collection Type for the table based on the former.
I would then open the table using a sys_refcursorUnfortunately, I could not get this to work. Ideally I would like to keep it all encapsulated in one procedure. I can't figure out a way to make an OUT parameter that will hold the table.
The end result is that I have a client program that will execute this procedure/function to return the normalized query result set for display.
Any suggestion or critique would be appreciated.

Answer 1

I still don't understand why you feel the need for looping round to create your dynamic SQL when you could just use static SQL (eg, like the query I gave you earlier)?
If you're wanting to take a row and turn it on its side, then the query I provided would do what you wanted:
with trans as (select 1 item_id, 'A' item_type, 2009 item_year, 10 jan, 20 feb, 30 mar, 40 apr, 50 may, 60 jun, 70 jul, 80 aug, 90 sep, 100 oct, 110 nov, 120 dec from dual union all
               select 1 item_id, 'A' item_type, 2008 item_year, 110 jan, 120 feb, 130 mar, 140 apr, 150 may, 160 jun, 170 jul, 180 aug, 190 sep, 1100 oct, 1110 nov, 1120 dec from dual union all
               select 2 item_id, 'C' item_type, 2009 item_year, 210 jan, 220 feb, 230 mar, 240 apr, 250 may, 260 jun, 270 jul, 280 aug, 290 sep, 2100 oct, 2100 nov, 2120 dec from dual),
-- end of mimicking data in your table
month_tab as (select 'JAN' month_name from dual union all
               select 'FEB' month_name from dual union all
               select 'MAR' month_name from dual union all
               select 'APR' month_name from dual union all
               select 'MAY' month_name from dual union all
               select 'JUN' month_name from dual union all
               select 'JUL' month_name from dual union all
               select 'AUG' month_name from dual union all
               select 'SEP' month_name from dual union all
               select 'OCT' month_name from dual union all
               select 'NOV' month_name from dual union all
               select 'DEC' month_name from dual)
SELECT tr.item_id "Item",
       mt.month_name "Month",
       DECODE(mt.month_name, 'JAN', tr.jan,
                             'FEB', tr.feb,
                             'MAR', tr.mar,
                             'APR', tr.apr,
                             'MAY', tr.may,
                             'JUN', tr.jun,
                             'JUL', tr.jul,
                             'AUG', tr.aug,
                             'SEP', tr.sep,
                             'OCT', tr.oct,
                             'NOV', tr.nov,
                             'DEC', tr.dec) "Amount"
FROM   trans tr,
       month_tab mt
WHERE  tr.item_id = 1 --p_item_id
AND    tr.item_year = 2009 --p_item_year;
      Item Month     Amount
         1 JAN           10
         1 FEB           20
         1 MAR           30
         1 APR           40
         1 MAY           50
         1 JUN           60
         1 JUL           70
         1 AUG           80
         1 SEP           90
         1 OCT          100
         1 NOV          110
         1 DEC          120There are several advantages for using one static query:
1. Easier to debug: the query is right there - you can copy it out of the procedure, change the parameters and then run it to see what values were being returned. You do not have to manually construct the query prior to running it.
2. Less code, less steps - therefore increased performance and easier maintenance. You no longer have an extra function call that the database needs to execute every time it runs the query.
3. More efficient code; no need to access the table 12 times, as the above query only accesses the table once. Again, leading to improved performance.
4. Easier to read and there maintain.
5. The PL/SQL engine won't check dynamic sql until runtime; if you've made a syntax error, the code will still compile, but will fail at runtime. With static SQL, the code won't compile until you've fixed all syntax errors.
6. Dynamic sql won't show up in the dependencies views (eg. user_dependencies), so makes it harder to track what tables are used by your code.
In short, avoid dynamic SQL if you can, stick to doing as much of the work in SQL as you can and hopefully you'll have faster and easier-to-maintain code.