求一个某字段连续重复最大次数的SQL的写法

nyfor

原帖由 grubbyoo 于 2008-11-18 13:29 发表
哈哈 感觉一个select 能实现， nyfor大侠来一个吧

这个是谁的专利来着? 是你的吧

原帖由 grubbyoo 于 2008-11-18 13:40 发表
请教nyfor一个问题，  wmsys.sys_concat 可以 对返回值 排序吗

没有研究过, 看之前的帖子讨论说资料太多的情况下可能不是有序的.
但自定义一个这样的聚集函数可以按你需要的进行排序

grubbyoo

找到了 nyfor可以试一试 这个  很强悍 ,竟然可以这么用 wmsys.wm_concat() over(partition by .. order  by ...)

bell6248

使用wmsys.wm_concat效率如何, 有何限制？

nyfor

原帖由 grubbyoo 于 2008-11-18 15:14 发表
找到了 nyfor可以试一试 这个  很强悍 ,竟然可以这么用 wmsys.wm_concat() over(partition by .. order  by ...)

呵呵,任何集聚函数都可以这么用, 包括自定义的集聚函数.

grubbyoo

原帖由 nyfor 于 2008-11-18 15:30 发表

呵呵,任何集聚函数都可以这么用, 包括自定义的集聚函数.

  太感谢了，今天又进步一点

dingjun123

自定义聚集函数的例子

1. 
   
2. create or replace type agg_t as object (
   
3. 
   
4.     str_agg varchar2(4000),
   
5. 
   
6.     static function ODCIAggregateInitialize(sctx  in out agg_t)
   
7.                     return number,
   
8. 
   
9.     member function ODCIAggregateIterate   (self  in out agg_t,
   
10.                                             value in varchar2 )
    
11.                     return number,
    
12. 
    
13.     member function ODCIAggregateTerminate (self         in     agg_t   ,
    
14.                                             return_value    out varchar2,
    
15.                                             flags        in number      )               
    
16.                     return number,
    
17. 
    
18.     member function ODCIAggregateMerge(self in out agg_t,
    
19.                                        ctx2 in agg_t    )
    
20.                     return number
    
21. );
    
22. /
    
23. 
    
24. create or replace type body agg_t is
    
25. 
    
26.     static function ODCIAggregateInitialize(sctx in out agg_t)
    
27.         return number is
    
28.     begin
    
29.         sctx := agg_t(null);
    
30.         return ODCIConst.Success;
    
31.     end;
    
32. 
    
33.     member function ODCIAggregateIterate(
    
34.       self in out agg_t, value in varchar2)
    
35.         return number is
    
36.     begin
    
37.         str_agg := str_agg || value;
    
38.         return ODCIConst.Success;
    
39.     end;
    
40. 
    
41.     member function ODCIAggregateTerminate(self in agg_t,
    
42.         return_value out varchar2, flags in number) return number is
    
43.     begin
    
44.         return_value := str_agg;
    
45.         return ODCIConst.Success;
    
46.     end;
    
47. 
    
48.     member function ODCIAggregateMerge(self in out agg_t,
    
49.         ctx2 in agg_t) return number is
    
50.     begin
    
51.         str_agg := str_agg || ctx2.str_agg;
    
52.         return ODCIConst.Success;
    
53.     end;
    
54. end;
    
55. /
    
56. 
    
57. create or replace function agg_concat (input varchar2) return varchar2
    
58.     parallel_enable aggregate using agg_t;
    
59. /
    
60. create table agg_test (
    
61.   a number,
    
62.   b varchar2(5)
    
63. );
    
64. 
    
65. insert into agg_test values (1,'a');
    
66. insert into agg_test values (2,'A');
    
67. insert into agg_test values (1,'b');
    
68. insert into agg_test values (1,'c');
    
69. insert into agg_test values (2,'B');
    
70. insert into agg_test values (2,'C');
    
71. insert into agg_test values (1,'d');
    
72. insert into agg_test values (2,'D');
    
73. column b_conc format a30
    
74. select
    
75.   a, agg_concat(b) b_conc from agg_test
    
76. group by
    
77.   a;
    
78.         A B_CONC
    
79. ---------- ------------------------------
    
80.          1 abcd
    
81.          2 ABCD
    

复制代码

grubbyoo

nyfor

自定义集聚函数, 只要把这个模板保存起来, 以后想要什么样的就可以得到什么样的

douqq

试试这个

select t3.tel_no, max(t4.rn - t3.rn)
  from (select rownum as rn,
               t.tel_no,
               t.call_date_time,
               decode(t.call_result, 01, 1, 0) as times
          from test t
         order by t.tel_no, t.call_date_time) t3
inner join (select rownum as rn,
                    t.tel_no,
                    t.call_date_time,
                    decode(t.call_result, 01, 1, 0) as times
               from test t
              order by t.tel_no, t.call_date_time) t4 on t3.tel_no =
                                                         t4.tel_no

where t4.times = 0
      
   and t3.times = 1
   and t4.rn > t3.rn
      
   and t4.call_date_time = (select min(t5.call_date_time)
                              from (select rownum as rn,
                                           t.tel_no,
                                           t.call_date_time,
                                           decode(t.call_result, 01, 1, 0) as times
                                      from test t
                                     order by t.tel_no, t.call_date_time) t5
                             where t5.tel_no = t3.tel_no
                               and t5.times = 0
                               and t5.rn > t3.rn)
group by t3.tel_no
order by t3.tel_no

newkid

原帖由 grubbyoo 于 2008-11-18 15:14 发表
找到了 nyfor可以试一试 这个  很强悍 ,竟然可以这么用 wmsys.wm_concat() over(partition by .. order  by ...)

在group by中使用，顺序没有保证；用作分析函数，顺序得到保证。但就是得再用MAX把最后那个取出来。