Oracle数据库数据恢复、性能优化

找回密码
注册
搜索
热搜: 活动 交友 discuz
Oracle数据库数据恢复、性能优化»论坛 › Oracle › Oracle数据库管理 › 使用sql 计算 1到10000的 完数 perfect number
发新帖
clevernby

157

积分

0

好友

14

主题

[RAC性能调优] 使用sql 计算 1到10000的 完数 perfect number

1#
发表于 2013-7-4 13:47:46 | 查看: 4377| 回复: 16
刘大提的问题，一定要捧场~

我的答案是：

  2. WITH natural_number AS
  3. (SELECT ROWNUM AS nn FROM dual CONNECT BY ROWNUM <= 1000)
  4. SELECT nn
  5.       ,SUM(factor) AS sum_factor
  6.   FROM (SELECT t1.nn
  7.               ,t2.nn AS factor
  8.               ,MOD(t1.nn, t2.nn) AS remain
  9.           FROM natural_number t1
  10.               ,natural_number t2
  11.          WHERE t1.nn > t2.nn)
  12. WHERE remain = 0
  13. GROUP BY nn
  14. HAVING nn = SUM (factor)
复制代码
坐等更高级的写法
已有 1 人评分威望 理由
Maclean Liu(刘相兵 + 10 很给力!

总评分: 威望 + 10   查看全部评分

2#
发表于 2013-7-4 13:49:18
值得鼓励!

回复 只看该作者 道具 举报

3#
发表于 2013-7-4 13:58:24
贴砖加瓦

set timing on;
set autotrace on;
with numbers as
(select rownum no from dual connect by level <= 10000)
SELECT X.no as Perfect /*查找完全数,find perfect number*/
  FROM numbers N
CROSS JOIN numbers X
WHERE mod (X.no, N.no) = 0 and X.no > 1 AND N.no < X.no AND N.no > 0
GROUP BY X.no
HAVING SUM (N.no) = X.no;


Elapsed: 00:00:36.08

Execution Plan
----------------------------------------------------------
Plan hash value: 1415001427

-------------------------------------------------------------------------------------------------------------
| Id  | Operation                       | Name                      | Rows  | Bytes | Cost (%CPU)| Time     |
-------------------------------------------------------------------------------------------------------------
|   0 | SELECT STATEMENT                |                           |     1 |    26 |     6   (0)| 00:00:01 |
|   1 |  TEMP TABLE TRANSFORMATION      |                           |       |       |            |          |
|   2 |   LOAD AS SELECT                | SYS_TEMP_0FD9D66AB_1B854C |       |       |            |          |
|   3 |    COUNT                        |                           |       |       |            |          |
|*  4 |     CONNECT BY WITHOUT FILTERING|                           |       |       |            |          |
|   5 |      FAST DUAL                  |                           |     1 |       |     2   (0)| 00:00:01 |
|*  6 |   FILTER                        |                           |       |       |            |          |
|   7 |    HASH GROUP BY                |                           |     1 |    26 |     4   (0)| 00:00:01 |
|   8 |     NESTED LOOPS                |                           |     1 |    26 |     4   (0)| 00:00:01 |
|*  9 |      VIEW                       |                           |     1 |    13 |     2   (0)| 00:00:01 |
|  10 |       TABLE ACCESS FULL         | SYS_TEMP_0FD9D66AB_1B854C |     1 |    13 |     2   (0)| 00:00:01 |
|* 11 |      VIEW                       |                           |     1 |    13 |     2   (0)| 00:00:01 |
|  12 |       TABLE ACCESS FULL         | SYS_TEMP_0FD9D66AB_1B854C |     1 |    13 |     2   (0)| 00:00:01 |
-------------------------------------------------------------------------------------------------------------

Predicate Information (identified by operation id):
---------------------------------------------------

   4 - filter(LEVEL<=10000)
   6 - filter("X"."NO"=SUM("N"."NO"))
   9 - filter("N"."NO">0)
  11 - filter(MOD("X"."NO","N"."NO")=0 AND "X"."NO">1 AND "N"."NO"<"X"."NO")


Statistics
----------------------------------------------------------
          2  recursive calls
         24  db block gets
     180020  consistent gets
         16  physical reads
        624  redo size
        613  bytes sent via SQL*Net to client
        543  bytes received via SQL*Net from client
          2  SQL*Net roundtrips to/from client
          1  sorts (memory)
          0  sorts (disk)
          4  rows processed



36秒  180020 个逻辑读 2个递归调用

回复 只看该作者 道具 举报

4#
发表于 2013-7-4 13:59:04
SQL> set linesize 200 pagesize 2000
SQL> set autotrace on;
set timing on;
WITH natural_number AS
(SELECT ROWNUM AS nn FROM dual CONNECT BY ROWNUM <= 10000)
SELECT nn
      ,SUM(factor) AS sum_factor
  FROM (SELECT t1.nn
              ,t2.nn AS factor
              ,MOD(t1.nn, t2.nn) AS remain
          FROM natural_number t1
              ,natural_number t2
         WHERE t1.nn > t2.nn)
WHERE remain = 0
GROUP BY nn
HAVING nn = SUM (factor);
SQL> SQL>   2    3    4    5    6    7    8    9   10   11   12   13  

        NN SUM_FACTOR
---------- ----------
      8128       8128
         6          6
        28         28
       496        496

Elapsed: 00:00:36.70

Execution Plan
----------------------------------------------------------
Plan hash value: 1415001427

-------------------------------------------------------------------------------------------------------------
| Id  | Operation                       | Name                      | Rows  | Bytes | Cost (%CPU)| Time     |
-------------------------------------------------------------------------------------------------------------
|   0 | SELECT STATEMENT                |                           |     1 |    26 |     6   (0)| 00:00:01 |
|   1 |  TEMP TABLE TRANSFORMATION      |                           |       |       |            |          |
|   2 |   LOAD AS SELECT                | SYS_TEMP_0FD9D66AC_1B854C |       |       |            |          |
|   3 |    COUNT                        |                           |       |       |            |          |
|*  4 |     CONNECT BY WITHOUT FILTERING|                           |       |       |            |          |
|   5 |      FAST DUAL                  |                           |     1 |       |     2   (0)| 00:00:01 |
|*  6 |   FILTER                        |                           |       |       |            |          |
|   7 |    HASH GROUP BY                |                           |     1 |    26 |     4   (0)| 00:00:01 |
|   8 |     NESTED LOOPS                |                           |     1 |    26 |     4   (0)| 00:00:01 |
|   9 |      VIEW                       |                           |     1 |    13 |     2   (0)| 00:00:01 |
|  10 |       TABLE ACCESS FULL         | SYS_TEMP_0FD9D66AC_1B854C |     1 |    13 |     2   (0)| 00:00:01 |
|* 11 |      VIEW                       |                           |     1 |    13 |     2   (0)| 00:00:01 |
|  12 |       TABLE ACCESS FULL         | SYS_TEMP_0FD9D66AC_1B854C |     1 |    13 |     2   (0)| 00:00:01 |
-------------------------------------------------------------------------------------------------------------

Predicate Information (identified by operation id):
---------------------------------------------------

   4 - filter(ROWNUM<=10000)
   6 - filter("T1"."NN"=SUM("T2"."NN"))
  11 - filter(MOD("T1"."NN","T2"."NN")=0 AND "T1"."NN">"T2"."NN")


Statistics
----------------------------------------------------------
          9  recursive calls
         23  db block gets
     180028  consistent gets
         16  physical reads
        624  redo size
        694  bytes sent via SQL*Net to client
        543  bytes received via SQL*Net from client
          2  SQL*Net roundtrips to/from client
          1  sorts (memory)
          0  sorts (disk)
          4  rows processed



180020  个逻辑读 9个递归调用 ， 36秒

回复 只看该作者 道具 举报

5#
发表于 2013-7-4 14:07:38
SQL>
SQL> select * from v$version;

BANNER
--------------------------------------------------------------------------------
Oracle Database 11g Enterprise Edition Release 11.2.0.2.0 - 64bit Production
PL/SQL Release 11.2.0.2.0 - Production
CORE    11.2.0.2.0      Production
TNS for Linux: Version 11.2.0.2.0 - Production
NLSRTL Version 11.2.0.2.0 - Production
SQL> WITH natural_number AS
  2   (SELECT ROWNUM AS nn FROM dual CONNECT BY ROWNUM <= 1000)
  3  SELECT nn
  4        ,SUM(factor) AS sum_factor
  5    FROM (SELECT t1.nn
  6                ,t2.nn AS factor
  7                ,MOD(t1.nn, t2.nn) AS remain
  8            FROM natural_number t1
  9                ,natural_number t2
10           WHERE t1.nn > t2.nn)
11   WHERE remain = 0
12   GROUP BY nn
13  HAVING nn = SUM (factor);

        NN SUM_FACTOR
---------- ----------
         6          6
        28         28
       496        496

Elapsed: 00:00:01.51

Execution Plan
----------------------------------------------------------
Plan hash value: 320126486

--------------------------------------------------------------------------------
-----------------------------

| Id  | Operation                       | Name                      | Rows  | By
tes | Cost (%CPU)| Time     |

--------------------------------------------------------------------------------
-----------------------------

|   0 | SELECT STATEMENT                |                           |     1 |
26 |     7  (15)| 00:00:01 |

|   1 |  TEMP TABLE TRANSFORMATION      |                           |       |
    |            |          |

|   2 |   LOAD AS SELECT                | SYS_TEMP_0FD9D6606_116B29 |       |
    |            |          |

|   3 |    COUNT                        |                           |       |
    |            |          |

|*  4 |     CONNECT BY WITHOUT FILTERING|                           |       |
    |            |          |

|   5 |      FAST DUAL                  |                           |     1 |
    |     2   (0)| 00:00:01 |

|*  6 |   FILTER                        |                           |       |
    |            |          |

|   7 |    HASH GROUP BY                |                           |     1 |
26 |     5  (20)| 00:00:01 |

|   8 |     NESTED LOOPS                |                           |     1 |
26 |     4   (0)| 00:00:01 |

|   9 |      VIEW                       |                           |     1 |
13 |     2   (0)| 00:00:01 |

|  10 |       TABLE ACCESS FULL         | SYS_TEMP_0FD9D6606_116B29 |     1 |
13 |     2   (0)| 00:00:01 |

|* 11 |      VIEW                       |                           |     1 |
13 |     2   (0)| 00:00:01 |

|  12 |       TABLE ACCESS FULL         | SYS_TEMP_0FD9D6606_116B29 |     1 |
13 |     2   (0)| 00:00:01 |

--------------------------------------------------------------------------------
-----------------------------


Predicate Information (identified by operation id):
---------------------------------------------------

   4 - filter(ROWNUM<=1000)
   6 - filter("T1"."NN"=SUM("T2"."NN"))
  11 - filter(MOD("T1"."NN","T2"."NN")=0 AND "T1"."NN">"T2"."NN")

Note
-----
   - automatic DOP: skipped because of IO calibrate statistics are missing


Statistics
----------------------------------------------------------
        128  recursive calls
          9  db block gets
       3094  consistent gets
          2  physical reads
        576  redo size
        665  bytes sent via SQL*Net to client
        523  bytes received via SQL*Net from client
          2  SQL*Net roundtrips to/from client
          8  sorts (memory)
          0  sorts (disk)
          3  rows processed

回复 只看该作者 道具 举报

6#
发表于 2013-7-4 14:27:47
SQL> set timing on
SQL> set autotrace on
SQL> WITH natural_number AS
(SELECT ROWNUM AS nn FROM dual CONNECT BY ROWNUM <= 10000)
SELECT nn
      ,SUM(factor) AS sum_factor
  FROM (SELECT t1.nn
              ,t2.nn AS factor
              ,MOD(t1.nn, t2.nn) AS remain
          FROM natural_number t1
              ,natural_number t2
         WHERE t1.nn > t2.nn)
WHERE remain = 0
GROUP BY nn
HAVING nn = SUM (factor)  2    3    4    5    6    7    8    9   10   11   12   13  
14  /
        NN SUM_FACTOR
---------- ----------
      8128       8128
         6          6
        28         28
       496        496

Elapsed: 00:00:54.26

Execution Plan
----------------------------------------------------------
Plan hash value: 1415001427

---------------------------------------------------------------------------------------------------------------
| Id  | Operation                       | Name                        | Rows  | Bytes | Cost (%CPU)| Time     |
---------------------------------------------------------------------------------------------------------------
|   0 | SELECT STATEMENT                |                             |     1 |    26 |     7  (15)| 00:00:01 |
|   1 |  TEMP TABLE TRANSFORMATION      |                             |       |       |            |          |
|   2 |   LOAD AS SELECT                | SYS_TEMP_0FD9D6761_52DB0D90 |       |       |            |          |
|   3 |    COUNT                        |                             |       |       |            |          |
|*  4 |     CONNECT BY WITHOUT FILTERING|                             |       |       |            |          |
|   5 |      FAST DUAL                  |                             |     1 |       |     2   (0)| 00:00:01 |
|*  6 |   FILTER                        |                             |       |       |            |          |
|   7 |    HASH GROUP BY                |                             |     1 |    26 |     5  (20)| 00:00:01 |
|   8 |     NESTED LOOPS                |                             |     1 |    26 |     4   (0)| 00:00:01 |
|   9 |      VIEW                       |                             |     1 |    13 |     2   (0)| 00:00:01 |
|  10 |       TABLE ACCESS FULL         | SYS_TEMP_0FD9D6761_52DB0D90 |     1 |    13 |     2   (0)| 00:00:01 |
|* 11 |      VIEW                       |                             |     1 |    13 |     2   (0)| 00:00:01 |
|  12 |       TABLE ACCESS FULL         | SYS_TEMP_0FD9D6761_52DB0D90 |     1 |    13 |     2   (0)| 00:00:01 |
---------------------------------------------------------------------------------------------------------------

Predicate Information (identified by operation id):
---------------------------------------------------

   4 - filter(ROWNUM<=10000)
   6 - filter("T1"."NN"=SUM("T2"."NN"))
  11 - filter(MOD("T1"."NN","T2"."NN")=0 AND "T1"."NN">"T2"."NN")

Note
-----
   - 'PLAN_TABLE' is old version


Statistics
----------------------------------------------------------
          2  recursive calls
         23  db block gets
     170019  consistent gets
         16  physical reads
        532  redo size
        678  bytes sent via SQL*Net to client
        519  bytes received via SQL*Net from client
          2  SQL*Net roundtrips to/from client
          1  sorts (memory)
          0  sorts (disk)
          4  rows processed



SQL> WITH natural_number AS
(SELECT /*+parallel(dual 4)*/ROWNUM AS nn FROM dual CONNECT BY ROWNUM <= 10000)
SELECT nn
      ,SUM(factor) AS sum_factor
  FROM (SELECT/*+parallel(t1 4) parallel(t2 4)*/ t1.nn
              ,t2.nn AS factor
              ,MOD(t1.nn, t2.nn) AS remain
          FROM natural_number t1
              ,natural_number t2
         WHERE t1.nn > t2.nn)
WHERE remain = 0
GROUP BY nn
HAVING nn = SUM (factor)
  2    3    4    5    6    7    8    9   10   11   12   13   14  
SQL> /

        NN SUM_FACTOR
---------- ----------
      8128       8128
         6          6
        28         28
       496        496

Elapsed: 00:00:30.17

Execution Plan
----------------------------------------------------------
Plan hash value: 505721961

--------------------------------------------------------------------------------------------------------------------------------------------
| Id  | Operation                       | Name                        | Rows  | Bytes | Cost (%CPU)| Time     |    TQ  |IN-OUT| PQ Distrib |
--------------------------------------------------------------------------------------------------------------------------------------------
|   0 | SELECT STATEMENT                |                             |     1 |    26 |     5   (0)| 00:00:01 |        |      |            |
|   1 |  TEMP TABLE TRANSFORMATION      |                             |       |       |            |          |        |      |            |
|   2 |   LOAD AS SELECT                | SYS_TEMP_0FD9D6765_52DB0D90 |       |       |            |          |        |      |            |
|   3 |    COUNT                        |                             |       |       |            |          |        |      |            |
|*  4 |     CONNECT BY WITHOUT FILTERING|                             |       |       |            |          |        |      |            |
|   5 |      FAST DUAL                  |                             |     1 |       |     2   (0)| 00:00:01 |        |      |            |
|   6 |   PX COORDINATOR                |                             |       |       |            |          |        |      |            |
|   7 |    PX SEND QC (RANDOM)          | :TQ10002                    |     1 |    26 |     3   (0)| 00:00:01 |  Q1,02 | P->S | QC (RAND)  |
|*  8 |     FILTER                      |                             |       |       |            |          |  Q1,02 | PCWC |            |
|   9 |      HASH GROUP BY              |                             |     1 |    26 |     3   (0)| 00:00:01 |  Q1,02 | PCWP |            |
|  10 |       PX RECEIVE                |                             |     1 |    26 |     3   (0)| 00:00:01 |  Q1,02 | PCWP |            |
|  11 |        PX SEND HASH             | :TQ10001                    |     1 |    26 |     3   (0)| 00:00:01 |  Q1,01 | P->P | HASH       |
|  12 |         HASH GROUP BY           |                             |     1 |    26 |     3   (0)| 00:00:01 |  Q1,01 | PCWP |            |
|  13 |          NESTED LOOPS           |                             |     1 |    26 |     3   (0)| 00:00:01 |  Q1,01 | PCWP |            |
|  14 |           PX RECEIVE            |                             |       |       |            |          |  Q1,01 | PCWP |            |
|  15 |            PX SEND BROADCAST    | :TQ10000                    |       |       |            |          |  Q1,00 | P->P | BROADCAST  |
|  16 |             VIEW                |                             |     1 |    13 |     2   (0)| 00:00:01 |  Q1,00 | PCWP |            |
|  17 |              PX BLOCK ITERATOR  |                             |     1 |    13 |     2   (0)| 00:00:01 |  Q1,00 | PCWC |            |
|  18 |               TABLE ACCESS FULL | SYS_TEMP_0FD9D6765_52DB0D90 |     1 |    13 |     2   (0)| 00:00:01 |  Q1,00 | PCWP |            |
|* 19 |           VIEW                  |                             |     1 |    13 |     2   (0)| 00:00:01 |  Q1,01 | PCWP |            |
|  20 |            PX BLOCK ITERATOR    |                             |     1 |    13 |     2   (0)| 00:00:01 |  Q1,01 | PCWC |            |
|  21 |             TABLE ACCESS FULL   | SYS_TEMP_0FD9D6765_52DB0D90 |     1 |    13 |     2   (0)| 00:00:01 |  Q1,01 | PCWP |            |
--------------------------------------------------------------------------------------------------------------------------------------------

Predicate Information (identified by operation id):
---------------------------------------------------

   4 - filter(ROWNUM<=10000)
   8 - filter("T1"."NN"=SUM(SYS_OP_CSR(SYS_OP_MSR(SUM("T2"."NN")),0)))
  19 - filter(MOD("T1"."NN","T2"."NN")=0 AND "T1"."NN">"T2"."NN")

Note
-----
   - 'PLAN_TABLE' is old version


Statistics
----------------------------------------------------------
         56  recursive calls
         23  db block gets
     320071  consistent gets
         17  physical reads
        720  redo size
        678  bytes sent via SQL*Net to client
        519  bytes received via SQL*Net from client
          2  SQL*Net roundtrips to/from client
          1  sorts (memory)
          0  sorts (disk)
          4  rows processed

SQL>
个人觉得这个运算是非常消耗cpu操作的，因此通过添加并行的提示能有所优化，通过实验，发现采用4个并行度后，由原来的54秒优化30秒。

回复 只看该作者 道具 举报

7#
发表于 2013-7-4 14:47:02
本帖最后由 hotdog04 于 2013-7-4 14:50 编辑

plsql不算吧，不过加上这么多跳出条件，效率要高很多：

declare
a int;
b int;
c int;
j int;
begin
for  i in 6..10000
loop
a := 1;b := i;
j :=2;
while j < b-1
loop
   
  if mod(i,j)=0 then
   a := a + j + i/j;
   b :=i/j;
  end if;
  j := j+1;
end loop;
if a = i then
dbms_output.put_line(i);
end if;
end loop;
end;
/


6
28
496
8128

PL/SQL procedure successfully completed.

Elapsed: 00:00:07.31

回复 只看该作者 道具 举报

8#
发表于 2013-7-4 14:50:47
SQL> exec perfstat.perfect_num(10000);
8128
496
28
6

PL/SQL procedure successfully completed.

Elapsed: 00:00:19.00

回复 只看该作者 道具 举报

9#
发表于 2013-7-4 14:52:28
貌似只能用SQL  不能PL/SQL 吧 否则就成结构化编程了

回复 只看该作者 道具 举报

10#
发表于 2013-7-4 14:52:52
对比该主机上用with temp的方法运行需要1分钟，plsql的效率明显高了
说明构造临时表以及对临时表的处理造成了较多的额外消耗，还是直接的运算程序效率高

回复 只看该作者 道具 举报

11#
发表于 2013-7-4 14:59:47
继续优化：

declare
a int;

begin
for  i in 6..10000
loop
a := 1;
for  j in 2 .. ceil(sqrt(i))-1
loop
   
  if mod(i,j)=0 then
   a := a + j + i/j;
  end if;
end loop;
if a = i then
dbms_output.put_line(i);
end if;
end loop;
end;

回复 只看该作者 道具 举报

12#
发表于 2013-7-4 15:00:37
6
28
496
8128

PL/SQL procedure successfully completed.

Elapsed: 00:00:00.52

回复 只看该作者 道具 举报

13#
发表于 2013-7-4 15:33:57
with t as
(select rownum no from dual connect by level <= 10000),
t22 as
(select rownum no from dual connect by level <= 100),
a as
(select t1.no no1, t2.no + t1.no / t2.no no3
    from t t1, t22 t2
   where mod(t1.no, t2.no) = 0
     and t1.no >= 6
     and ceil(sqrt(t1.no)) - 1 >= t2.no
     and t2.no > 1)
select no1 from a group by no1 having no1 = sum (no3) + 1；

2S以内

回复 只看该作者 道具 举报

14#
发表于 2013-7-4 16:00:36
模仿一下
SELECT b.rn as "完数"
FROM (select rownum rn from dual connect by rownum<=100) a
CROSS JOIN (select rownum　rn from dual connect by rownum<=10000) b
WHERE mod(b.rn, a.rn) = 0
and a.rn <= sqrt(b.rn)
and b.rn > 1
AND a.rn < b.rn
GROUP BY b.rn
HAVING SUM(a.rn) + sum(decode(b.rn/a.rn,1,0,b.rn/a.rn))= 2*b.rn;

回复 只看该作者 道具 举报

15#
发表于 2013-7-4 16:51:42
SQL> exec perfstat.perfect_num_4(10000);
6
28
496
8128

PL/SQL procedure successfully completed.

Elapsed: 00:00:00.10

SQL> exec perfstat.perfect_num_4(100000000);
6
28
496
8128
33550336

PL/SQL procedure successfully completed.

Elapsed: 00:30:46.29

回复 只看该作者 道具 举报

16#
发表于 2013-7-4 17:00:02
算法如下:create or replace function perfstat.perfect_num_2(p_num number)
  return number as
  i   number;
  j   number;
  cnt number;
  n   number;
begin
  n   := p_num;
  i   := 0;
  cnt := 0;
  j   := n;
  while (i != 1) loop
    i := trunc(n / 2);
    if (mod(n, 2) != 0) then
      i := i + 1;
      end if;
      if (mod(j, i) != 0) then
        return 0;
        end if;
      if (mod(i, 2) != 0 and i > 1) then
        cnt := cnt + 1;
      end if;
  n := i;
end loop;
if (cnt > 0) then return 1; else return 0;
end if;
end;

create or replace function perfstat.perfect_num_3(p_num number)
  return number as
  j     number;
  i     number;
  sum_i number;
begin
  sum_i := 0;
  j     := p_num;
  for i in 1 .. j-1 loop
    if (mod(j, i) = 0) then
      sum_i := sum_i + i;
    end if;
  end loop;
  /*dbms_output.put_line(sum_i);
  dbms_output.put_line(j);*/
  if (sum_i = j) then
    return 1;
  else
    return 0;
  end if;
end;


create or replace procedure perfstat.perfect_num_4(p_num number) as
  j number;
  --k number;
begin
  j := p_num;
  for i in 1 .. j loop
    --select perfstat.perfect_num_2(i) into k from dual;
    if (perfstat.perfect_num_2(i) = 1 and perfstat.perfect_num_3(i) = 1) then
      dbms_output.put_line(i);
    end if;
  end loop;
end;

回复 只看该作者 道具 举报

17#
发表于 2013-7-5 09:33:01
雪影舞剑 发表于 2013-7-4 17:00
算法如下:create or replace function perfstat.perfect_num_2(p_num number)
  return number as
  i   nu ...

我觉得你有点偏离题目设计的原本初衷了。
使用PLSQL、C、JAVA这样的结构化编程语言，其实现业务的思路往往是one by one，事情一件一件的做，就好比处理完数也是一个一个自然数的判断。
使用SQL实现业务和结构化编程语言是完全不同的，他处理的是数据集，是一批一批的处理。
刘大设计这个命题的初衷并不是找一个最优的算法来实现找完数的业务，这也明细不是SQL的优势所在，而是考察大家以SQL的思路来实现业务的能力。
目前的SQL方案中最大的缺点就是自连接而且还是笛卡尔积，这个过程大大的影响了性能。如果能将其改进，消除自连接，比如使用行间计算（我瞎说一个的哦~），那么通过这个解答的过程，SQL语句的书写能力就得到了提升。提升SQL的书写能力才是这个命题的价值。

点评 回复 只看该作者 道具 举报

雪影舞剑 发表于 2013-7-5 10:29
其实我还试图把这个plsql改写成sql，不过很困难
雪影舞剑 发表于 2013-7-5 10:28
思考问题的角度不同而已，我觉得不拘泥于别人的框架，解决问题即可。同时思考了sql方案为什么这么慢，他需要构造临时表，比直接的程序运算慢。
Ling.QIu 发表于 2013-7-5 09:47
赞成 最后完全变成数学意义上的优化了
返回列表
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

QQ|手机版|Archiver|Oracle数据库数据恢复、性能优化

GMT+8, 2024-11-16 21:50 , Processed in 0.059188 second(s), 21 queries .

Powered by Discuz! X2.5

© 2001-2012 Comsenz Inc.

回顶部
TEL/電話+86 13764045638
Email service@parnassusdata.com
QQ 47079569