Need help tuning package.

Question

Hi,
I am trying to speed up a package I created which currently runs for more than an hour. What I have is a source table which has approximately 16M records. In the report I'm creating, I need to re-use this table 48 times to get the sum of a column for the next 48 weeks.
Initially I created 48 inline views of this table, one for each week but this was very slow. Took more than 3 hours. Then I decided to create a global temporary table with only the columns I need. I populate this table with only needed records so basically around 600K rows. I also added a column "WEEK" and created a function in my package to determine what week the record belongs to depending on its date. So my code looks something like below.
insert into my_table_gtt  ( inventory_item_id
                           , organization_id
                           , compile_designator
                           , using_assembly_demand_date
                           , using_requirements_quantity
                           , week )
select inventory_item_id
     , organization_id
     , compile_designator
     , decode(sign(using_assembly_demand_date-trunc(sysdate)), -1, trunc(sysdate), using_assembly_demand_date)
     , using_requirements_quantity
     , my_pkg.week(decode(sign(using_assembly_demand_date-trunc(sysdate)), -1, trunc(sysdate), using_assembly_demand_date))
from my_table_source mgr
where mgr.compile_designator = 'XXXXXX'
and mgr.organization_id = p_org_idPutting the code above, it takes about an hour and 15 minutes to finish the insert. Then around 15 more minutes to build the report.
Is there any way I can make this run faster?
Adding function week.
  function week(p_date date) return number
  is
    l_week number;
  begin
  select case
          when p_date between my_pkg.next('MON',1) and my_pkg.next('SUN',1) then 1
          when p_date between my_pkg.next('MON',2) and my_pkg.next('SUN',2) then 2
          when p_date between my_pkg.next('MON',3) and my_pkg.next('SUN',3) then 3
          when p_date between my_pkg.next('MON',4) and my_pkg.next('SUN',4) then 4
          when p_date between my_pkg.next('MON',5) and my_pkg.next('SUN',5) then 5
          when p_date between my_pkg.next('MON',6) and my_pkg.next('SUN',6) then 6
          when p_date between my_pkg.next('MON',7) and my_pkg.next('SUN',7) then 7
          when p_date between my_pkg.next('MON',8) and my_pkg.next('SUN',8) then 8
          when p_date between my_pkg.next('MON',9) and my_pkg.next('SUN',9) then 9
          when p_date between my_pkg.next('MON',10) and my_pkg.next('SUN',10) then 10
          when p_date between my_pkg.next('MON',11) and my_pkg.next('SUN',11) then 11
          when p_date between my_pkg.next('MON',12) and my_pkg.next('SUN',12) then 12
          when p_date between my_pkg.next('MON',13) and my_pkg.next('SUN',13) then 13
          when p_date between my_pkg.next('MON',14) and my_pkg.next('SUN',14) then 14
          when p_date between my_pkg.next('MON',15) and my_pkg.next('SUN',15) then 15
          when p_date between my_pkg.next('MON',16) and my_pkg.next('SUN',16) then 16
          when p_date between my_pkg.next('MON',17) and my_pkg.next('SUN',17) then 17
          when p_date between my_pkg.next('MON',18) and my_pkg.next('SUN',18) then 18
          when p_date between my_pkg.next('MON',19) and my_pkg.next('SUN',19) then 19
          when p_date between my_pkg.next('MON',20) and my_pkg.next('SUN',20) then 20
          when p_date between my_pkg.next('MON',21) and my_pkg.next('SUN',21) then 21
          when p_date between my_pkg.next('MON',22) and my_pkg.next('SUN',22) then 22
          when p_date between my_pkg.next('MON',23) and my_pkg.next('SUN',23) then 23
          when p_date between my_pkg.next('MON',24) and my_pkg.next('SUN',24) then 24
          when p_date between my_pkg.next('MON',25) and my_pkg.next('SUN',25) then 25
          when p_date between my_pkg.next('MON',26) and my_pkg.next('SUN',26) then 26
          when p_date between my_pkg.next('MON',27) and my_pkg.next('SUN',27) then 27
          when p_date between my_pkg.next('MON',28) and my_pkg.next('SUN',28) then 28
          when p_date between my_pkg.next('MON',29) and my_pkg.next('SUN',29) then 29
          when p_date between my_pkg.next('MON',30) and my_pkg.next('SUN',30) then 30
          when p_date between my_pkg.next('MON',31) and my_pkg.next('SUN',31) then 31
          when p_date between my_pkg.next('MON',32) and my_pkg.next('SUN',32) then 32
          when p_date between my_pkg.next('MON',33) and my_pkg.next('SUN',33) then 33
          when p_date between my_pkg.next('MON',34) and my_pkg.next('SUN',34) then 34
          when p_date between my_pkg.next('MON',35) and my_pkg.next('SUN',35) then 35
          when p_date between my_pkg.next('MON',36) and my_pkg.next('SUN',36) then 36
          when p_date between my_pkg.next('MON',37) and my_pkg.next('SUN',37) then 37
          when p_date between my_pkg.next('MON',38) and my_pkg.next('SUN',38) then 38
          when p_date between my_pkg.next('MON',39) and my_pkg.next('SUN',39) then 39
          when p_date between my_pkg.next('MON',40) and my_pkg.next('SUN',40) then 40
          when p_date between my_pkg.next('MON',41) and my_pkg.next('SUN',41) then 41
          when p_date between my_pkg.next('MON',42) and my_pkg.next('SUN',42) then 42
          when p_date between my_pkg.next('MON',43) and my_pkg.next('SUN',43) then 43
          when p_date between my_pkg.next('MON',44) and my_pkg.next('SUN',44) then 44
          when p_date between my_pkg.next('MON',45) and my_pkg.next('SUN',45) then 45
          when p_date between my_pkg.next('MON',46) and my_pkg.next('SUN',46) then 46
          when p_date between my_pkg.next('MON',47) and my_pkg.next('SUN',47) then 47
          when p_date between my_pkg.next('MON',48) and my_pkg.next('SUN',48) then 48
         end week
      into l_week
      from dual;
      return l_week;
  exception
    when no_data_found then
      return null;
  end week;Adding function next.
  function next(day varchar2, week number) return date
  is
    l_week number := week;
    l_first_monday date;
    l_today date := trunc(sysdate);
  begin
    if to_char(l_today,'DAY') = 'MONDAY' then
      l_first_monday := l_today;
    else
      if l_today > next_day(l_today,'MON') then
        l_first_monday := next_day(l_today,'MON');
      else
        l_first_monday := next_day(l_today-7,'MON');
      end if;
    end if;
    while l_week > 1
    loop
      return next_day(next(upper(day), l_week - 1),upper(day));
    end loop;
    if l_today > l_first_monday then
      return next_day(l_first_monday-1,upper(day));
    else
      return next_day(l_first_monday,upper(day));
    end if;
  end next;Thanks,
Allen
Edited by: Allen Sandiego on Jun 2, 2011 3:01 PM

Answer 1

SQL and PL/SQL are (very) different language and executed by different engines.
You can use PL/SQL user defined functions in SQL.. as you can use SQL inside PL/SQL source code. There is fairly tight integration between the two languages. But this does not mean that the languages are one, or that such code is executed by a single engine.
When you code something as follows in SQL:
select
  <some columns goes here>,
  MyPLSQLFunction( <some columns as params> )
from some_tableThe SQL engine parses and executes this SELECT. It has a call to a PL/SQL function. That requires the SQL engine, via an "expensive" context switch, call the PL/SQL engine and have the PL/SQL engine execute that function and returning a result.
If that SELECT selects a 1000 rows, it means a 1000 context switches to the PL/SQL engine for executing that function. This does not scale well. The more loop iterations there are, the more context switching and the bigger the overhead and impact on performance.
Thus it is better to say inside the SQL engine and rather consider doing that PL/SQL function code inside the SQL engine (using CASE statements for example).
If this proves to complex or difficult, you can look at implementing deterministic functions as PL/SQL functions. Deterministic means that the function will always return the same output for the same input - so it will always act in a pre-defined and determined way.
In that case (simplistically speaking), the SQL engine only need to make the context switch to the PL/SQL engine to execute the function, when the SQL engine has not call that function before with that specific set of parameter values. If it has, it simply re-uses the results previously returned by that function for that set of input parameter values.