plsql優化笛卡爾積

原創 编程小强 2020-06-19 20:46

轉載自：http://www.itpub.net/thread-1840767-1-1.html

寫在最前，是對我自己而言收穫最大的想法。
oracle的優化，瞭解CBO很重要，分析執行計劃很重要；
但是，優化絕不止於CBO，相比之下優化必談CBO，我覺得多少有點誤區。
我們究竟是否明白一個sql或者一段plsql執行過程中哪步最費時？爲什麼？
--******************************************************
正題
論壇上有很多網友問過這樣的問題：
我的表中有一個字段text，有一個分隔符 ','，需要按照分隔符把數據分爲n行，每行按順序取夾在分隔符中的部分
比如數據是
id                        text
1                        a, b, c, d
2                        e, f, g
我需要的結果是
1        a
1        b
1        c
1        d
2        e
2        f
2        g

這時候，很多網友會用itpub上最經典的sql回覆
  1. select        id, regexp_substr(text, '[^'||chr(10)||']+', 1, level) item_txt
  2. from        t1
  3. connect by prior id=id and level<=length(text)-length(replace(text, chr(10))) and prior dbms_random.value>0;
複製代碼
當然，也可能有“正則黑”，會用substr套instr的版本來實現。
當然，也會有笛卡爾積的版本。
總之，這已經成了一個套路。

但是，這樣做真的好麼？
我以前從來沒思考過這個問題，直到我的項目中真正接觸到了這個問題，我才發現，sql的幾個寫法，幾乎只有理論上的意義。
我們來測測。
  1. create table t1 (id int, text varchar2(4000));
  2. insert into t1
  3. select        1, listagg(lpad('a', 60), chr(10)) within group (order by 1)||chr(10)
  4. from        dual
  5. connect by rownum<=64;

  7. insert into t1
  8. select        n+1, text
  9. from        t1, (select rownum n from dual connect by rownum<=199);
複製代碼
  1. --sql connect by 寫法
  2. bill@ORCL> select       id, regexp_substr(text, '[^'||chr(10)||']+', 1, level) item_txt
  3.   2  from       t1
  4.   3  connect by prior id=id and level<=length(text)-length(replace(text, chr(10))) and prior dbms_random.value>0;

  6. 已選擇 12800 行。

  8. 已用時間:  00: 00: 16.24

  10. 執行計劃
  11. ----------------------------------------------------------
  12. Plan hash value: 3874795171

  14. -------------------------------------------------------------------------------------
  15. | Id  | Operation                    | Name | Rows  | Bytes | Cost (%CPU)| Time     |
  16. -------------------------------------------------------------------------------------
  17. |   0 | SELECT STATEMENT             |      |   186 |   366K|    68   (0)| 00:00:01 |
  18. |*  1 |  CONNECT BY WITHOUT FILTERING|      |       |       |            |          |
  19. |   2 |   TABLE ACCESS FULL          | T1   |   186 |   366K|    68   (0)| 00:00:01 |
  20. -------------------------------------------------------------------------------------

  22. Predicate Information (identified by operation id):
  23. ---------------------------------------------------

  25.    1 - access("ID"=PRIOR "ID")
  26.        filter(LEVEL<=LENGTH("TEXT")-LENGTH(REPLACE("TEXT",' ')) AND PRIOR
  27.               "DBMS_RANDOM"."VALUE"()>0)

  29. Note
  30. -----
  31.    - dynamic statistics used: dynamic sampling (level=2)


  34. 統計信息
  35. ----------------------------------------------------------
  36.           4  recursive calls
  37.           0  db block gets
  38.         313  consistent gets
  39.           0  physical reads
  40.           0  redo size
  41.      228399  bytes sent via SQL*Net to client
  42.        9927  bytes received via SQL*Net from client
  43.         855  SQL*Net roundtrips to/from client
  44.           1  sorts (memory)
  45.           0  sorts (disk)
  46.       12800  rows processed
複製代碼
16秒這個時間有點出乎我的意料。我沒想到會這麼慢，試試substr套instr的版本
  1. bill@ORCL> select       id, substr(text,
  2.   2                                decode(level, 1, 1, instr(text, chr(10), 1, level-1)+1)),
  3.   3                                instr(text, chr(10), 1, level)-decode(level, 1, 1, instr(text, chr(10), 1, level-1)+1)
  4.   4  from       t1
  5.   5  connect by prior id=id and level<=length(text)-length(replace(text, chr(10))) and prior dbms_random.value>0;

  7. 已選擇 12800 行。

  9. 已用時間:  00: 00: 04.89

  11. 執行計劃
  12. ----------------------------------------------------------
  13. Plan hash value: 3874795171

  15. -------------------------------------------------------------------------------------
  16. | Id  | Operation                    | Name | Rows  | Bytes | Cost (%CPU)| Time     |
  17. -------------------------------------------------------------------------------------
  18. |   0 | SELECT STATEMENT             |      |   186 |   366K|    68   (0)| 00:00:01 |
  19. |*  1 |  CONNECT BY WITHOUT FILTERING|      |       |       |            |          |
  20. |   2 |   TABLE ACCESS FULL          | T1   |   186 |   366K|    68   (0)| 00:00:01 |
  21. -------------------------------------------------------------------------------------

  23. Predicate Information (identified by operation id):
  24. ---------------------------------------------------

  26.    1 - access("ID"=PRIOR "ID")
  27.        filter(LEVEL<=LENGTH("TEXT")-LENGTH(REPLACE("TEXT",' ')) AND PRIOR
  28.               "DBMS_RANDOM"."VALUE"()>0)

  30. Note
  31. -----
  32.    - dynamic statistics used: dynamic sampling (level=2)


  35. 統計信息
  36. ----------------------------------------------------------
  37.           0  recursive calls
  38.           0  db block gets
  39.         248  consistent gets
  40.           0  physical reads
  41.           0  redo size
  42.    25757310  bytes sent via SQL*Net to client
  43.        9927  bytes received via SQL*Net from client
  44.         855  SQL*Net roundtrips to/from client
  45.           1  sorts (memory)
  46.           0  sorts (disk)
  47.       12800  rows processed
複製代碼
強多了，看來oracle的正則最好是能不用盡量不用。
但是仍然很不滿意，這才幾條數據啊。
試試笛卡爾積的版本

  1. bill@ORCL> select       substr(text,
  2.   2                        decode(lv, 1, 1, instr(text, chr(10), 1, lv-1)+1)),
  3.   3                        instr(text, chr(10), 1, lv)-decode(lv, 1, 1, instr(text, chr(10), 1, lv-1)+1)
  4.   4  from       t1,
  5.   5             (select rownum lv from dual connect by rownum<=64) b;

  7. 已選擇 12800 行。

  9. 已用時間:  00: 00: 03.30

  11. 執行計劃
  12. ----------------------------------------------------------
  13. Plan hash value: 894562235

  15. ----------------------------------------------------------------------------------------
  16. | Id  | Operation                       | Name | Rows  | Bytes | Cost (%CPU)| Time     |
  17. ----------------------------------------------------------------------------------------
  18. |   0 | SELECT STATEMENT                |      |   186 |   366K|    70   (0)| 00:00:01 |
  19. |   1 |  MERGE JOIN CARTESIAN           |      |   186 |   366K|    70   (0)| 00:00:01 |
  20. |   2 |   VIEW                          |      |     1 |    13 |     2   (0)| 00:00:01 |
  21. |   3 |    COUNT                        |      |       |       |            |          |
  22. |*  4 |     CONNECT BY WITHOUT FILTERING|      |       |       |            |          |
  23. |   5 |      FAST DUAL                  |      |     1 |       |     2   (0)| 00:00:01 |
  24. |   6 |   BUFFER SORT                   |      |   186 |   363K|    70   (0)| 00:00:01 |
  25. |   7 |    TABLE ACCESS FULL            | T1   |   186 |   363K|    68   (0)| 00:00:01 |
  26. ----------------------------------------------------------------------------------------

  28. Predicate Information (identified by operation id):
  29. ---------------------------------------------------

  31.    4 - filter(ROWNUM<=64)

  33. Note
  34. -----
  35.    - dynamic statistics used: dynamic sampling (level=2)


  38. 統計信息
  39. ----------------------------------------------------------
  40.          48  recursive calls
  41.           0  db block gets
  42.         435  consistent gets
  43.           2  physical reads
  44.           0  redo size
  45.      359032  bytes sent via SQL*Net to client
  46.        9927  bytes received via SQL*Net from client
  47.         855  SQL*Net roundtrips to/from client
  48.           8  sorts (memory)
  49.           0  sorts (disk)
  50.       12800  rows processed
複製代碼
又快一點，不過僅僅一點而已，數量級是不會變了。
試試物理表
  1. create table t2 (id int, lv int, text varchar2(4000));
  2. insert into t2
  3. select        (n-1)*200+id, n, text
  4. from        t1, (select rownum n from dual connect by rownum<=64);

  6. bill@ORCL> select       substr(text,
  7.   2                        decode(lv, 1, 1, instr(text, chr(10), 1, lv-1)+1)),
  8.   3                        instr(text, chr(10), 1, lv)-decode(lv, 1, 1, instr(text, chr(10), 1, lv-1)+1)
  9.   4  from       t2;

  11. 已選擇 12800 行。

  13. 已用時間:  00: 00: 03.53

  15. 執行計劃
  16. ----------------------------------------------------------
  17. Plan hash value: 1513984157

  19. --------------------------------------------------------------------------
  20. | Id  | Operation         | Name | Rows  | Bytes | Cost (%CPU)| Time     |
  21. --------------------------------------------------------------------------
  22. |   0 | SELECT STATEMENT  |      | 15663 |    30M|  3567   (1)| 00:00:01 |
  23. |   1 |  TABLE ACCESS FULL| T2   | 15663 |    30M|  3567   (1)| 00:00:01 |
  24. --------------------------------------------------------------------------

  26. Note
  27. -----
  28.    - dynamic statistics used: dynamic sampling (level=2)


  31. 統計信息
  32. ----------------------------------------------------------
  33.           0  recursive calls
  34.           0  db block gets
  35.       13005  consistent gets
  36.       12997  physical reads
  37.           0  redo size
  38.     3526140  bytes sent via SQL*Net to client
  39.        9927  bytes received via SQL*Net from client
  40.         855  SQL*Net roundtrips to/from client
  41.           0  sorts (memory)
  42.           0  sorts (disk)
  43.       12800  rows processed
複製代碼
從實驗現象來看，似乎oracle不管你select的substr需要多少空間，都把全表複製64份，再取substr。如果是這樣，那這裏的內存操作實在太低效了。
多做兩個實驗看看。
  1. bill@ORCL> select       substr(text,
  2.   2                        decode(lv, 1, 1, instr(text, chr(10), 1, lv-1)+1)),
  3.   3                        instr(text, chr(10), 1, lv)-decode(lv, 1, 1, instr(text, chr(10), 1, lv-1)+1)
  4.   4  from       t1,
  5.   5             (
  6.   6             select  id, lv
  7.   7             from    (select id from t1),
  8.   8                             (select rownum lv from dual connect by rownum<=64)
  9.   9             where   rownum>0
  10. 10             ) b
  11. 11  where      t1.id=b.id;

  13. 已選擇 12800 行。

  15. 已用時間:  00: 00: 03.56

  17. 執行計劃
  18. ----------------------------------------------------------
  19. Plan hash value: 553474792

  21. ----------------------------------------------------------------------------------------------------
  22. | Id  | Operation                           | Name         | Rows  | Bytes | Cost (%CPU)| Time     |
  23. ----------------------------------------------------------------------------------------------------
  24. |   0 | SELECT STATEMENT                    |              |   187 |   372K|    71   (0)| 00:00:01 |
  25. |*  1 |  HASH JOIN                          |              |   187 |   372K|    71   (0)| 00:00:01 |
  26. |   2 |   VIEW                              |              |   186 |  4836 |     3   (0)| 00:00:01 |
  27. |   3 |    COUNT                            |              |       |       |            |          |
  28. |*  4 |     FILTER                          |              |       |       |            |          |
  29. |   5 |      MERGE JOIN CARTESIAN           |              |   186 |  4836 |     3   (0)| 00:00:01 |
  30. |   6 |       VIEW                          |              |     1 |    13 |     2   (0)| 00:00:01 |
  31. |   7 |        COUNT                        |              |       |       |            |          |
  32. |*  8 |         CONNECT BY WITHOUT FILTERING|              |       |       |            |          |
  33. |   9 |          FAST DUAL                  |              |     1 |       |     2   (0)| 00:00:01 |
  34. |  10 |       BUFFER SORT                   |              |   186 |  2418 |     3   (0)| 00:00:01 |
  35. |  11 |        INDEX FULL SCAN              | SYS_C0010642 |   186 |  2418 |     1   (0)| 00:00:01 |
  36. |  12 |   TABLE ACCESS FULL                 | T1           |   186 |   366K|    68   (0)| 00:00:01 |
  37. ----------------------------------------------------------------------------------------------------

  39. Predicate Information (identified by operation id):
  40. ---------------------------------------------------

  42.    1 - access("T1"."ID"="B"."ID")
  43.    4 - filter(ROWNUM>0)
  44.    8 - filter(ROWNUM<=64)

  46. Note
  47. -----
  48.    - dynamic statistics used: dynamic sampling (level=2)


  51. 統計信息
  52. ----------------------------------------------------------
  53.          15  recursive calls
  54.           0  db block gets
  55.         515  consistent gets
  56.           9  physical reads
  57.           0  redo size
  58.    25712495  bytes sent via SQL*Net to client
  59.        9927  bytes received via SQL*Net from client
  60.         855  SQL*Net roundtrips to/from client
  61.           2  sorts (memory)
  62.           0  sorts (disk)
  63.       12800  rows processed
複製代碼
可以看到，改寫的速度也是一樣，似乎效率還要更差一點。
再看看我們明確的告訴oracle select的字段內容，它的表現怎麼樣，
  1. bill@ORCL> select       substr(t1.id, instr(text, chr(10), 1, 58), instr(text, chr(10), 1, 59)-instr(text, chr(10), 1, 58)-1) item_txt
  2.   2  from       t1,
  3.   3             (select rownum lv from dual connect by rownum<=64) b;

  5. 已選擇 12800 行。

  7. 已用時間:  00: 00: 01.26

  9. 執行計劃
  10. ----------------------------------------------------------
  11. Plan hash value: 894562235

  13. ----------------------------------------------------------------------------------------
  14. | Id  | Operation                       | Name | Rows  | Bytes | Cost (%CPU)| Time     |
  15. ----------------------------------------------------------------------------------------
  16. |   0 | SELECT STATEMENT                |      |   186 |   366K|    70   (0)| 00:00:01 |
  17. |   1 |  MERGE JOIN CARTESIAN           |      |   186 |   366K|    70   (0)| 00:00:01 |
  18. |   2 |   VIEW                          |      |     1 |       |     2   (0)| 00:00:01 |
  19. |   3 |    COUNT                        |      |       |       |            |          |
  20. |*  4 |     CONNECT BY WITHOUT FILTERING|      |       |       |            |          |
  21. |   5 |      FAST DUAL                  |      |     1 |       |     2   (0)| 00:00:01 |
  22. |   6 |   BUFFER SORT                   |      |   186 |   366K|    70   (0)| 00:00:01 |
  23. |   7 |    TABLE ACCESS FULL            | T1   |   186 |   366K|    68   (0)| 00:00:01 |
  24. ----------------------------------------------------------------------------------------

  26. Predicate Information (identified by operation id):
  27. ---------------------------------------------------

  29.    4 - filter(ROWNUM<=64)

  31. Note
  32. -----
  33.    - dynamic statistics used: dynamic sampling (level=2)


  36. 統計信息
  37. ----------------------------------------------------------
  38.           7  recursive calls
  39.           0  db block gets
  40.         380  consistent gets
  41.           2  physical reads
  42.           0  redo size
  43.      227513  bytes sent via SQL*Net to client
  44.        9927  bytes received via SQL*Net from client
  45.         855  SQL*Net roundtrips to/from client
  46.           2  sorts (memory)
  47.           0  sorts (disk)
  48.       12800  rows processed
複製代碼
又快了一些。
那經過這些測試，似乎可以得出這樣的結論，cpu運算和內存操作現在是需要考慮的重要因素(本來也是，只不過我們似乎總是做不了什麼來優化這些)。
很顯然的結論就是，長的字符串，我們對它進行的substr和instr操作，自然會更慢，變量的賦值，效率也會更低。
思考到這裏，似乎需要轉向plsql了。
因爲我的需求中，打散之後的結果是要和其他表繼續關聯，所以我理所當然想要用管道表函數來試試。
第一個版本的代碼並不難寫，除了plsql中這些複雜的語法，當然複雜是相對sql而言，其他高級編程語言請呵呵。
  1. create or replace package refcur_pkg_v1
  2. authid current_user
  3. as
  4.     type inrec is record (
  5.         id                        number(38),
  6.         text                varchar2(4000));
  7.     type refcur_t is ref cursor return inrec;
  8.     type outrec_typ is record (
  9.         id                        number(38),
  10.         item_txt        varchar2(4000));
  11.     type outrecset is table of outrec_typ;
  12.     function f_cartesian (p refcur_t) return outrecset pipelined
  13.     parallel_enable (partition p by any);
  14. end;
  15. /

  17. create or replace PACKAGE BODY refcur_pkg_v1 IS
  18.     FUNCTION f_cartesian (p refcur_t) RETURN outrecset PIPELINED
  19.     parallel_enable (partition p by any)
  20.     IS
  21.         in_rec      p%ROWTYPE;
  22.         out_rec     outrec_typ;
  23.         C_NL_TERM   varchar2(2) := chr(10); --unix style
  24.         v_nl_pos    int:=0;
  25.         v_tmp_pos        int:=0;
  26.     BEGIN
  27.         LOOP
  28.             FETCH p INTO in_rec;  -- input row
  29.             EXIT WHEN p%NOTFOUND;

  31.                 v_nl_pos        :=0;
  32.                 v_tmp_pos        :=0;
  33.             out_rec.id        :=in_rec.id;
  34.             FOR i IN 1..100000 LOOP
  35.                 v_tmp_pos:=instr(in_rec.text, C_NL_TERM, v_nl_pos+1);
  36.                                 exit when v_tmp_pos=0;
  37.                 out_rec.item_txt        :=substr(in_rec.text, v_nl_pos+1, v_tmp_pos-v_nl_pos-1);
  38.                 v_nl_pos                        :=v_tmp_pos;
  39.                 PIPE ROW(out_rec);
  40.             END LOOP;

  42.         END LOOP;
  43.         CLOSE p;
  44.         RETURN;
  45.     END f_cartesian;
  46. END refcur_pkg_v1;
  47. /
複製代碼
  1. bill@ORCL> select       id, item_txt
  2.   2  from       table(refcur_pkg_v1.f_cartesian(cursor(
  3.   3                     select  id, text
  4.   4                     from    t1
  5.   5                     )));

  7. 已選擇 12800 行。

  9. 已用時間:  00: 00: 00.70

  11. 執行計劃
  12. ----------------------------------------------------------
  13. Plan hash value: 4049074522

  15. --------------------------------------------------------------------------------------------------
  16. | Id  | Operation                          | Name        | Rows  | Bytes | Cost (%CPU)| Time     |
  17. --------------------------------------------------------------------------------------------------
  18. |   0 | SELECT STATEMENT                   |             |  8168 |   271K|    29   (0)| 00:00:01 |
  19. |   1 |  VIEW                              |             |  8168 |   271K|    29   (0)| 00:00:01 |
  20. |   2 |   COLLECTION ITERATOR PICKLER FETCH| F_CARTESIAN |  8168 |       |    29   (0)| 00:00:01 |
  21. |   3 |    TABLE ACCESS FULL               | T1          |   186 |   366K|    68   (0)| 00:00:01 |
  22. --------------------------------------------------------------------------------------------------

  24. Note
  25. -----
  26.    - dynamic statistics used: dynamic sampling (level=2)


  29. 統計信息
  30. ----------------------------------------------------------
  31.         217  recursive calls
  32.           0  db block gets
  33.         264  consistent gets
  34.           0  physical reads
  35.           0  redo size
  36.      228399  bytes sent via SQL*Net to client
  37.        9927  bytes received via SQL*Net from client
  38.         855  SQL*Net roundtrips to/from client
  39.           0  sorts (memory)
  40.           0  sorts (disk)
  41.       12800  rows processed
複製代碼
0.7秒!看來方向是正確的。
但是我的需求中數據量很龐大，最好還能繼續優化一下。
現在的版本是帶着整個text的內容去循環，那很自然的會想用二分法去試一試。
  1. create or replace package refcur_pkg
  2. authid current_user
  3. as
  4.     type inrec is record (
  5.         id                        number(38),
  6.         lines                number(38),
  7.         text                varchar2(4000));
  8.     type refcur_t is ref cursor return inrec;
  9.     type outrec_typ is record (
  10.         id                        number(38),
  11.         item_txt        varchar2(4000));
  12.     type outrecset is table of outrec_typ;
  13.     function f_cartesian (p refcur_t) return outrecset pipelined
  14.     parallel_enable (partition p by any);
  15.     function f_cartesian2 (p refcur_t) return outrecset pipelined
  16.     parallel_enable (partition p by any);
  17.     function f_cartesian3 (p refcur_t) return outrecset pipelined
  18.     parallel_enable (partition p by any);
  19. end;
  20. /

  22. create or replace package body refcur_pkg IS
  23.     function f_cartesian (p refcur_t) return outrecset pipelined
  24.     parallel_enable (partition p by any)
  25.     is
  26.         in_rec      p%ROWTYPE;
  27.         out_rec     outrec_typ;
  28.         C_NL_TERM   varchar2(2) := chr(10); --unix style
  29.         C_NL_LENG   int := 1;                           --unix new line length
  30.         C_SIZE                int:=64;                                --split clob to varchar by every C_SIZE-th newline character
  31.         C_MAX_LEN        INT:=1024;                                --max length for item_txt; if change, also change item_txt varchar2(1024)
  32.         v_div_pos        int;                                        --end postion of each sub clob
  33.         v1_div_pos        int;                                        --end postion of each sub clob
  34.         v2_div_pos        int;                                        --end postion of each sub clob
  35.         v3_div_pos        int;                                        --end postion of each sub clob
  36.         v4_div_pos        int;                                        --end postion of each sub clob
  37.         v5_div_pos        int;                                        --end postion of each sub clob
  38.         v1_substr        varchar2(4000);
  39.         v2_substr        varchar2(4000);
  40.         v3_substr        varchar2(4000);
  41.         v4_substr        varchar2(4000);
  42.         v5_substr        varchar2(4000);
  43.     begin
  44.         loop
  45.             fetch p into in_rec;  -- input row
  46.             exit when p%NOTFOUND;
  47.             out_rec.id                :=in_rec.id;

  49.                         --if lines=C_SIZE, then dichotomy
  50.                         if in_rec.lines=C_SIZE then
  51.                         v_div_pos        :=instr(in_rec.text, C_NL_TERM, 1, C_SIZE/2);
  52.                         for a in 1..2 loop
  53.                                 v1_substr        :=substr(in_rec.text, 1+v_div_pos*(a-1), v_div_pos*(2-a)+1e6*(a-1));
  54.                                 v1_div_pos        :=instr(v1_substr, C_NL_TERM, 1, C_SIZE/4);
  55.                                 for b in 1..2 loop
  56.                                         v2_substr        :=substr(v1_substr, 1+v1_div_pos*(b-1), v1_div_pos*(2-b)+1e6*(b-1));
  57.                                         v2_div_pos        :=instr(v2_substr, C_NL_TERM, 1, C_SIZE/8);
  58.                                         for c in 1..2 loop
  59.                                                 v3_substr        :=substr(v2_substr, 1+v2_div_pos*(c-1), v2_div_pos*(2-c)+1e6*(c-1));
  60.                                                 v3_div_pos        :=instr(v3_substr, C_NL_TERM, 1, C_SIZE/16);
  61.                                                 for d in 1..2 loop
  62.                                                         v4_substr        :=substr(v3_substr, 1+v3_div_pos*(d-1), v3_div_pos*(2-d)+1e6*(d-1));
  63.                                                         v4_div_pos        :=instr(v4_substr, C_NL_TERM, 1, C_SIZE/32);
  64.                                                         for e in 1..2 loop
  65.                                                                 v5_substr        :=substr(v4_substr, 1+v4_div_pos*(e-1), v4_div_pos*(2-e)+1e6*(e-1));
  66.                                                                 v5_div_pos        :=instr(v5_substr, C_NL_TERM, 1, 1);
  67.                                                                 for f in 1..2 loop
  68.                                                                         out_rec.item_txt        :=substr(v5_substr, 1+v5_div_pos*(f-1), (v5_div_pos-1)*(2-f)+(v4_div_pos-v5_div_pos-1)*(f-1));
  69.                                                                         exit when out_rec.item_txt is null;
  70.                                                                         pipe row(out_rec);
  71.                                                                 end loop;
  72.                                                         end loop;
  73.                                                 end loop;
  74.                                         end loop;
  75.                                 end loop;
  76.                         end loop;
  77.                         --if lines=C_SIZE, then ordinary loop method,
  78.                         else
  79.                                 v_div_pos:=0;
  80.                                 v1_div_pos:=0;
  81.                                 for i in 1..1000000000 loop
  82.                         v1_div_pos:=instr(in_rec.text, C_NL_TERM, v_div_pos+1);
  83.                                         exit when v1_div_pos=0;
  84.                         out_rec.item_txt        :=substr(in_rec.text, v_div_pos+1, v1_div_pos-v_div_pos-1);
  85.                         v_div_pos                        :=v1_div_pos;
  86.                         pipe row(out_rec);
  87.                     end loop;
  88.                         end if;
  89.         end loop;
  90.         close p;
  91.         return;
  92.     end f_cartesian;

  94.     function f_cartesian2 (p refcur_t) return outrecset pipelined
  95.     parallel_enable (partition p by any)
  96.     is
  97.         in_rec      p%ROWTYPE;
  98.         out_rec     outrec_typ;
  99.     begin
  100.         loop
  101.             fetch p into in_rec;  -- input row
  102.             exit when p%NOTFOUND;
  103.             out_rec.id                        :=in_rec.id;
  104.                         out_rec.item_txt        :=in_rec.text;
  105.                         for i in 1..in_rec.lines loop
  106.                                 pipe row(out_rec);
  107.                         end loop;
  108.         end loop;
  109.         close p;
  110.         return;
  111.     end f_cartesian2;

  113.     function f_cartesian3 (p refcur_t) return outrecset pipelined
  114.     parallel_enable (partition p by any)
  115.     is
  116.         in_rec      p%ROWTYPE;
  117.         out_rec     outrec_typ;
  118.     begin
  119.         loop
  120.             fetch p into in_rec;  -- input row
  121.             exit when p%NOTFOUND;
  122.             out_rec.id                        :=in_rec.id;
  123.                         out_rec.item_txt        :=substr(in_rec.text, 1, 64);
  124.                         for i in 1..in_rec.lines loop
  125.                                 pipe row(out_rec);
  126.                         end loop;
  127.         end loop;
  128.         close p;
  129.         return;
  130.     end f_cartesian3;

  132. end refcur_pkg;
  133. /
複製代碼
  1. bill@ORCL> select       id, item_txt
  2.   2  from       table(refcur_pkg.f_cartesian(cursor(
  3.   3                     select  id, length(text)-length(replace(text, chr(10))), text
  4.   4                     from    t1
  5.   5                     )));

  7. 已選擇 12800 行。

  9. 已用時間:  00: 00: 00.40

  11. 執行計劃
  12. ----------------------------------------------------------
  13. Plan hash value: 4049074522

  15. --------------------------------------------------------------------------------------------------
  16. | Id  | Operation                          | Name        | Rows  | Bytes | Cost (%CPU)| Time     |
  17. --------------------------------------------------------------------------------------------------
  18. |   0 | SELECT STATEMENT                   |             |  8168 |   271K|    29   (0)| 00:00:01 |
  19. |   1 |  VIEW                              |             |  8168 |   271K|    29   (0)| 00:00:01 |
  20. |   2 |   COLLECTION ITERATOR PICKLER FETCH| F_CARTESIAN |  8168 |       |    29   (0)| 00:00:01 |
  21. |   3 |    TABLE ACCESS FULL               | T1          |   186 |   366K|    68   (0)| 00:00:01 |
  22. --------------------------------------------------------------------------------------------------

  24. Note
  25. -----
  26.    - dynamic statistics used: dynamic sampling (level=2)


  29. 統計信息
  30. ----------------------------------------------------------
  31.         258  recursive calls
  32.           0  db block gets
  33.         469  consistent gets
  34.           1  physical reads
  35.           0  redo size
  36.      228399  bytes sent via SQL*Net to client
  37.        9927  bytes received via SQL*Net from client
  38.         855  SQL*Net roundtrips to/from client
  39.           0  sorts (memory)
  40.           0  sorts (disk)
  41.       12800  rows processed
複製代碼
我不太想詳細解釋二分法的代碼，因爲它太醜了，而代碼本身的邏輯其實很簡單。
因爲在我的處理中，是要從clob進行打散，所以我先把之前的處理結果分成64行爲一個大的varchar，到這裏再用硬性的6層二分法，
如果你的需求中行數不定，可以略微更改一下if條件，以及二分法的層數，這樣可以不必在二分法的層數上太過傷神。
總之，我們看到了性能的提升，是顯著的，而且，在我的測試當中，我發現先把instr的變量存起來，
也就是類似substr(in_rec.text, v_nl_pos+1, v_tmp_pos-v_nl_pos-1)這種寫法，要更高效，上面的代碼其實還可以再改。

純粹爲了測試，我還做了f_cartesian2和f_cartesian3，
前者是簡單的實現數據的複製，後者是每行取指定的substr，在這兩種情況下，其實plsql就沒有什麼優勢了。
  1. --sql connect by
  2. bill@ORCL> select       id, text
  3.   2  from       t1
  4.   3  connect by prior id=id and level<=length(text)-length(replace(text, chr(10))) and prior dbms_random.value>0;

  6. 已選擇 12800 行。

  8. 已用時間:  00: 00: 06.81

  10. 執行計劃
  11. ----------------------------------------------------------
  12. Plan hash value: 3874795171

  14. -------------------------------------------------------------------------------------
  15. | Id  | Operation                    | Name | Rows  | Bytes | Cost (%CPU)| Time     |
  16. -------------------------------------------------------------------------------------
  17. |   0 | SELECT STATEMENT             |      |   186 |   366K|    68   (0)| 00:00:01 |
  18. |*  1 |  CONNECT BY WITHOUT FILTERING|      |       |       |            |          |
  19. |   2 |   TABLE ACCESS FULL          | T1   |   186 |   366K|    68   (0)| 00:00:01 |
  20. -------------------------------------------------------------------------------------

  22. Predicate Information (identified by operation id):
  23. ---------------------------------------------------

  25.    1 - access("ID"=PRIOR "ID")
  26.        filter(LEVEL<=LENGTH("TEXT")-LENGTH(REPLACE("TEXT",' ')) AND PRIOR
  27.               "DBMS_RANDOM"."VALUE"()>0)

  29. Note
  30. -----
  31.    - dynamic statistics used: dynamic sampling (level=2)


  34. 統計信息
  35. ----------------------------------------------------------
  36.           4  recursive calls
  37.           0  db block gets
  38.         313  consistent gets
  39.           0  physical reads
  40.           0  redo size
  41.      236099  bytes sent via SQL*Net to client
  42.        9927  bytes received via SQL*Net from client
  43.         855  SQL*Net roundtrips to/from client
  44.           1  sorts (memory)
  45.           0  sorts (disk)
  46.       12800  rows processed

  48. --sql笛卡爾
  49. bill@ORCL> select       id, text
  50.   2  from       t1,
  51.   3  (select rownum n from dual connect by rownum<=64) b;

  53. 已選擇 12800 行。

  55. 已用時間:  00: 00: 05.00

  57. 執行計劃
  58. ----------------------------------------------------------
  59. Plan hash value: 894562235

  61. ----------------------------------------------------------------------------------------
  62. | Id  | Operation                       | Name | Rows  | Bytes | Cost (%CPU)| Time     |
  63. ----------------------------------------------------------------------------------------
  64. |   0 | SELECT STATEMENT                |      |   186 |   366K|    70   (0)| 00:00:01 |
  65. |   1 |  MERGE JOIN CARTESIAN           |      |   186 |   366K|    70   (0)| 00:00:01 |
  66. |   2 |   VIEW                          |      |     1 |       |     2   (0)| 00:00:01 |
  67. |   3 |    COUNT                        |      |       |       |            |          |
  68. |*  4 |     CONNECT BY WITHOUT FILTERING|      |       |       |            |          |
  69. |   5 |      FAST DUAL                  |      |     1 |       |     2   (0)| 00:00:01 |
  70. |   6 |   BUFFER SORT                   |      |   186 |   366K|    70   (0)| 00:00:01 |
  71. |   7 |    TABLE ACCESS FULL            | T1   |   186 |   366K|    68   (0)| 00:00:01 |
  72. ----------------------------------------------------------------------------------------

  74. Predicate Information (identified by operation id):
  75. ---------------------------------------------------

  77.    4 - filter(ROWNUM<=64)

  79. Note
  80. -----
  81.    - dynamic statistics used: dynamic sampling (level=2)


  84. 統計信息
  85. ----------------------------------------------------------
  86.           7  recursive calls
  87.           0  db block gets
  88.         378  consistent gets
  89.           0  physical reads
  90.           0  redo size
  91.      280133  bytes sent via SQL*Net to client
  92.        9927  bytes received via SQL*Net from client
  93.         855  SQL*Net roundtrips to/from client
  94.           2  sorts (memory)
  95.           0  sorts (disk)
  96.       12800  rows processed

  98. --管道表函數
  99. bill@ORCL> select       id, item_txt
  100.   2  from       table(refcur_pkg.f_cartesian2(cursor(
  101.   3                     select  id, length(text)-length(replace(text, chr(10))), text
  102.   4                     from    t1
  103.   5                     )));

  105. 已選擇 12800 行。

  107. 已用時間:  00: 00: 05.16

  109. 執行計劃
  110. ----------------------------------------------------------
  111. Plan hash value: 2991304848

  113. ---------------------------------------------------------------------------------------------------
  114. | Id  | Operation                          | Name         | Rows  | Bytes | Cost (%CPU)| Time     |
  115. ---------------------------------------------------------------------------------------------------
  116. |   0 | SELECT STATEMENT                   |              |  8168 |   271K|    29   (0)| 00:00:01 |
  117. |   1 |  VIEW                              |              |  8168 |   271K|    29   (0)| 00:00:01 |
  118. |   2 |   COLLECTION ITERATOR PICKLER FETCH| F_CARTESIAN2 |  8168 |       |    29   (0)| 00:00:01 |
  119. |   3 |    TABLE ACCESS FULL               | T1           |   186 |   366K|    68   (0)| 00:00:01 |
  120. ---------------------------------------------------------------------------------------------------

  122. Note
  123. -----
  124.    - dynamic statistics used: dynamic sampling (level=2)


  127. 統計信息
  128. ----------------------------------------------------------
  129.         266  recursive calls
  130.           0  db block gets
  131.         529  consistent gets
  132.           0  physical reads
  133.           0  redo size
  134.      236103  bytes sent via SQL*Net to client
  135.        9927  bytes received via SQL*Net from client
  136.         855  SQL*Net roundtrips to/from client
  137.           0  sorts (memory)
  138.           0  sorts (disk)
  139.       12800  rows processed


  142. bill@ORCL> select       id, item_txt
  143.   2  from       table(refcur_pkg.f_cartesian3(cursor(
  144.   3                     select  id, length(text)-length(replace(text, chr(10))), text
  145.   4                     from    t1
  146.   5                     )));

  148. 已選擇 12800 行。

  150. 已用時間:  00: 00: 00.29

  152. 執行計劃
  153. ----------------------------------------------------------
  154. Plan hash value: 2831580648

  156. ---------------------------------------------------------------------------------------------------
  157. | Id  | Operation                          | Name         | Rows  | Bytes | Cost (%CPU)| Time     |
  158. ---------------------------------------------------------------------------------------------------
  159. |   0 | SELECT STATEMENT                   |              |  8168 |   271K|    29   (0)| 00:00:01 |
  160. |   1 |  VIEW                              |              |  8168 |   271K|    29   (0)| 00:00:01 |
  161. |   2 |   COLLECTION ITERATOR PICKLER FETCH| F_CARTESIAN3 |  8168 |       |    29   (0)| 00:00:01 |
  162. |   3 |    TABLE ACCESS FULL               | T1           |   186 |   366K|    68   (0)| 00:00:01 |
  163. ---------------------------------------------------------------------------------------------------

  165. Note
  166. -----
  167.    - dynamic statistics used: dynamic sampling (level=2)


  170. 統計信息
  171. ----------------------------------------------------------
  172.         278  recursive calls
  173.           0  db block gets
  174.         555  consistent gets
  175.           0  physical reads
  176.         124  redo size
  177.      228407  bytes sent via SQL*Net to client
  178.        9927  bytes received via SQL*Net from client
  179.         855  SQL*Net roundtrips to/from client
  180.           0  sorts (memory)
  181.           0  sorts (disk)
  182.       12800  rows processed
複製代碼
整個這些測試，比較，對我震撼是比較大的。用sql來實現笛卡爾然後取不同的數據，似乎是個天經地義適合sql來處理的事情，可惜到最後我都不知道這究竟是不適合sql，還是oracle沒把這個實現好？大家不妨用別的數據庫來測測？
不過，從此以後，oracle裏面，再有這種需求，大家不妨參考這裏plsql的思路來做。

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

SQLServer中CASE語句在ORACLE中的實現

如下：SELECT LogID,UserID,LogTime,Url,Description,(case OperateType when OperateType = 0 then '新增'  when OperateType＝1 the

wzg1031 2020-07-03 14:04:55

execute immediate 的用法

create or replace procedure proc_test(v_item in varchar2) as v_sql varchar2(2000):=''; --執行的sql v_num number(9);

嶶風 2020-06-23 21:30:35

Oracle函數--instr()

  instr() 返回要截取的字符串在源字符串中的位置 語法：  instr(sourceString,destString,startPosition,appearPosition)  參數說明： sourceString:源字符串，

嶶風 2020-06-23 21:30:30

存儲過程使用遊標變量返回結果集（推薦）

轉載自：http://www.2cto.com/database/201301/186608.html 存儲過程使用遊標變量返回結果集   1)登錄SQLPLUS,用戶爲SCOTT,利用該用戶提供的表EMP   www.2ct

编程小强 2020-06-19 20:46:41

【分析函數】使用分析函數LAST_VALUE或11g LAG實現缺失數據填充及其區別

轉載自:http://blog.chinaunix.net/uid-7655508-id-3736949.html  在“使用Partitioned Outer Join實現稠化報表”這篇文章中，講述了實現稠化數據填充的方法。這篇文章和

编程小强 2020-06-19 20:46:41

使用 RATIO_TO_REPORT() 計算百分比

轉載自：http://www.java2s.com/Tutorial/Oracle/0320__Analytical-Functions/UsingtheRATIOTOREPORTFunction.htm RATIO_TO_REPORT

编程小强 2020-06-19 20:46:41

ORACLE 內置函數之 GREATEST 和 LEAST(求多列的最大值,最小值)

轉載自：http://dlblog.iteye.com/blog/1274005 Oracle比較一列的最大值或者最小值，我們會不假思索地用MAX和MIN函數，但是對於比較一行的最大值或最小值呢？是不是日常用的少，很多人都不知道有O

编程小强 2020-06-19 20:46:41

Oracle中的Truncate和Delete語句(與索引的關係)

轉載自:http://www.cnblogs.com/hqbhonker/p/3312028.html 首先講一下，truncate命令：     語法：TRUNCATE  TABLE  table;   表格裏的數據被清空，

编程小强 2020-06-19 20:46:41

關於Long和Varchar2數據的相互轉換在Oracle

轉載自：http://blog.itpub.net/30193/viewspace-364458 前幾天，公司有人因爲一個特別的事情，要把Varchar2轉換成long; 這讓我們費了不少腦精,Oracle的文檔不建議我們用Lon

编程小强 2020-06-19 20:46:41

LNNVL函數使用

轉載自：http://blog.csdn.net/stevendbaguo/article/details/12611189 顯示那些佣金比例（commision）不大於20%或者爲NULL的員工的信息。 CREATE TABLE

编程小强 2020-06-19 20:46:41

oracle 表(table)上最後一次 DML時間、行(row)上最後DML時間

轉載自：http://www.anbob.com/archives/734.html 在這介紹兩個oracle 10G開始提供的一個僞列ORA_ROWSCN,它又分爲兩種模式一種是基於block,這是默認的模式，還有一種是基於row上

编程小强 2020-06-19 20:46:41

淺談oracle中的context（上下文）

轉載自：http://blog.itpub.net/25701553/viewspace-702957 context這個詞見得還是挺多的，尤其是在計算機領域。大部人將它翻譯爲上下文，我也就跟隨大衆吧。比如操作系統中的上下文切換等等。那麼

编程小强 2020-06-19 20:46:41

提高上百萬行數據insert速度的方法

有兩個結構相同的表table1,table2 將table1插入到table2中：   現在採用兩種方法： 1、指定回滾段，回滾段足夠大 set tr

甲骨文 2020-06-14 16:25:48

簡單的樹形查詢--prior放在select中使用

簡單的樹形查詢使用scott用戶下的表：emp想要查出上級主管的姓名(sql1)：select e.empno as "員工編碼", e.ename as "員工姓名", e.mgr as "主管編碼",

嶶風 2020-06-10 18:27:22

Oracle執行計劃的6種方法

 /*   總的結論：   一.獲取執行計劃的6種方法(詳細步驟已經在每個例子的開頭註釋部分說明了）：     1. explain plan for獲取；      2. set autotrace on ；         3

嶶風 2020-06-10 18:27:22