Concatenating clobs

Question

Hi
I have a question on concatenating many small clobs into a large. DB = 11.2.0.1.
The following is a sample set of data;
create table t_bi001_payment
(customer_number number
,payment clob
begin
for i in 1..1000 loop
insert into t_bi001_payment (customer_number
                            ,payment)
values  
(1
,'200003783511655968                   000000000000100000320000000000100
26Kalles Plåt AB
27Storgatan 2                        12345
28Storåker
29005500001234
210003783511                    898540000000000000500002200023000011100
26Kalles Plåt AB
27Storgatan 2                        12345
28Storåker
2900550000' || lpad(i, 4, '0'));
end loop;
commit;
end;
/There are thousands of such clobs, which have to be concatenated per customer into a single clob.
Each clob should start on a new line.
The first technique I used was connect by, which I picked up from; http://www.williamrobertson.net/
create table abc (c clob)
insert into abc (c)
select ltrim(max(sys_connect_by_path(payment,',')) keep (dense_rank last order by curr),',') as clob_val
from   (select customer_number
              ,payment
              ,row_number() over (partition by customer_number order by customer_number) AS curr,
               row_number() over (partition by customer_number order by customer_number) -1 AS prev
        from   t_bi001_payment)
group by customer_number
connect by prev = prior curr and customer_number = prior customer_number
start with curr = 1
commit
/The above statement returns error:
ORA-01489: result of string concatenation is too long
The following statement is an alternative method:
insert into abc (c)
select to_clob(concatenated)
from
select   xmlagg (xmlelement (c, payment || chr(13))).extract ('//text()') as concatenated
from     t_bi001_payment
group by customer_number
commit
/The above statement returns a similar error, but different message:
ORA-19011: Character string buffer too small
I realise that in both cases the SQL 4000 varchar2 limit has been reached.
The question I have is how can I concatenate hundreds or possibly
thousands of clobs (all relatively small, mostly around 1 or 2k)
into a single larger clob using SQL without having to revert to PL/SQL ?
thx
Edited by: bluefrog on Mar 8, 2011 10:52 AM

Answer 1

Oddly, I was just looking at the following example code in relation to another thread.
This is a user defined aggregate function for concatenating clobs...
create or replace
  type clobagg_type as object(
                              text clob,
                              static function ODCIAggregateInitialize(
                                                                      sctx in out clobagg_type
                                return number,
                              member function ODCIAggregateIterate(
                                                                   self  in out clobagg_type,
                                                                   value in     clob
                                return number,
                              member function ODCIAggregateTerminate(
                                                                     self        in     clobagg_type,
                                                                     returnvalue    out clob,
                                                                     flags       in     number
                                return number,
                              member function ODCIAggregateMerge(
                                                                 self in out clobagg_type,
                                                                 ctx2 in     clobagg_type
                                return number
create or replace
  type body clobagg_type
    is
      static function ODCIAggregateInitialize(
                                              sctx in out clobagg_type
        return number
        is
        begin
            sctx := clobagg_type(null) ;
            return ODCIConst.Success ;
      end;
      member function ODCIAggregateIterate(
                                           self  in out clobagg_type,
                                           value in     clob
        return number
        is
        begin
            self.text := self.text || value ;
            return ODCIConst.Success;
      end;
      member function ODCIAggregateTerminate(
                                             self        in     clobagg_type,
                                             returnvalue    out clob,
                                             flags       in     number
        return number
        is
        begin
            returnValue := self.text;
            return ODCIConst.Success;
        end;
      member function ODCIAggregateMerge(
                                         self in out clobagg_type ,
                                         ctx2 in     clobagg_type
        return number
        is
        begin
            self.text := self.text || ctx2.text;
            return ODCIConst.Success;
        end;
end;
create or replace
  function clobagg(
                   input clob
    return clob
    deterministic
    parallel_enable
    aggregate using clobagg_type;
SQL> select trim(',' from clobagg(ename||',')) as enames from emp;
ENAMES
SMITH,ALLEN,WARD,JONES,MARTIN,BLAKE,CLARK,SCOTT,KING,TURNER,ADAMS,JAMES,FORD,MILLER
SQL>Not my code, just one I've picked up from elsewhere over time.