Object Performace Problems

Question

In order to model a situation I need an object type to hold a table of objects of the enclosing type. In order to accomplish this I did the following (using 11.2.0.1 running on Windows 64-bit):
<li>declared a base type without the table of objects
<li>declared the table type to be a table of the base types
<li>declared the a sub-type of the base type that includes a member of the table type, as well as the functions and procedures I need.
This works fine. Because the table actually holds instances of the sub-type I have to use the treat function to cast table elements to the correct type, but this is not a problem.
The problem arises when I create constructor functions to allow me to not have to specify every data member when creating an instance of the sub-type. When the constructor includes a table instance as a parameter – which must be assigned to the member in the constructor – the performance degrades dramatically over calling the default constructor if the constructor is called multiple times.
I have distilled this down to a simple type with three members, two of which are declared in the base type, with the table member declared in the sub-type, as shown below.
h2. Type Definitions
-- base type --
create type base_t as object(
   text varchar2(16),
   val  int
) not final;
-- table type (of base type) --
create type table_t as table of base_t;
-- sub type specification --
create type sub_t under base_t(
   items table_t,
   constructor function sub_t(
      p_text  in varchar2)
      return self as result,
   constructor function sub_t(
      p_text  in varchar2,
      p_items in table_t)
      return self as result,
   member procedure output_text(
      p_level in pls_integer default 0)
-- sub type body --
create type body sub_t as
   constructor function sub_t(
      p_text  in varchar2)
      return self as result
   is
   begin
      self.text := p_text;
      return;
   end sub_t;
   constructor function sub_t(
      p_text  in varchar2,
      p_items in table_t)
      return self as result
   is
   begin
      self.text  := p_text;
      self.items := p_items;
      return;
   end sub_t;
   member procedure output_text(
      p_level in pls_integer default 0)
   is
      prefix varchar2(32767);
      sub    sub_t;
   begin
      for i in 1..p_level loop
         prefix := prefix || '  ';
      end loop;
      dbms_output.put_line(prefix || self.text);
      if self.items is not null then
         for i in 1..self.items.count loop
            sub := treat(items(i) as sub_t);
            sub.output_text(p_level + 1);
         end loop;
      end if;
   end;
end;I have also built a little testing routine that creates an object of the base_t type (with nested objects of the same type in the table member) in a loop, as shown below:
h2. Testing Routine
declare
   type timestamps_t is table of timestamp;
   ts1   timestamps_t := timestamps_t();
   ts2   timestamps_t := timestamps_t();
   obj   sub_t;
   dflt  boolean := true;
   times pls_integer := 10000;  
begin
   -- setup --
   ts1.extend(times);
   ts2.extend(times);
   -- iterate --
   for i in 1..times loop
      ts1(i) := systimestamp;
      if dflt then
         -- call default constructor --
         obj :=
            sub_t('1', null, table_t(
               sub_t('A'),
               sub_t('B', null, table_t(
                  sub_t('i', null, table_t(sub_t('a'))),
                  sub_t('ii'))),
               sub_t('C')));
      else
         -- call user-defined constructor --
         obj :=
            sub_t('1', table_t(
               sub_t('A'),
               sub_t('B', table_t(
                  sub_t('i', table_t(sub_t('a'))),
                  sub_t('ii'))),
               sub_t('C')));
      end if;
      ts2(i) := systimestamp;
   end loop;
   -- output timing --
   if times < 10 then
      for i in 1..times loop
         dbms_output.put_line('time '||i||' : '||(ts2(i) - ts1(i)));
      end loop;
   end if;
   dbms_output.put_line('total  : '||(ts2(times) - ts1(1)));
   -- output data --
   obj.output_text;     
end;When I execute the test routine as shown (with dflt = true and times = 10000) I get the following output (281 milliseconds to construct 10000 objects using the default constructor, with the expected contents displayed correctly):
h2. Output using Default Constructor (10000 times)
total  : +000000000 00:00:00.281000000
1
  A
  B
    i
      a
    ii
  C However, when I set dflt = false and set times = 7 I get the following output. The expected contents are still display correctly, but it takes over *4-1/2 seconds* to create just seven objects, but notice the geometric growth in time over each iteration. If I increase the number of iterations to 8, the routine eats the system and never returns!
h2. Output using User-Defined Constructor (7 times)
time 1 : +000000000 00:00:00.000000000
time 2 : +000000000 00:00:00.000000000
time 3 : +000000000 00:00:00.015000000
time 4 : +000000000 00:00:00.016000000
time 5 : +000000000 00:00:00.141000000
time 6 : +000000000 00:00:00.734000000
time 7 : +000000000 00:00:03.703000000
total  : +000000000 00:00:04.609000000
1
  A
  B
    i
      a
    ii
  CWhat gives? How can I use a custom constructor and at least approach the performance of using the default constructor? I have run the hierarchical profiler, which indicates the time is being consumed in the 2-parameter constructor.

Answer 1

You have prepared a wonderful reproducable case, which I would use in a service request for Oracle support.
You probably won't find many 'experts' on this forum that are experienced in the OO-features of PL/SQL. You might try the Objects forum: Objects . Allthough that forum does not seem to be very 'active'...