Error in Table Function (PIPELINE)

I executed the following:
CREATE OR REPLACE TYPE TYPE_BANK_STMT_DT_RANGE as object
COL1 VARCHAR2(200),
COL2 VARCHAR2(200),
COL3 VARCHAR2(200),
COL4 VARCHAR2(200),
COL5 VARCHAR2(200),
COL6 VARCHAR2(200),
COL7 VARCHAR2(200),
COL8 VARCHAR2(200),
COL9 VARCHAR2(200),
COL10 VARCHAR2(200)
CREATE OR REPLACE TYPE T_BANK_STMT_DT_RANGE as table of TYPE_BANK_STMT_DT_RANGE
CREATE OR REPLACE PROCEDURE FN_BANK_STMT_DT_RANGE (P_TNAME IN VARCHAR2,
P_GL_ACC IN VARCHAR2,
P_FROM_DT IN DATE,
P_TO_DT IN DATE,
P_FORMATSL IN NUMBER
RETURN T_BANK_STMT_DT_RANGE
PIPELINED IS
TYPE_BANK_STMT_DT_RANGE_TEMP TYPE_BANK_STMT_DT_RANGE := TYPE_BANK_STMT_DT_RANGE (NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL
TYPE R_COL IS RECORD (COL1 VARCHAR2(200),
COL2 VARCHAR2(200),
COL3 VARCHAR2(200),
COL4 VARCHAR2(200),
COL5 VARCHAR2(200),
COL6 VARCHAR2(200),
COL7 VARCHAR2(200),
COL8 VARCHAR2(200),
COL9 VARCHAR2(200),
COL10 VARCHAR2(200)
TYPE TY_TEMP_TAB IS TABLE OF R_COL INDEX BY PLS_INTEGER;
T_TEMP_TAB TY_TEMP_TAB;
BEGIN
V_SQL := 'SELECT * FROM TABLE_1'; --Actual query is different.
EXECUTE IMMEDIATE V_SQL
BULK COLLECT INTO T_TEMP_TAB;
FOR I IN 1..T_TEMP_TAB.COUNT
LOOP
TYPE_BANK_STMT_DT_RANGE_TEMP.COL1 := trim(TO_CHAR(T_TEMP_TAB(I).COL1));
TYPE_BANK_STMT_DT_RANGE_TEMP.COL2 := trim(TO_CHAR(T_TEMP_TAB(I).COL2));
TYPE_BANK_STMT_DT_RANGE_TEMP.COL3 := trim(TO_CHAR(T_TEMP_TAB(I).COL3));
TYPE_BANK_STMT_DT_RANGE_TEMP.COL4 := trim(TO_CHAR(T_TEMP_TAB(I).COL4));
TYPE_BANK_STMT_DT_RANGE_TEMP.COL5 := trim(TO_CHAR(T_TEMP_TAB(I).COL5));
TYPE_BANK_STMT_DT_RANGE_TEMP.COL6 := trim(TO_CHAR(T_TEMP_TAB(I).COL6));
TYPE_BANK_STMT_DT_RANGE_TEMP.COL7 := trim(TO_CHAR(T_TEMP_TAB(I).COL7));
TYPE_BANK_STMT_DT_RANGE_TEMP.COL8 := trim(TO_CHAR(T_TEMP_TAB(I).COL8));
TYPE_BANK_STMT_DT_RANGE_TEMP.COL9 := trim(TO_CHAR(T_TEMP_TAB(I).COL9));
TYPE_BANK_STMT_DT_RANGE_TEMP.COL10 := trim(TO_CHAR(T_TEMP_TAB(I).COL10));
PIPE ROW (TYPE_BANK_STMT_DT_RANGE_TEMP);
END LOOP;
EXCEPTION
WHEN OTHERS THEN
NULL;
END FN_BANK_STMT_DT_RANGE;
I got the error:
Error: PLS-00103: Encountered the symbol "RETURN" when expecting one of the following:
; is with authid as cluster order using external
deterministic parallel_enable pipelined
The symbol "authid was inserted before "RETURN" to continue.
Line: 9
Text: RETURN T_BANK_STMT_DT_RANGE
Please help to solve this.
Thanks in advance.

CREATE OR REPLACE PROCEDURE FN_BANK_STMT_DT_RANGE (P_TNAME IN VARCHAR2,
P_GL_ACC IN VARCHAR2,
P_FROM_DT IN DATE,
P_TO_DT IN DATE,
P_FORMATSL IN NUMBER
RETURN T_BANK_STMT_DT_RANGE
You are creating a PROCEDURE here, it must have been a function!!

Similar Messages

Oracle 11g Table function returns no records on first call

Hello,
On a Oracle 11g R2 I've a table function ( PIPELINED ) returning rows selected from a table.
The first time the function is selected, in a session ( I've tried to disconnect and log in again ), it returns no rows.
I've tried to log the call using DBMS_OUTPUT and from what I see the select on the table function returns no rows and no output is printed. So I presume Oracle is not calling the function.
The same function on a similar environment ( same db versions, patches and database structure ) works fine. The second environment is a production environment so it has more memory and some other settings enabled.
Does anyone know of settings that can relate to this behaviour ?
Thanks in advance for the help.
Regards,
Stefano Muret

Thank you for answering so fast.
Here's the function code:
FUNCTION template_parameters (iTemplate IN TEMPLATE_RAW_DATA.TMPL_ID%TYPE := NULL)
RETURN table_type_tmpl_parameters PIPELINED
IS
li_exception INTEGER DEFAULT -20025;
POUT_PARM TABLE_TYPE_TMPL_PARAMETERS;
lt_parms table_type_tmpl_parms_raw;
sParmCheck VARCHAR2(4000);
iOccurrence INTEGER;
BEGIN
pOut_Parm := table_type_tmpl_parameters();
pOut_Parm.EXTEND;
select
tmpl_id
*,tmpl_name*
*,replace(upper(trim(sql_out)),'[SCHEMA].')*
*,UPPER(TRIM(out_tmpl_parms))*
bulk collect into lt_parms
from ref_templates
where tmpl_id = NVL(iTemplate,tmpl_id)
order by tmpl_id;
FOR k IN 1..lt_parms.COUNT
LOOP
pOut_Parm(1).tmpl_id := lt_parms(k).tmpl_id;
pOut_Parm(1).tmpl_name := lt_parms(k).tmpl_name;
FOR i IN 1..2
LOOP
IF i = 1 THEN
sParmCheck := lt_parms(k).sql_out;
ELSE
sParmCheck := lt_parms(k).sql_parms;
END IF;
iOccurrence := 1;
*pOut_Parm(1).parameter_name := regexp_substr(sParmCheck,'\[[^\[]+\]',1,iOccurrence);*
WHILE pOut_Parm(1).parameter_name IS NOT NULL
LOOP
PIPE ROW (pOut_Parm(1));
iOccurrence := iOccurrence + 1;
*pOut_Parm(1).parameter_name := regexp_substr(sParmCheck,'\[[^\[]+\]',1,iOccurrence);*
END LOOP;
END LOOP;
END LOOP;
RETURN;
EXCEPTION
WHEN OTHERS THEN
RAISE_APPLICATION_ERROR(li_exception,SUBSTR(SQLERRM,1,1000));
RETURN;
END template_parameters;
This function is part of a package.
The data on both environments is the same.

Pipeline Table Function returning a fraction of data

My current project involves migrating an Oracle database to a new structure based on the new client application requirements. I would like to use pipelined table functions as it seems as though that would provide the best performance.
The first table has about 65 fields, about 75% of which require some type of recoding for the new app. I have written a function for each transformation and have all of these functions stored in a package. If I do:
create new_table as select (
pkg_name.function1(old_field1),
pkg_name.function2(old_field2),
pkg_name.function3(old_field3),
it runs with out any errors but takes about 3 1/2 hours. There are a little more than 10 million rows in the table.
I wrote a function that is passed the old table as a cursor, runs all the functions for the transformations and then pipes the new row back to the insert statement that called the function. It is incredibly fast but only returns .025% of the data (about 50 rows out of my sample table of 200,000). It does not throw any errors.
So I am trying to determine what is going on. Perhaps one of my functions has a bug. If there was would cause the row to be kicked out? There are 40 or so functions so tracking this down has been a bit of a bear.
Any advice as to how I might resolve this would be much appreciated.
Thanks
Dan

. I would like to use pipelined table functions as it seems as though that would provide the best performanceUh huh...
it runs with out any errors but takes about 3 1/2 hours. There are a little more than 10 million rows in the table.Not the first time a lovely theory has been killed by an ugly fact. Did you do any bench marks to see whether the pipelined functions did offer performance benefits over doing it some other way?
From the context of your comments I think you are trying to a populate a new table from a single old table. Is this the case? If so I would have thought a straightforward CTAS with normal functions would be more appropriate: pipelined functions are really meant for situations in which one input produced more than one output. Anyway, ifr we are to help you I think you need to give us more details about how this process works and post a sample transformation function.
There are 40 or so functions so tracking this down has been a bit of a bear.The teaching is: we should code one function and get that working before moving on to the next one. Which might not seem like a helpful thing to say, but the best lesson is often "I'll do it differently next time".
Cheers, APC

10g: delay for collecting results from parallel pipelined table functions

When parallel pipelined table functions are properly started and generate output record, there is a delay for the consuming main thread to gather these records.
This delay is huge compared with the run-time of the worker threads.
For my application it goes like this:
main thread timing efforts to start worker and collect their results:
[10:50:33-*10:50:49*]:JOMA: create (master): 015.93 sec (#66356 records, #4165/sec)
worker threads:
[10:50:34-*10:50:39*]:JOMA: create (slave) : 005.24 sec (#2449 EDRs, #467/sec, #0 errored / #6430 EBTMs, #1227/sec, #0 errored) - bulk #1 / sid #816
[10:50:34-*10:50:39*]:JOMA: create (slave) : 005.56 sec (#2543 EDRs, #457/sec, #0 errored / #6792 EBTMs, #1221/sec, #0 errored) - bulk #1 / sid #718
[10:50:34-*10:50:39*]:JOMA: create (slave) : 005.69 sec (#2610 EDRs, #459/sec, #0 errored / #6950 EBTMs, #1221/sec, #0 errored) - bulk #1 / sid #614
[10:50:34-*10:50:39*]:JOMA: create (slave) : 005.55 sec (#2548 EDRs, #459/sec, #0 errored / #6744 EBTMs, #1216/sec, #0 errored) - bulk #1 / sid #590
[10:50:34-*10:50:39*]:JOMA: create (slave) : 005.33 sec (#2461 EDRs, #462/sec, #0 errored / #6504 EBTMs, #1220/sec, #0 errored) - bulk #1 / sid #508
You can see, the worker threads are all started at the same time and terminating at the same time: 10:50:34-10:50:*39*.
But the main thread just invoking them and saving their results into a collection has finished at 10:50:*49*.
Why does it need #10 sec more just to save the data?
Here's a sample sqlplus script to demonstrate this:
--------------------------- snip -------------------------------------------------------
set serveroutput on;
drop table perf_data;
drop table test_table;
drop table tmp_test_table;
drop type ton_t;
drop type test_list;
drop type test_obj;
create table perf_data
     sid number,
     t1 timestamp with time zone,
     t2 timestamp with time zone,
     client varchar2(256)
create table test_table
     a number(19,0),
     b timestamp with time zone,
     c varchar2(256)
create global temporary table tmp_test_table
     a number(19,0),
     b timestamp with time zone,
     c varchar2(256)
create or replace type test_obj as object(
     a number(19,0),
     b timestamp with time zone,
     c varchar2(256)
create or replace type test_list as table of test_obj;
create or replace type ton_t as table of number;
create or replace package test_pkg
as
     type test_rec is record (
          a number(19,0),
          b timestamp with time zone,
          c varchar2(256)
     type test_tab is table of test_rec;
     type test_cur is ref cursor return test_rec;
     function TZDeltaToMilliseconds(
          t1 in timestamp with time zone,
          t2 in timestamp with time zone)
     return pls_integer;
     function TF(mycur test_cur)
return test_list pipelined
parallel_enable(partition mycur by hash(a));
end;
create or replace package body test_pkg
as
     * Calculate timestamp with timezone difference
     * in milliseconds
     function TZDeltaToMilliseconds(
          t1 in timestamp with time zone,
          t2 in timestamp with time zone)
     return pls_integer
     is
     begin
          return     (extract(hour from t2) - extract(hour from t1)) * 3600 * 1000
          +     (extract(minute from t2) - extract(minute from t1)) * 60 * 1000
          +     (extract(second from t2) - extract(second from t1)) * 1000;
     end TZDeltaToMilliseconds;
     function TF(mycur test_cur)
return test_list pipelined
parallel_enable(partition mycur by hash(a))
is
          pragma autonomous_transaction;
          sid number;
          counter number(19,0) := 0;
          myrec test_rec;
          mytab test_tab;
          mytab2 test_list := test_list();
          t1 timestamp with time zone;
          t2 timestamp with time zone;
     begin
          t1 := systimestamp;
          select userenv('SID') into sid from dual;
          dbms_output.put_line('test_pkg.TF( sid => '''|| sid || ''' ): enter');
          loop
               fetch mycur into myRec;
               exit when mycur%NOTFOUND;
               mytab2.extend;
               mytab2(mytab2.last) := test_obj(myRec.a, myRec.b, myRec.c);
          end loop;
          for i in mytab2.first..mytab2.last loop
               -- attention: saves own SID in test_obj.a for indication to caller
               --     how many sids have been involved
               pipe row(test_obj(sid, mytab2(i).b, mytab2(i).c));
               pipe row(test_obj(sid, mytab2(i).b, mytab2(i).c)); -- duplicate
               pipe row(test_obj(sid, mytab2(i).b, mytab2(i).c)); -- duplicate once again
               counter := counter + 1;
          end loop;
          t2 := systimestamp;
          insert into perf_data (sid, t1, t2, client) values(sid, t1, t2, 'slave');
          commit;
          dbms_output.put_line('test_pkg.TF( sid => '''|| sid || ''' ): exit, piped #' || counter || ' records');
     end;
end;
declare
     myList test_list := test_list();
     myList2 test_list := test_list();
     sids ton_t := ton_t();
     sid number;
     t1 timestamp with time zone;
     t2 timestamp with time zone;
procedure LogPerfTable
is
type ton is table of number;
type tot is table of timestamp with time zone;
          type clients_t is table of varchar2(256);
sids ton;
t1s tot;
t2s tot;
          clients clients_t;
deltaTime integer;
btsPerSecond number(19,0);
edrsPerSecond number(19,0);
begin
select sid, t1, t2, client bulk collect into sids, t1s, t2s, clients from perf_data order by client;
if clients.count > 0 then
for i in clients.FIRST .. clients.LAST loop
deltaTime := test_pkg.TZDeltaToMilliseconds(t1s(i), t2s(i));
if deltaTime = 0 then deltaTime := 1; end if;
dbms_output.put_line(
'[' || to_char(t1s(i), 'hh:mi:ss') ||
'-' || to_char(t2s(i), 'hh:mi:ss') ||
']:' ||
' client ' || clients(i) || ' / sid #' || sids(i)
end loop;
end if;
end LogPerfTable;
begin
     select userenv('SID') into sid from dual;
     for i in 1..200000 loop
          myList.extend; myList(myList.last) := test_obj(i, sysdate, to_char(i+2));
     end loop;
     -- save into the real table
     insert into test_table select * from table(cast (myList as test_list));
     -- save into the tmp table
     insert into tmp_test_table select * from table(cast (myList as test_list));
     dbms_output.put_line(chr(10) || '(1) copy ''mylist'' to ''mylist2'' by streaming via table function...');
     delete from perf_data;
     t1 := systimestamp;
     select /*+ first_rows */ test_obj(a, b, c) bulk collect into myList2
     from table(test_pkg.TF(CURSOR(select /*+ parallel(tab,5) */ * from table(cast (myList as test_list)) tab)));
     t2 := systimestamp;
     insert into perf_data (sid, t1, t2, client) values(sid, t1, t2, 'master');
     LogPerfTable;
     dbms_output.put_line('... saved #' || myList2.count || ' records');
     select distinct(tab.a) bulk collect into sids from table(cast (myList2 as test_list)) tab;
     dbms_output.put_line(chr(10) || '(2) copy temporary ''tmp_test_table'' to ''mylist2'' by streaming via table function:');
     delete from perf_data;
     t1 := systimestamp;
     select /*+ first_rows */ test_obj(a, b, c) bulk collect into myList2
     from table(test_pkg.TF(CURSOR(select /*+ parallel(tab,5) */ * from tmp_test_table tab)));
     t2 := systimestamp;
     insert into perf_data (sid, t1, t2, client) values(sid, t1, t2, 'master');
     LogPerfTable;
     dbms_output.put_line('... saved #' || myList2.count || ' records');
     select distinct(tab.a) bulk collect into sids from table(cast (myList2 as test_list)) tab;
     dbms_output.put_line(chr(10) || '(3) copy physical ''test_table'' to ''mylist2'' by streaming via table function:');
     delete from perf_data;
     t1 := systimestamp;
     select /*+ first_rows */ test_obj(a, b, c) bulk collect into myList2
     from table(test_pkg.TF(CURSOR(select /*+ parallel(tab,5) */ * from test_table tab)));
     t2 := systimestamp;
     insert into perf_data (sid, t1, t2, client) values(sid, t1, t2, 'master');
     LogPerfTable;
     dbms_output.put_line('... saved #' || myList2.count || ' records');
     select distinct(tab.a) bulk collect into sids from table(cast (myList2 as test_list)) tab;
end;
--------------------------- snap -------------------------------------------------------
best regards,
Frank

Hello
I think the delay you are seeing is down to choosing the partitioning method as HASH. When you specify anything other than ANY, an additional buffer sort is included in the execution plan...
create or replace package test_pkg
as
type test_rec is record (
a number(19,0),
b timestamp with time zone,
c varchar2(256)
type test_tab is table of test_rec;
type test_cur is ref cursor return test_rec;
function TZDeltaToMilliseconds(
t1 in timestamp with time zone,
t2 in timestamp with time zone)
return pls_integer;
function TF(mycur test_cur)
return test_list pipelined
parallel_enable(partition mycur by hash(a));
function TF_Any(mycur test_cur)
return test_list pipelined
parallel_enable(partition mycur by ANY);
end;
create or replace package body test_pkg
as
* Calculate timestamp with timezone difference
* in milliseconds
function TZDeltaToMilliseconds(
t1 in timestamp with time zone,
t2 in timestamp with time zone)
return pls_integer
is
begin
return (extract(hour from t2) - extract(hour from t1)) * 3600 * 1000
+ (extract(minute from t2) - extract(minute from t1)) * 60 * 1000
+ (extract(second from t2) - extract(second from t1)) * 1000;
end TZDeltaToMilliseconds;
function TF(mycur test_cur)
return test_list pipelined
parallel_enable(partition mycur by hash(a))
is
pragma autonomous_transaction;
    sid number;
    counter number(19,0) := 0;
    myrec test_rec;
    t1 timestamp with time zone;
    t2 timestamp with time zone;
begin
    t1 := systimestamp;
    select userenv('SID') into sid from dual;
    dbms_output.put_line('test_pkg.TF( sid => '''|| sid || ''' ): enter');
loop
    fetch mycur into myRec;
    exit when mycur%NOTFOUND;
    -- attention: saves own SID in test_obj.a for indication to caller
    -- how many sids have been involved
    pipe row(test_obj(sid, myRec.b, myRec.c));
    pipe row(test_obj(sid, myRec.b, myRec.c)); -- duplicate
    pipe row(test_obj(sid, myRec.b, myRec.c)); -- duplicate once again
    counter := counter + 1;
end loop;
t2 := systimestamp;
insert into perf_data (sid, t1, t2, client) values(sid, t1, t2, 'slave');
commit;
dbms_output.put_line('test_pkg.TF( sid => '''|| sid || ''' ): exit, piped #' || counter || ' records');
end;
function TF_any(mycur test_cur)
return test_list pipelined
parallel_enable(partition mycur by ANY)
is
pragma autonomous_transaction;
    sid number;
    counter number(19,0) := 0;
    myrec test_rec;
    t1 timestamp with time zone;
    t2 timestamp with time zone;
begin
    t1 := systimestamp;
    select userenv('SID') into sid from dual;
    dbms_output.put_line('test_pkg.TF( sid => '''|| sid || ''' ): enter');
    loop
      fetch mycur into myRec;
      exit when mycur%NOTFOUND;
      -- attention: saves own SID in test_obj.a for indication to caller
      -- how many sids have been involved
      pipe row(test_obj(sid, myRec.b, myRec.c));
      pipe row(test_obj(sid, myRec.b, myRec.c)); -- duplicate
      pipe row(test_obj(sid, myRec.b, myRec.c)); -- duplicate once again
      counter := counter + 1;
    end loop;
    t2 := systimestamp;
    insert into perf_data (sid, t1, t2, client) values(sid, t1, t2, 'slave');
    commit;
    dbms_output.put_line('test_pkg.TF( sid => '''|| sid || ''' ): exit, piped #' || counter || ' records');
end;
end;
explain plan for
select /*+ first_rows */ test_obj(a, b, c)
from table(test_pkg.TF(CURSOR(select /*+ parallel(tab,5) */ * from test_table tab)));
select * from table(dbms_xplan.display);
Plan hash value: 1037943675
| Id | Operation                             | Name       | Rows | Bytes | Cost (%CPU)| Time     |    TQ |IN-OUT| PQ Distrib |
|   0 | SELECT STATEMENT                      |            | 8168 | 3972K|    20   (0)| 00:00:01 |        |      |            |
|   1 | PX COORDINATOR                       |            |       |       |            |          |        |      |            |
|   2 |   PX SEND QC (RANDOM)                 | :TQ10001   | 8168 | 3972K|    20   (0)| 00:00:01 | Q1,01 | P->S | QC (RAND) |
|   3 |    BUFFER SORT                        |            | 8168 | 3972K|            |          | Q1,01 | PCWP |            |
|   4 |     VIEW                              |            | 8168 | 3972K|    20   (0)| 00:00:01 | Q1,01 | PCWP |            |
|   5 |      COLLECTION ITERATOR PICKLER FETCH| TF         |       |       |            |          | Q1,01 | PCWP |            |
|   6 |       PX RECEIVE                      |            |   931K|   140M|   136   (2)| 00:00:02 | Q1,01 | PCWP |            |
|   7 |        PX SEND HASH                   | :TQ10000   |   931K|   140M|   136   (2)| 00:00:02 | Q1,00 | P->P | HASH       |
|   8 |         PX BLOCK ITERATOR             |            |   931K|   140M|   136   (2)| 00:00:02 | Q1,00 | PCWC |            |
|   9 |          TABLE ACCESS FULL            | TEST_TABLE |   931K|   140M|   136   (2)| 00:00:02 | Q1,00 | PCWP |            |
Note
   - dynamic sampling used for this statement
explain plan for
select /*+ first_rows */ test_obj(a, b, c)
from table(test_pkg.TF_Any(CURSOR(select /*+ parallel(tab,5) */ * from test_table tab)));
select * from table(dbms_xplan.display);
Plan hash value: 4097140875
| Id | Operation                            | Name       | Rows | Bytes | Cost (%CPU)| Time     |    TQ |IN-OUT| PQ Distrib |
|   0 | SELECT STATEMENT                     |            | 8168 | 3972K|    20   (0)| 00:00:01 |        |      |            |
|   1 | PX COORDINATOR                      |            |       |       |            |          |        |      |            |
|   2 |   PX SEND QC (RANDOM)                | :TQ10000   | 8168 | 3972K|    20   (0)| 00:00:01 | Q1,00 | P->S | QC (RAND) |
|   3 |    VIEW                              |            | 8168 | 3972K|    20   (0)| 00:00:01 | Q1,00 | PCWP |            |
|   4 |     COLLECTION ITERATOR PICKLER FETCH| TF_ANY     |       |       |            |          | Q1,00 | PCWP |            |
|   5 |      PX BLOCK ITERATOR               |            |   931K|   140M|   136   (2)| 00:00:02 | Q1,00 | PCWC |            |
|   6 |       TABLE ACCESS FULL              | TEST_TABLE |   931K|   140M|   136   (2)| 00:00:02 | Q1,00 | PCWP |            |
Note
   - dynamic sampling used for this statementI posted about it here a few years ago and I more recently posted a question on Asktom. Unfortunately Tom was not able to find a technical reason for it to be there so I'm still a little in the dark as to why it is needed. The original question I posted is here:
Pipelined function partition by hash has extra sort#
I ran your tests with HASH vs ANY and the results are in line with the observations above....
declare
myList test_list := test_list();
myList2 test_list := test_list();
sids ton_t := ton_t();
sid number;
t1 timestamp with time zone;
t2 timestamp with time zone;
procedure LogPerfTable
is
type ton is table of number;
type tot is table of timestamp with time zone;
type clients_t is table of varchar2(256);
sids ton;
t1s tot;
t2s tot;
clients clients_t;
deltaTime integer;
btsPerSecond number(19,0);
edrsPerSecond number(19,0);
begin
select sid, t1, t2, client bulk collect into sids, t1s, t2s, clients from perf_data order by client;
if clients.count > 0 then
for i in clients.FIRST .. clients.LAST loop
deltaTime := test_pkg.TZDeltaToMilliseconds(t1s(i), t2s(i));
if deltaTime = 0 then deltaTime := 1; end if;
dbms_output.put_line(
'[' || to_char(t1s(i), 'hh:mi:ss') ||
'-' || to_char(t2s(i), 'hh:mi:ss') ||
']:' ||
' client ' || clients(i) || ' / sid #' || sids(i)
end loop;
end if;
end LogPerfTable;
begin
select userenv('SID') into sid from dual;
for i in 1..200000 loop
myList.extend; myList(myList.last) := test_obj(i, sysdate, to_char(i+2));
end loop;
-- save into the real table
insert into test_table select * from table(cast (myList as test_list));
-- save into the tmp table
insert into tmp_test_table select * from table(cast (myList as test_list));
dbms_output.put_line(chr(10) || '(1) copy ''mylist'' to ''mylist2'' by streaming via table function...');
delete from perf_data;
t1 := systimestamp;
select /*+ first_rows */ test_obj(a, b, c) bulk collect into myList2
from table(test_pkg.TF(CURSOR(select /*+ parallel(tab,5) */ * from table(cast (myList as test_list)) tab)));
t2 := systimestamp;
insert into perf_data (sid, t1, t2, client) values(sid, t1, t2, 'master');
LogPerfTable;
dbms_output.put_line('... saved #' || myList2.count || ' records');
select distinct(tab.a) bulk collect into sids from table(cast (myList2 as test_list)) tab;
dbms_output.put_line(chr(10) || '(2) copy temporary ''tmp_test_table'' to ''mylist2'' by streaming via table function:');
delete from perf_data;
t1 := systimestamp;
select /*+ first_rows */ test_obj(a, b, c) bulk collect into myList2
from table(test_pkg.TF(CURSOR(select /*+ parallel(tab,5) */ * from tmp_test_table tab)));
t2 := systimestamp;
insert into perf_data (sid, t1, t2, client) values(sid, t1, t2, 'master');
LogPerfTable;
dbms_output.put_line('... saved #' || myList2.count || ' records');
select distinct(tab.a) bulk collect into sids from table(cast (myList2 as test_list)) tab;
dbms_output.put_line(chr(10) || '(3) copy physical ''test_table'' to ''mylist2'' by streaming via table function:');
delete from perf_data;
t1 := systimestamp;
select /*+ first_rows */ test_obj(a, b, c) bulk collect into myList2
from table(test_pkg.TF(CURSOR(select /*+ parallel(tab,5) */ * from test_table tab)));
t2 := systimestamp;
insert into perf_data (sid, t1, t2, client) values(sid, t1, t2, 'master');
LogPerfTable;
dbms_output.put_line('... saved #' || myList2.count || ' records');
select distinct(tab.a) bulk collect into sids from table(cast (myList2 as test_list)) tab;
dbms_output.put_line(chr(10) || '(4) copy temporary ''tmp_test_table'' to ''mylist2'' by streaming via table function ANY:');
delete from perf_data;
t1 := systimestamp;
select /*+ first_rows */ test_obj(a, b, c) bulk collect into myList2
from table(test_pkg.TF_any(CURSOR(select /*+ parallel(tab,5) */ * from tmp_test_table tab)));
t2 := systimestamp;
insert into perf_data (sid, t1, t2, client) values(sid, t1, t2, 'master');
LogPerfTable;
dbms_output.put_line('... saved #' || myList2.count || ' records');
select distinct(tab.a) bulk collect into sids from table(cast (myList2 as test_list)) tab;
dbms_output.put_line(chr(10) || '(5) copy physical ''test_table'' to ''mylist2'' by streaming via table function using ANY:');
delete from perf_data;
t1 := systimestamp;
select /*+ first_rows */ test_obj(a, b, c) bulk collect into myList2
from table(test_pkg.TF_any(CURSOR(select /*+ parallel(tab,5) */ * from test_table tab)));
t2 := systimestamp;
insert into perf_data (sid, t1, t2, client) values(sid, t1, t2, 'master');
LogPerfTable;
dbms_output.put_line('... saved #' || myList2.count || ' records');
select distinct(tab.a) bulk collect into sids from table(cast (myList2 as test_list)) tab;
end;
(1) copy 'mylist' to 'mylist2' by streaming via table function...
test_pkg.TF( sid => '918' ): enter
test_pkg.TF( sid => '918' ): exit, piped #200000 records
[01:40:19-01:40:29]: client master / sid #918
[01:40:19-01:40:29]: client slave / sid #918
... saved #600000 records
(2) copy temporary 'tmp_test_table' to 'mylist2' by streaming via table function:
[01:40:31-01:40:36]: client master / sid #918
[01:40:31-01:40:32]: client slave / sid #659
[01:40:31-01:40:32]: client slave / sid #880
[01:40:31-01:40:32]: client slave / sid #1045
[01:40:31-01:40:32]: client slave / sid #963
[01:40:31-01:40:32]: client slave / sid #712
... saved #600000 records
(3) copy physical 'test_table' to 'mylist2' by streaming via table function:
[01:40:37-01:41:05]: client master / sid #918
[01:40:37-01:40:42]: client slave / sid #738
[01:40:37-01:40:42]: client slave / sid #568
[01:40:37-01:40:42]: client slave / sid #618
[01:40:37-01:40:42]: client slave / sid #659
[01:40:37-01:40:42]: client slave / sid #963
... saved #3000000 records
(4) copy temporary 'tmp_test_table' to 'mylist2' by streaming via table function ANY:
[01:41:12-01:41:16]: client master / sid #918
[01:41:12-01:41:16]: client slave / sid #712
[01:41:12-01:41:16]: client slave / sid #1045
[01:41:12-01:41:16]: client slave / sid #681
[01:41:12-01:41:16]: client slave / sid #754
[01:41:12-01:41:16]: client slave / sid #880
... saved #600000 records
(5) copy physical 'test_table' to 'mylist2' by streaming via table function using ANY:
[01:41:18-01:41:38]: client master / sid #918
[01:41:18-01:41:38]: client slave / sid #681
[01:41:18-01:41:38]: client slave / sid #712
[01:41:18-01:41:38]: client slave / sid #754
[01:41:18-01:41:37]: client slave / sid #880
[01:41:18-01:41:38]: client slave / sid #1045
... saved #3000000 recordsHTH
David

Parallel pipelined table function, autonomous_transaction to global tmp tab

Hi,
i try to speed up my parallel pipelined table function and switch from pl/sql collection to global temporary table inside.
This requires to use PRAGMA AUTONOMOUS_TRANSACTION (and commit), because inserting into global temporary table (DML)
within select - for invoking the table function - is not allowed without.
As a consequence of commit it next requires to have on commit preserve rows for the global temporary table.
Now:
Inserts into the global temporary table are done - indicated by sql%rowcount.
But a select afterwards doesn't show any record anymore.
Here is a program to demonstrate it:
set serveroutput on;
drop type TestTableOfNumber_t;
create or replace type TestTableOfNumber_t is table of number;
drop type TestStatusList;
drop type TestStatusObj;
create or replace type TestStatusObj as object(
     sid number,
     ctr1 number,
     ctr2 number,
     ctr3 number
create or replace type TestStatusList is table of TestStatusObj;
drop table TestTmpTable;
create global temporary table TestTmpTable (
     value     number
) on commit preserve rows;
create or replace package test_pkg
as
     type TestStatusRec is record (
          sid number,
          ctr1 number,
          ctr2 number,
          ctr3 number
     type TestStatusTab is table of TestStatusRec;
     function FillTmpTable(id in varchar2)
     return TestStatusRec;
     FUNCTION ptf (p_cursor IN sys_refcursor)
     RETURN TestStatusList PIPELINED
     PARALLEL_ENABLE(PARTITION p_cursor BY any);
end;
create or replace package body test_pkg
as
     function FillTmpTable(id in varchar2)
     return TestStatusRec
     is
          PRAGMA AUTONOMOUS_TRANSACTION;
          result TestStatusRec;
          sid number;
          type ton is table of number;
          tids TestTableOfNumber_t := TestTableOfNumber_t();
          records number := 0;
     begin
          select userenv('SID') into sid from dual;
          result.sid := sid;
          delete from TestTmpTable;
          for i in 1..100 loop
               tids.extend;
               tids(tids.last) := i;
          end loop;
          forall i in 1..tids.count
               insert into TestTmpTable (value) values (tids(i));
          -- get number of records inserted
          records := sql%rowcount;
          result.ctr1 := records;
          -- retrieve again before commit
          select count(*) into records from TestTmpTable;
          result.ctr2 := records;
          commit;
          -- retrieve again after commit
          select count(*) into records from TestTmpTable;
          result.ctr3 := records;
          return result;
     end;
     FUNCTION ptf (p_cursor IN sys_refcursor)
     RETURN TestStatusList PIPELINED
     PARALLEL_ENABLE(PARTITION p_cursor BY any)
     IS
          rec test_pkg.TestStatusRec;
          value number;
          sid number;
          ctr integer := 0;
     BEGIN
          select userenv('SID') into sid from dual;
          rec := FillTmpTable('IN PTF');
          LOOP
               FETCH p_cursor into value;
               EXIT WHEN p_cursor%NOTFOUND;
               ctr := ctr + 1;
          END LOOP;
          -- as a result i am only interested in the results of FillTmpTable():
          PIPE ROW (TestStatusObj(rec.sid, rec.ctr1, rec.ctr2, rec.ctr3));
              RETURN;
     END;
end;
declare
     tons TestTableOfNumber_t;
     counts TestTableOfNumber_t;
     status test_pkg.TestStatusRec;
     statusList test_pkg.TestStatusTab;
begin
     status := test_pkg.FillTmpTable('MAIN');
     dbms_output.put_line('main thread:'
          || ' sid #' || status.sid
          || ' / #' || status.ctr1 || ' inserted '
          || ' / #' || status.ctr2 || ' before commit'
          || ' / #' || status.ctr3 || ' after commit');
     select value bulk collect into tons from TestTmpTable;
     select * bulk collect into statusList from TABLE(test_pkg.ptf(CURSOR(select /*+ parallel(tab,2) */ value from TestTmpTable tab)));
     for i in 1..StatusList.count loop
          dbms_output.put_line('worker thread #' || i || ':'
          || ' sid #' || statusList(i).sid
          || ' / #' || statusList(i).ctr1 || ' inserted '
          || ' / #' || statusList(i).ctr2 || ' before commit'
          || ' / #' || statusList(i).ctr3 || ' after commit');
     end loop;
end;
/The output is:
main thread: sid #881 / #100 inserted / #100 before commit / #100 after commit
worker thread #1: sid #421 / #100 inserted / #0 before commit / #0 after commit
worker thread #2: sid #321 / #100 inserted / #0 before commit / #0 after commitThe 1st line is for the main thread invoking FillTmpTable().
The next #2 lines are for the worker threads of the parallel pipelined table function for invoking the same FillTmpTable().
For the main thread everything is as expected.
But for the worker threads the logs for before commit and after commit both give #0 for the number of available records in the global temporary table.
However all indicate #100 for the SQL insert
regards,
Frank
Edited by: user8704911 on Jul 7, 2011 10:13 AM
Edited by: user8704911 on Jul 7, 2011 10:20 AM
Edited by: user8704911 on Jul 7, 2011 10:27 AM

SQL> select * from v$version;
BANNER
Oracle Database 11g Enterprise Edition Release 11.1.0.7.0 - 64bit Production
PL/SQL Release 11.1.0.7.0 - Production
CORE    11.1.0.7.0      Production
TNS for Linux: Version 11.1.0.7.0 - Production
NLSRTL Version 11.1.0.7.0 - Production
SQL> set serveroutput on;
SQL> drop type TestTableOfNumber;
drop type TestTableOfNumber
ERROR at line 1:
ORA-04043: object TESTTABLEOFNUMBER does not exist
SQL> /
drop type TestTableOfNumber
ERROR at line 1:
ORA-04043: object TESTTABLEOFNUMBER does not exist
SQL>
SQL> create or replace type TestTableOfNumber_t is table of number;
2 /
Type created.
SQL>
SQL> drop type TestStatusObj;
drop type TestStatusObj
ERROR at line 1:
ORA-04043: object TESTSTATUSOBJ does not exist
SQL> /
drop type TestStatusObj
ERROR at line 1:
ORA-04043: object TESTSTATUSOBJ does not exist
SQL>
SQL> create or replace type TestStatusObj as object(
2   sid number,
3   ctr1 number,
4   ctr2 number,
5   ctr3 number
6 );
7 /
Type created.
SQL>
SQL> drop type TestStatusList;
drop type TestStatusList
ERROR at line 1:
ORA-04043: object TESTSTATUSLIST does not exist
SQL> /
drop type TestStatusList
ERROR at line 1:
ORA-04043: object TESTSTATUSLIST does not exist
SQL>
SQL> create or replace type TestStatusList is table of TestStatusObj;
2 /
Type created.
SQL>
SQL> drop table TestTmpTable;
drop table TestTmpTable
ERROR at line 1:
ORA-00942: table or view does not exist
SQL> /
drop table TestTmpTable
ERROR at line 1:
ORA-00942: table or view does not exist
SQL>
SQL> create global temporary table TestTmpTable (
2   value number
3 ) on commit preserve rows;
Table created.
SQL> /
create global temporary table TestTmpTable (
ERROR at line 1:
ORA-00955: name is already used by an existing object
SQL>
SQL> create or replace package test_pkg
2 as
3
4   type TestStatusRec is record (
5    sid number,
6    ctr1 number,
7    ctr2 number,
8    ctr3 number
9   );
10
11   type TestStatusTab is table of TestStatusRec;
12
13   function FillTmpTable(id in varchar2)
14   return TestStatusRec;
15
16   FUNCTION ptf (p_cursor IN sys_refcursor)
17   RETURN TestStatusList PIPELINED
18   PARALLEL_ENABLE(PARTITION p_cursor BY any);
19
20 end;
21 /
Package created.
SQL>
SQL> create or replace package body test_pkg
2 as
3
4   function FillTmpTable(id in varchar2)
5   return TestStatusRec
6   is
7    PRAGMA AUTONOMOUS_TRANSACTION;
8
9    result TestStatusRec;
10
11    sid number;
12
13    type ton is table of number;
14    tids TestTableOfNumber_t := TestTableOfNumber_t();
15
16    records number := 0;
17   begin
18    select userenv('SID') into sid from dual;
19    result.sid := sid;
20
21    delete from TestTmpTable;
22
23    for i in 1..100 loop
24     tids.extend;
25     tids(tids.last) := i;
26    end loop;
27
28    forall i in 1..tids.count
29     insert into TestTmpTable (value) values (tids(i));
30
31    -- get number of records inserted
32    records := sql%rowcount;
33    result.ctr1 := records;
34
35    -- retrieve again before commit
36    select count(*) into records from TestTmpTable;
37    result.ctr2 := records;
38
39    commit;
40
41    -- retrieve again after commit
42    select count(*) into records from TestTmpTable;
43    result.ctr3 := records;
44
45    return result;
46   end;
47
48     FUNCTION ptf (p_cursor IN sys_refcursor)
49   RETURN TestStatusList PIPELINED
50   PARALLEL_ENABLE(PARTITION p_cursor BY any)
51   IS
52    rec test_pkg.TestStatusRec;
53    value number;
54    sid number;
55    ctr integer := 0;
56   BEGIN
57    select userenv('SID') into sid from dual;
58    rec := FillTmpTable('IN PTF');
59    LOOP
60     FETCH p_cursor into value;
61     EXIT WHEN p_cursor%NOTFOUND;
62     ctr := ctr + 1;
63    END LOOP;
64
65    -- as a result i am only interested in the results of FillTmpTable():
66    PIPE ROW (TestStatusObj(rec.sid, rec.ctr1, rec.ctr2, rec.ctr3));
67
68        RETURN;
69   END;
70 end;
71 /
Package body created.
SQL>
SQL> declare
2   tons TestTableOfNumber_t;
3   counts TestTableOfNumber_t;
4   status test_pkg.TestStatusRec;
5   statusList test_pkg.TestStatusTab;
6 begin
7   status := test_pkg.FillTmpTable('MAIN');
8   dbms_output.put_line('main thread:'
9    || ' sid #' || status.sid
10    || ' / #' || status.ctr1 || ' inserted '
11    || ' / #' || status.ctr2 || ' before commit'
12    || ' / #' || status.ctr3 || ' after commit');
13
14   select value bulk collect into tons from TestTmpTable;
15
16   select * bulk collect into statusList from TABLE(test_pkg.ptf(CURSOR(select /*+ parallel(tab,2
) */ value from TestTmpTable tab)));
17
18   for i in 1..StatusList.count loop
19    dbms_output.put_line('worker thread #' || i || ':'
20    || ' sid #' || statusList(i).sid
21    || ' / #' || statusList(i).ctr1 || ' inserted '
22    || ' / #' || statusList(i).ctr2 || ' before commit'
23    || ' / #' || statusList(i).ctr3 || ' after commit');
24   end loop;
25
26 end;
27 /
main thread: sid #1023 / #100 inserted / #100 before commit / #100 after commit
worker thread #1: sid #1045 / #100 inserted / #100 before commit / #100 after
commit
worker thread #2: sid #1019 / #100 inserted / #100 before commit / #100 after
commit
PL/SQL procedure successfully completed.
SQL> I am getting a different result.
Regards
Raj

Performance issues with pipelined table functions

I am testing pipelined table functions to be able to re-use the base_query function. Contrary to my understanding, the with_pipeline procedure runs 6 time slower than the legacy no_pipeline procedure. Am I missing something? The processor function is from [url http://www.oracle-developer.net/display.php?id=429]improving performance with pipelined table functions .
Edit: The underlying query returns 500,000 rows in about 3 minutes. So there are are no performance issues with the query itself.
Many thanks in advance.
CREATE OR REPLACE PACKAGE pipeline_example
IS
 TYPE resultset_typ IS REF CURSOR;
 TYPE row_typ IS RECORD (colC VARCHAR2(200), colD VARCHAR2(200), colE VARCHAR2(200));
 TYPE table_typ IS TABLE OF row_typ;
 FUNCTION base_query (argA IN VARCHAR2, argB IN VARCHAR2)
 RETURN resultset_typ;
 c_default_limit CONSTANT PLS_INTEGER := 100;
 FUNCTION processor (
 p_source_data IN resultset_typ,
 p_limit_size IN PLS_INTEGER DEFAULT c_default_limit)
 RETURN table_typ
 PIPELINED
 PARALLEL_ENABLE(PARTITION p_source_data BY ANY);
 PROCEDURE with_pipeline (argA IN VARCHAR2,
 argB IN VARCHAR2,
 o_resultset OUT resultset_typ);
 PROCEDURE no_pipeline (argA IN VARCHAR2,
 argB IN VARCHAR2,
 o_resultset OUT resultset_typ);
END pipeline_example;
CREATE OR REPLACE PACKAGE BODY pipeline_example
IS
 FUNCTION base_query (argA IN VARCHAR2, argB IN VARCHAR2)
 RETURN resultset_typ
 IS
 o_resultset resultset_typ;
 BEGIN
 OPEN o_resultset FOR
 SELECT colC, colD, colE
 FROM some_table
 WHERE colA = ArgA AND colB = argB;
 RETURN o_resultset;
 END base_query;
 FUNCTION processor (
 p_source_data IN resultset_typ,
 p_limit_size IN PLS_INTEGER DEFAULT c_default_limit)
 RETURN table_typ
 PIPELINED
 PARALLEL_ENABLE(PARTITION p_source_data BY ANY)
 IS
 aa_source_data table_typ;-- := table_typ ();
 BEGIN
 LOOP
 FETCH p_source_data
 BULK COLLECT INTO aa_source_data
 LIMIT p_limit_size;
 EXIT WHEN aa_source_data.COUNT = 0;
 /* Process the batch of (p_limit_size) records... */
 FOR i IN 1 .. aa_source_data.COUNT
 LOOP
 PIPE ROW (aa_source_data (i));
 END LOOP;
 END LOOP;
 CLOSE p_source_data;
 RETURN;
 END processor;
 PROCEDURE with_pipeline (argA IN VARCHAR2,
 argB IN VARCHAR2,
 o_resultset OUT resultset_typ)
 IS
 BEGIN
 OPEN o_resultset FOR
 SELECT /*+ PARALLEL(t, 5) */ colC,
 SUM (CASE WHEN colD > colE AND colE != '0' THEN colD / ColE END)de,
 SUM (CASE WHEN colE > colD AND colD != '0' THEN colE / ColD END)ed,
 SUM (CASE WHEN colD = colE AND colD != '0' THEN '1' END) de_one,
 SUM (CASE WHEN colD = '0' OR colE = '0' THEN '0' END) de_zero
 FROM TABLE (processor (base_query (argA, argB),100)) t
 GROUP BY colC
 ORDER BY colC
 END with_pipeline;
 PROCEDURE no_pipeline (argA IN VARCHAR2,
 argB IN VARCHAR2,
 o_resultset OUT resultset_typ)
 IS
 BEGIN
 OPEN o_resultset FOR
 SELECT colC,
 SUM (CASE WHEN colD > colE AND colE != '0' THEN colD / ColE END)de,
 SUM (CASE WHEN colE > colD AND colD != '0' THEN colE / ColD END)ed,
 SUM (CASE WHEN colD = colE AND colD != '0' THEN 1 END) de_one,
 SUM (CASE WHEN colD = '0' OR colE = '0' THEN '0' END) de_zero
 FROM (SELECT colC, colD, colE
 FROM some_table
 WHERE colA = ArgA AND colB = argB)
 GROUP BY colC
 ORDER BY colC;
 END no_pipeline;
END pipeline_example;
ALTER PACKAGE pipeline_example COMPILE;Edited by: Earthlink on Nov 14, 2010 9:47 AM
Edited by: Earthlink on Nov 14, 2010 11:31 AM
Edited by: Earthlink on Nov 14, 2010 11:32 AM
Edited by: Earthlink on Nov 20, 2010 12:04 PM
Edited by: Earthlink on Nov 20, 2010 12:54 PM

Earthlink wrote:
Contrary to my understanding, the with_pipeline procedure runs 6 time slower than the legacy no_pipeline procedure. Am I missing something? Well, we're missing a lot here.
Like:
- a database version
- how did you test
- what data do you have, how is it distributed, indexed
and so on.
If you want to find out what's going on then use a TRACE with wait events.
All nessecary steps are explained in these threads:
HOW TO: Post a SQL statement tuning request - template posting
http://oracle-randolf.blogspot.com/2009/02/basic-sql-statement-performance.html
Another nice one is RUNSTATS:
http://asktom.oracle.com/pls/asktom/ASKTOM.download_file?p_file=6551378329289980701

Interactive report on view based on pipelined table function.

Hi,
I want to build an Interactive Report on a view.
The view definition contains a select on a pipelined table function. I use context functionality to pass paramaters to the pipelined table function.
A plain select * from #my_view# in SqlPlus results in 121 different rows.
However, If I base my Interactive report on this view, I get 15 repeated rows (all the same).
Is it possible to use pipelined table functionality on an Interactive report? I can't seem to get it working.
If I use the following approach (http://rakeshjsr.blogspot.nl/2010/10/oracle-apex-interactive-report-based-on.html) I do get results, but I can't use this solution for a reason that's not relevant.

Hello,
Is it possible to use pipelined table functionality on an Interactive report? I can't seem to get it working. I have used it in one instance and it works fine. However I was passing the values to pipe-lined function directly.
IR Query..
SELECT * FROM TABLE(fn_pipeline(:P1_ITEM_NAME))Call pipe-lined function from IR query directly (instead of using view)
Try sending values to Pipe-lined function directly. In-case if the problem is with setting and getting values from the context?
Regards,
Hari

Query performance improvement using pipelined table function

Hi,
I have got two select queries one is like...
select * from table
another is using pielined table function
select *
from table(pipelined_function(cursor(select * from table)))
which query will return result set more faster????????
suggest methods for retrieving dataset more faster (using pipelined table function) than a normal select query.
rgds
somy

Compare the performance between these solutions:
create table big as select * from all_objects;
First test the performance of a normal select statement:
begin
for r in (select * from big) loop
   null;
end loop;
end;
/Second a pipelined function:
create type rc_vars as object
(OWNER VARCHAR2(30)
,OBJECT_NAME     VARCHAR2(30));
create or replace type rc_vars_table as table of rc_vars ;
create or replace
function rc_get_vars
return rc_vars_table
pipelined
as
cursor c_aobj
         is
         select owner, object_name
         from   big;
l_aobj c_aobj%rowtype;
begin
for r_aobj in c_aobj loop
    pipe row(rc_vars(r_aobj.owner,r_aobj.object_name));
end loop;
return;
end;
/Test the performance of the pipelined function:
begin
for r in (select * from table(rc_get_vars)) loop
   null;
end loop;
end;
/On my system the simple select-statement is 20 times faster.
Correction: It is 10 times faster, not 20.
Message was edited by:
wateenmooiedag

Duplicate Rows In Oracle Pipelined Table Functions

Hi fellow oracle users,
I am trying to create an Oracle piplined table function that contains duplicate records. Whenever I try to pipe the same record twice, the duplicate record does not show up in the resulting pipelined table.
Here's a sample piece of SQL:
/* Type declarations */
TYPE MY_RECORD IS RECORD(
MY_NUM INTEGER
TYPE MY_TABLE IS TABLE OF MY_RECORD;
/* Pipelined function declaration */
FUNCTION MY_FUNCTION RETURN MY_TABLE PIPELINED IS
V_RECORD MY_RECORD;
BEGIN
-- insert first record
V_RECORD.MY_NUM = 1;
PIPE ROW (V_RECORD);
-- insert second duplicate record
V_RECORD.MY_NUM = 1;
PIPE ROW (V_RECORD);
-- return piplined table
RETURN;
END;
/* Statement to query pipelined function */
SELECT * FROM TABLE( MY_FUNCTION ); -- for some reason this only returns one record instead of two
I am trying to get the duplicate row to show up in the select statement. Any help would be greatly appreciated.

Can you provide actual output from an SQL*Plus prompt trying this? I don't see the same behavior
SQL> SELECT * FROM V$VERSION;
BANNER
Oracle Database 10g Enterprise Edition Release 10.2.0.4.0 - 64bi
PL/SQL Release 10.2.0.4.0 - Production
CORE    10.2.0.4.0      Production
TNS for 64-bit Windows: Version 10.2.0.4.0 - Production
NLSRTL Version 10.2.0.4.0 - Production
SQL> CREATE TYPE MY_RECORD IS OBJECT(MY_NUM INTEGER);
2 /
Type created.
SQL> CREATE TYPE MY_TABLE IS TABLE OF MY_RECORD;
2 /
Type created.
SQL> CREATE OR REPLACE FUNCTION MY_FUNCTION
2 RETURN MY_TABLE
3 PIPELINED
4          AS
5                  V_RECORD        MY_RECORD;
6          BEGIN
7                  V_RECORD.MY_NUM := 1;
8                  PIPE ROW(V_RECORD);
9
10                  V_RECORD.MY_NUM := 1;
11                  PIPE ROW(V_RECORD);
12
13                  RETURN;
14          END;
15 /
Function created.
SQL> SELECT * FROM TABLE(MY_FUNCTION);
              MY_NUM
                   1
                   1

How to debug "pipelined parallel enable table function" ?

Dear All,
Normally we can retrieve output from a "pipelined parallel enable table function " by using SQL statement, such as
select output from table(pipelined_function(arg1));
Can anyone alight me how to call this function purely using PL/SQL statement?
Reason for this : We have third party developer develooped a complicate "pipelined parallel enable table function" and this function is currently calling by SQL (select output from table(pipelined_function(arg1));
), I will like to debug this function, but unable to do so, so far I have done :
1) compile function with debug option
2) using Procedure Builder to debug, if I execute the above statement (select output from table(pipelined_function(arg1)); I believe, Procedure Builder will not debug a function from a SQL statement
3) try to build up a PL/SQL block, but don't know how to it.
basically I want to debug this "pipelined parallel enable table function " and don't know how to do it, any example will be greate!

user2302827 wrote:
Using dbms_output is fine but too tedious. I was looking for a PL/SQL procedure builder that can help to debug a statement like this:
select output from table(pipelined_function(arg1));
Any suggestion?I don't know about any procedure builders.
There is a debugger you can use, though I'd have to think about how to invoke it to use with a pipelined function. The debugger is available in GUI tools like SQL*Developer and TOAD and can be used to walk through a program and set values

Using Pipeline Table functions with other tables

I am on DB 11.2.0.2 and have sparingly used pipelined table functions but am considering it for a project that has some fairly big (lots of rows) sized tables. In my tests, selecting from just the pipelined table perform pretty well (whether it is directly from the pipleined table or the view I created on top of it). Where I start to see some degregation when I try to join the pipelined tabe view to other tables and add where conditions.
ie:
SELECT A.empno, A.empname, A.job, B.sal
FROM EMP_VIEW A, EMP B
WHERE A.empno = B.empno AND
      B.mgr = '7839'
I have seen some articles and blogs that mention this as a cardinality issue, and offer some undocumented methods to try and combat.
Can someone please give me some advice or tips on this. Thanks!
I have created a simple example using the emp table below to help illustrate what I am doing.
DROP TYPE EMP_TYPE;
DROP TYPE EMP_SEQ;
CREATE OR REPLACE TYPE EMP_SEQ AS OBJECT
       ( EMPNO                                         NUMBER(10),
         ENAME                                         VARCHAR2(100),
         JOB                                           VARCHAR2(100));
CREATE OR REPLACE TYPE EMP_TYPE AS TABLE OF EMP_SEQ;
CREATE OR REPLACE FUNCTION get_emp return EMP_TYPE PIPELINED AS
BEGIN
FOR cur IN (SELECT
                empno,
                ename,
                job
              FROM emp
         LOOP
           PIPE ROW(EMP_SEQ(cur.empno,
                            cur.ename,
                            cur.job));
         END LOOP;
         RETURN;
END get_emp;
create OR REPLACE view EMP_VIEW as select * from table(get_emp());
SELECT A.empno, A.empname, A.job, B.sal
FROM EMP_VIEW A, EMP B
WHERE A.empno = B.empno AND
      B.mgr = '7839'

I am on DB 11.2.0.2 and have sparingly used pipelined table functions but am considering it for a project that has some fairly big (lots of rows) sized tables
Which begs the question: WHY? What PROBLEM are you trying to solve and what makes you think using pipelined table functions is the best way to solve that problem?
The lack of information about cardinality is the likely root of the degradation you noticed as already mentioned.
But that should be a red flag about pipelined functions in general. PIPELINED functions hide virtually ALL KNOWLEDGE about the result set that is produced; cardinality is just the tip of the iceberg. Those functions pretty much say 'here is a result set' without ANY information about the number of rows (cardinality), distinct values for any columns, nullability of any columns, constraints that might apply to any columns (foreign key, primary key) and so on.
If you are going to hide all of that information from Oracle that would normally be used to help optimize queries and select the appropriate execution plan you need to have a VERY good reason.
The use of PIPELINED functions should be reserved for those use cases where ordinary SQL and PL/SQL cannot get the job done. That is they are a 'special case' solution.
The classic use case for those functions is for the transform stage of ETL where multiple pipelined functions are chained together: one function feeds its rows to the next function which feeds its rows to another and so on. Each of those 'chained' functions is roughly analogous to a full table scan of the data that often does not need to be joined to other data except perhaps low volumn lookup tables where the data may even be cached.
I suggest that any exploratory or prototyping work you do use standard relational tables until such point as you run into a problem whose solution might require PIPELINED functions to solve.

Distributed queries+pipelined table function

HI friends,
can i get better performance for distributed queries if i use pipelined table function.I have got my data distribued across three different databases.
thanx
somy

You will need to grant EXECUTE access on the pipelined table function to whatever users want it. When other users call this function, they may need to prefix the schema owner (i.e. <<owner>>.getValue('001') ) unless you've set up the appropriate synonym.
What version of SQL*Plus do you have on the NT machine?
Justin
Distributed Database Consulting, Inc.
http://www.ddbcinc.com/askDDBC

How to define a view on a table function

I have a defined a pipelined table function in a package and can return data from it using:
select * from table(mtreport.FN_GET_JOBS_FOR_PROJECT(?));How can I define a view on this so that users can select from it without having to know to use the 'table' syntax?
select *
from vw_jobs_for_project
where id = ?I've tried this, but it doesn't work
CREATE OR REPLACE VIEW vw_jobs_for_project (PROJECT_ID, NAME) AS
SELECT PROJECT_ID, NAME
FROM table(mtreport.FN_GET_JOBS_FOR_PROJECT(PROJECT_ID));
ERROR at line 3:
ORA-00904: "PROJECT_ID": invalid identifier

views do not accept input parameters in the way that you want to use. you can define a CONTEXT parameter, but the users would need to set the context value before selecting from the view, so you'll still need to train them to do something new.
example:
create or replace context my_context using pkg_context;
 
create or replace package pkg_context is
procedure set_context(p_parameter in varchar2, p_value in varchar2);
function get_context(p_parameter in varchar2) return varchar2;
end;
show errors
create or replace package body pkg_context is
CONTEXT_NAME constant all_context.namespace%type := 'MY_CONTEXT';
procedure set_context(p_parameter in varchar2, p_value in varchar2) is
begin
 dbms_session.set_context(CONTEXT_NAME, p_parameter, p_value);
end;
function get_context(p_parameter in varchar2) return varchar2 is
begin
 return sys_context(CONTEXT_NAME, p_parameter);
end;
end;
show errors
create or replace view tree_view as
select level lvl, chid
from tree
connect by prior parid=chid
start with chid = sys_context('MY_CONTEXT','CHID');
-- at runtime
exec pkg_context.set_context('CHID', 14)
select * from tree_view;

Question about Table Function inside a Package

Hi … I am new in PL/SQL, I am trying to use a table function to create depending on a value passed to it (I am using 10g). Everything works great but the moment I add a parameter everything explode, I am creating it on a package.
SQL that work
CREATE OR REPLACE PACKAGE BODY financial_reports AS
FUNCTION Fund_Amount
RETURN financial_reports.Fund_Amount_Table
pipelined parallel_enable IS
cur_row financial_reports.Fund_Amount_Record;
BEGIN
FOR cur_row IN
SELECT
to_number(substr(bu5.usrdata, 1, 1)) As SECTION_ID
,to_number(substr(bu5.usrdata, 2, 1)) As SUB_SECTION_ID
,to_number(substr(bu5.usrdata, 4, 2)) AS LINE_NUMBER
,to_number(substr(bu5.usrdata, 7, 2)) As FUND_ID
,sum(be.amt) AS AMOUNT
FROM
linc.budgetdb_usr5@stjohnsfp bu5
JOIN linc.budgetdb_event@stjohnsfp be ON
bu5.keyvalue = be.acctno
WHERE
bu5.keyvalue like '__-__-__-____-____-_____'
AND bu5.usrdata like '__-__-__'
AND bu5.fieldnum = 1
AND bu5.ispecname = 'GLMST'
AND to_number(substr(bu5.usrdata, 7, 2)) = 1
GROUP BY
bu5.usrdata
ORDER BY
bu5.usrdata
LOOP
PIPE ROW(cur_row);
END LOOP;
END Fund_Amount;
END financial_reports;
SQL that do not work …
CREATE OR REPLACE PACKAGE BODY financial_reports AS
FUNCTION Fund_Amount (Fund_Id IN NUMBER)
RETURN financial_reports.Fund_Amount_Table
pipelined parallel_enable IS
cur_row financial_reports.Fund_Amount_Record;
fund_id_int NUMBER;
BEGIN
fund_id_int := Fund_Id;
FOR cur_row IN
SELECT
to_number(substr(bu5.usrdata, 1, 1)) As SECTION_ID
,to_number(substr(bu5.usrdata, 2, 1)) As SUB_SECTION_ID
,to_number(substr(bu5.usrdata, 4, 2)) AS LINE_NUMBER
,to_number(substr(bu5.usrdata, 7, 2)) As FUND_ID
,sum(be.amt) AS AMOUNT
FROM
linc.budgetdb_usr5@stjohnsfp bu5
JOIN linc.budgetdb_event@stjohnsfp be ON
bu5.keyvalue = be.acctno
WHERE
bu5.keyvalue like '__-__-__-____-____-_____'
AND bu5.usrdata like '__-__-__'
AND bu5.fieldnum = 1
AND bu5.ispecname = 'GLMST'
AND to_number(substr(bu5.usrdata, 7, 2)) = fund_id_int
GROUP BY
bu5.usrdata
ORDER BY
bu5.usrdata
LOOP
PIPE ROW(cur_row);
END LOOP;
END Fund_Amount;
END financial_reports;
Error … (This works without the parameter)
Error starting at line 43 in command:
select * from table(financial_reports.Fund_Amount(1) )
Error at Command Line:1 Column:14
Error report:
SQL Error: ORA-22905: cannot access rows from a non-nested table item
Any help would be greatly appreciated

try renaming your parameter so as not to confuse with what you are using in your column " to_number(substr(bu5.usrdata, 7, 2)) AS FUND_ID":
CREATE OR REPLACE PACKAGE BODY financial_reports AS
FUNCTION Fund_Amount (pFund_Id IN NUMBER)
    RETURN financial_reports.Fund_Amount_Table
    pipelined parallel_enable IS
    cur_row financial_reports.Fund_Amount_Record;
    fund_id_int NUMBER;
BEGIN
    fund_id_int := pFund_Id;
    FOR cur_row IN ( SELECT to_number(substr(bu5.usrdata, 1, 1)) As SECTION_ID,
                            to_number(substr(bu5.usrdata, 2, 1)) As SUB_SECTION_ID,
                            to_number(substr(bu5.usrdata, 4, 2)) AS LINE_NUMBER,
                            to_number(substr(bu5.usrdata, 7, 2)) As FUND_ID,
                            sum(be.amt) AS AMOUNT
                       FROM linc.budgetdb_usr5@stjohnsfp bu5
                              JOIN linc.budgetdb_event@stjohnsfp be ON bu5.keyvalue = be.acctno
                      WHERE bu5.keyvalue like '__-__-__-____-____-_____'
                        AND bu5.usrdata like '__-__-__'
                        AND bu5.fieldnum = 1
                        AND bu5.ispecname = 'GLMST'
                        AND to_number(substr(bu5.usrdata, 7, 2)) = fund_id_int
                     GROUP BY bu5.usrdata
                     ORDER BY bu5.usrdata ) LOOP
      PIPE ROW(cur_row);
    END LOOP;
END Fund_Amount;
END financial_reports;

Returning Collection using table function

Hi,
I'm trying to return a collection with record type using table function but facing some issues.
Could someone help me with it.
SUNNY@11gR1> create or replace package test_pack as
2 type rec_typ is record (
3 empname varchar2(30),
4 empage number(2),
5 empsal number(10));
6 type nest_typ is table of rec_typ;
7 function list_emp return nest_typ;
8 end;
9 /
Package created.
Elapsed: 00:00:00.01
SUNNY@11gR1> create or replace package body test_pack is
2 function list_emp return nest_typ is
3 nest_var nest_typ := nest_typ();
4 begin
5 nest_var.extend;
6 nest_var(nest_var.last).empname := 'KING';
7 nest_var(nest_var.last).empage := 25;
8 nest_var(nest_var.last).empsal := 2500;
9 nest_var.extend;
10 nest_var(nest_var.last).empname := 'SCOTT';
11 nest_var(nest_var.last).empage := 22;
12 nest_var(nest_var.last).empsal := 3500;
13 nest_var.extend;
14 nest_var(nest_var.last).empname := 'BLAKE';
15 nest_var(nest_var.last).empage := 1;
16 return nest_var;
17 end;
18 end;
19 /
Package body created.
Elapsed: 00:00:00.01
SUNNY@11gR1> select * from table(test_pack.list_emp);
select * from table(test_pack.list_emp)
ERROR at line 1:
ORA-00902: invalid datatype
Elapsed: 00:00:00.01
SUNNY@11gR1>Regards,
Sunny

But if I use pipelined function instead then I'm able to retrieve the records
SUNNY@11gR1> create or replace package test_pack as
2 type rec_typ is record (
3 empname varchar2(30),
4 empage number(2),
5 empsal number(10));
6 type nest_typ is table of rec_typ;
7 function list_emp return nest_typ pipelined;
8 end;
9 /
Package created.
SUNNY@11gR1> ed
Wrote file afiedt.buf
1 create or replace package body test_pack as
2 function list_emp return nest_typ pipelined is
3 rec_var rec_typ;
4 begin
5 rec_var.empname := 'KING';
6 rec_var.empage := 24;
7 rec_var.empsal := 10000;
8 pipe row(rec_var);
9 rec_var.empname:='SCOTT';
10 rec_var.empage:=22;
11 rec_var.empsal:=2000;
12 pipe row(rec_var);
13 rec_var.empname:='BLAKE';
14 rec_var.empage:='1';
15 pipe row(rec_var);
16 return;
17 end;
18* end;
SUNNY@11gR1> /
Package body created.
Elapsed: 00:00:00.01
SUNNY@11gR1> select * from table(test_pack.list_emp);
EMPNAME                            EMPAGE     EMPSAL
KING                                   24      10000
SCOTT                                  22       2000
BLAKE                                   1       2000
Elapsed: 00:00:00.00Why is that?
Regards,
Sunny

Error in Table Function (PIPELINE)

Similar Messages

Maybe you are looking for