Order of values passed to ODCIAggregateIterate

Question

I have implemented my own aggregate function that concatenates varchar2 values together. It works perfectly, however, the order of the aggregated data is inconsistent and does not match the order that it occurs in the table the aggregation is over ( I have sorted the data). As an example:
original data:
column_a     column_b
a                1-abc
a                2-abc
a                3-abc
b                1-abc
b                2-abc
b                3-abcafter aggregation query
column_a         column_b_concat
a                    1-abc,3-abc,2-abc
b                    1-abc,2-abc,3-abcMost of the concatenated data is correct (2nd row) but some of it is not (1st row). My question is....Is there a way to force the order of the aggregated rows to be maintained? I understand for aggregations such as count, sum or avg order is unimportant and so the db optimizes it to run as fast as possible. I can do this using PL/SQL but the execution time is much longer and would rather avoid it if possible.
Thanks.
Edited by: user8092994 on Feb 23, 2009 5:11 PM

Answer 1

Hi,
Let's phrase the question in terms of the scott.emp table and the wm_concat function, which a lot of people using Oracle 10 (and up) have available.
Right now you're doing something like:
SELECT    deptno
,       WM_CONCAT (ename)     AS ename_concat
FROM       scott.emp
GROUP BY  deptno;and getting results like
.   DEPTNO ENAME_CONCAT
        10 CLARK,KING,MILLER
        20 SMITH,FORD,ADAMS,SCOTT,JONES
        30 ALLEN,BLAKE,MARTIN,TURNER,JAMES,WARDexcept that the names aren't in order (which is exactly the problem: you need to be sure they are in order, as shown above).
I can think of three ways to do that:
(1) modify the function (as you have already considered)
(2) use CONNECT_BY_PATH instead of the function
(3) use the analytic form of the function
My guess is that the options above are listed in order of execution speed ((1) is fastest), but that's just my hunch.
Option (2) works like this:
WITH       got_r_num   AS
     SELECT     deptno
     ,     ename
     ,     ROW_NUMBER () OVER
                  (     PARTITION BY     deptno
                       ORDER BY       ename
                  ) AS r_num
     FROM     scott.emp
SELECT     deptno
,     SUBSTR ( SYS_CONNECT_BY_PATH (ename, ',')
            , 2
            )     AS ename_concat
FROM     got_r_num
WHERE     CONNECT_BY_ISLEAF     = 1
START WITH     r_num     = 1
CONNECT BY     r_num     = PRIOR r_num + 1
     AND     deptno     = PRIOR deptno;Option (3) works like this:
WITH  got_concat     AS
     SELECT     deptno
     ,     WM_CONCAT (ename) OVER
                 (       PARTITION BY     deptno
                        ORDER BY       ename
                 ) AS e_concat
     FROM     scott.emp
SELECT       deptno
,       MAX (e_concat)     AS ename_concat
FROM       got_concat
GROUP BY  deptno;Any user-defined aggregate function can also serve as an analytic function: just add "OVER (...)" when you run it.
Within each partition, the various values of e_concat will all be longer versions of one another, all starting the same way.
For example, in deoptno = 10, the various values are
CLARK
CLARK,KING
CLARK,KING,MILLERThe one you want to display is the longest one, which, since they all start the same way, will also be the MAX.