Function not returning table object correctly

Question

Instead of returning a table, my function is returning this:
SCHEMA_OWNER.TBL_SUMS([SCHEMA_OWNER.SUMS_OBJ])
Does anyone see a syntax error in my function or the ddl of my table and object types?
This is a stripped down, simplified version of my function:
create or replace FUNCTION "F_TEST" (p_skey number, p_start_date date, p_end_date date)
RETURN tbl_sums
IS
tmp_A NUMBER;
tmp_B NUMBER;
l_tbl tbl_sums := tbl_sums();
BEGIN
SELECT SUM(FieldA), SUM(FieldB)
into tmpA, tmpB
from myTable where SKEY = p_skey
and DATE_VALUE >= p_start_date
and DATE_VALUE < p_end_date;
l_tbl.extend;
l_tbl(l_tbl.count()) := sums_obj(p_start_date, p_end_date, p_skey, tmpA, tmpB);
return l_tbl;
END;
My types are:
create or replace type sums_obj is object (start_date DATE, end_date DATE, skey NUMBER, SumA NUMBER, SumB NUMBER);
create or replace type tbl_sums is table of sums_obj;
Thanks!

Answer 1

>
RETURN tbl_kpi
>
What is 'tbl_kpi'? That isn't defined anywhere. Your original post said this:
>
RETURN tbl_sums
>
We can't help you if you don't post what you are really using. Cut & Paste is ok but you have to paste the correct code.
Your funtion is returning a TABLE but it is NOT PIPELINED. So if you query the function from DUAL you will get a DATASET as the result.
If you query the function AS A TABLE you will get the 'contents' of the table.
If you make your function a PIPELINED function then you use PIPE ROW to return each row but the function is still declared to return a TABLE. Maybe that is what is confusing you.
Try the following sample code to see what the difference is.
Here are two SQL types based on the EMP table in the scott schema.
-- type to match emp record
create or replace type emp_scalar_type as object
  (EMPNO NUMBER(4) ,
   ENAME VARCHAR2(10),
   JOB VARCHAR2(9),
   MGR NUMBER(4),
   HIREDATE DATE,
   SAL NUMBER(7, 2),
   COMM NUMBER(7, 2),
   DEPTNO NUMBER(2)
-- table of emp records
create or replace type emp_table_type as table of emp_scalar_type
/Now - here is a function (similar to yours) that returns that EMP_TABLE_TYPE. NOTE: the function IS NOT PIPELINED
CREATE OR REPLACE function SCOTT.get_emp1( p_deptno in number )
  return emp_table_type
  as
tb emp_table_type;
BEGIN
  select emp_scalar_type(empno, ename, job, mgr, hiredate, sal, comm, deptno)
    bulk collect into tb from emp where deptno = p_deptno;
  return tb;
end;
/If I just select the function itself from DUAL I get this:
select get_emp1(20) from dual
GET_EMP1(20)
(DATASET)I can use TOAD or sql developer to examine that dataset and see the records.
But I can actually query the records by using the TABLE function:
select * from table(get_emp1(20))
EMPNO     ENAME     JOB     MGR     HIREDATE     SAL     COMM     DEPTNO
7369     SMITH     CLERK     7902     12/17/1980     800          20
7566     JONES     MANAGER     7839     4/2/1981     2975          20
7788     SCOTT     ANALYST     7566     4/19/1987     3000          20
7876     ADAMS     CLERK     7788     5/23/1987     1100          20
7902     FORD     ANALYST     7566     12/3/1981     3000          20This is a similar function. It returns the same EMP_TABLE_TYPE but it is a PIPELINED function.
-- pipelined function
create or replace function get_emp( p_deptno in number )
  return emp_table_type
  PIPELINED
  as
   TYPE EmpCurTyp IS REF CURSOR RETURN emp%ROWTYPE;
    emp_cv EmpCurTyp;
    l_rec  emp%rowtype;
  begin
    open emp_cv for select * from emp where deptno = p_deptno;
    loop
      fetch emp_cv into l_rec;
      exit when (emp_cv%notfound);
      pipe row( emp_scalar_type( l_rec.empno, LOWER(l_rec.ename),
          l_rec.job, l_rec.mgr, l_rec.hiredate, l_rec.sal, l_rec.comm, l_rec.deptno ) );
    end loop;
    return;
  end;
  /The ONLY way I can query this function is by using the TABLE function:
select * from table(get_emp(20))
EMPNO     ENAME     JOB     MGR     HIREDATE     SAL     COMM     DEPTNO
7369     smith     CLERK     7902     12/17/1980     800          20
7566     jones     MANAGER     7839     4/2/1981     2975          20
7788     scott     ANALYST     7566     4/19/1987     3000          20
7876     adams     CLERK     7788     5/23/1987     1100          20
7902     ford     ANALYST     7566     12/3/1981     3000          20The query of the PIPELINED function is the same and the result set is the same.
The difference is that the PIPELINED function returns ONE ROW at a time and does NOT need to accumulate a lot of data in a collection before returning it. That collection uses expensive PGA memory and the more data you have the more memory it uses.
Your function (and my similar one) doesn't return ANY data until it has produced ALL of it. And it uses that expensive PGA memory. What is the point of creating your collection one row at a time and waiting until you have it all before you return it?
You could easily modify your function and add PIPELINED to the declaration. Then use the PIPE ROW clause to return each row as it is produced. That will eliminate the need for the collection (and memory) within the function.
You can also then chain the function calls together if you need to.
See 'Using Pipelined and Parallel Table Functions' in the Data Cartridge Developer's Guide
http://docs.oracle.com/cd/B28359_01/appdev.111/b28425/pipe_paral_tbl.htm
There is little use for your function that is not pipelined but returns a table type unless you were storing that table-type in an object column of a table.
There are many uses for PIPELINED functions.