Thanks for that link. It’s worthing knowing. I’ll have to try to remember to fix up my examples from now on to use the right method; fortunately it’s not something I’ve ever put into production code (I think).

I should have edited that column out, I was running the test on a multi-CPU 32-bit virtual machine running Windows XP Pro, guesting under Windows 7 on a 64-bit multi-core machine, and the combinatin seems to do some strange things with timing occasionally.

In theory the plan is claiming that the query took about 5 minutes to run, when in practice the real elapsed time was much smaller.

select
        rownum id
from
        dual
connect by
        rownum <= 4000

returns the same as

select
        level id
from
        dual
connect by
        level <= 4000

see
http://asktom.oracle.com/pls/asktom/f?p=100:11:0::::P11_QUESTION_ID:12718072439781#36409968445172

Thanks for the link – the follow-on to Adrian Billington’s article on the topic is particularly useful: http://www.oracle-developer.net/display.php?id=408.

I am curious about the comment on Tanel’s article that the “with subquery” approach being faster than the inlne view – I only used “with” because I used to use “select rownum from all_objects” to generate the starting rows and either “with” or “no_merge” was a necessity, so I never checked for speed when I changed to the “connect by” approach.

create or replace function generator (n pls_integer) return sys.odcinumberlist pipelined is
  m pls_integer := trunc(n / 10);
  r pls_integer := n - 10 * m;
begin
  for i in 1 .. m loop
    pipe row (null);
    pipe row (null);
    pipe row (null);
    pipe row (null);
    pipe row (null);
    pipe row (null);
    pipe row (null);
    pipe row (null);
    pipe row (null);
    pipe row (null);
  end loop;  
  for i in 1 .. r loop
    pipe row (null);
  end loop;
end;
/
alter function generator compile plsql_code_type = native;

It's 0.67sec, but if I add rownum into count - time increases to 1.6sec:

SQL> set timing on
SQL> select count(*) from table(generator(1e7));

  COUNT(*)
----------
  10000000

Elapsed: 00:00:00.67
SQL> select count(rownum) from table(generator(1e7));

COUNT(ROWNUM)
-------------
     10000000

Elapsed: 00:00:01.60

have you checked this?

http://blog.tanelpoder.com/2008/06/08/generating-lots-of-rows-using-connect-by-safely/

Greetings.

I should probably have pointed out that the increase in the PGA memory was due to the increase in the UGA – which is located inside the PGA.

Very nice – and it’s only 1.18 seconds on my laptop (although that goes up to 2.23 if I gather plan statistics). More significantly it’s another option that doesn’t use a lot of memory.

I did wonder during the talk if there was going to be any real difference between using the subquery generator and a cartesian product or just the simple select with a larger value for rownum (level). You said the more complex form was quicker but not really how much {you did only have 10 minutes}. I was going to test it myself, so you have saved me the task. I think I will change how I generate my test data.

BTW I think you need to tidy up the info on PGA and UGA, as it stands it shows a massive increase in usage for both and you only say PGA in the text.