2

我的最后一个问题让我思考。

1)

SELECT COUNT(*) INTO count FROM foo WHERE bar = 123;
IF count > 0 THEN
    SELECT a INTO var FROM foo WHERE bar = 123;
    -- do stuff
ELSE
    -- do other stuff
END IF;

2)

BEGIN
    SELECT a INTO var FROM foo where bar = 123;
    -- do stuff
EXCEPTION
    WHEN no_data_found THEN
        --do other stuff
END ;

我假设 2 号更快，因为它需要少一趟数据库。

有没有我不考虑的情况下 1 会更好？

编辑：我打算让这个问题再挂几天，在回答之前收集更多关于答案的投票。

4

4 回答 4

5

如果您使用问题中的确切查询，那么第一个变体当然会更慢，因为它必须计算表中满足条件的所有记录。

它必须写成

SELECT COUNT(*) INTO row_count FROM foo WHERE bar = 123 and rownum = 1;

或者

select 1 into row_count from dual where exists (select 1 from foo where bar = 123);

因为检查记录是否足以满足您的目的。

当然，这两种变体都不能保证其他人不会foo在两个语句之间更改某些内容，但如果此检查是更复杂场景的一部分，这不是问题。想想当有人在执行一些引用选定值的操作时foo.a选择它的值后更改值的情况。因此，在复杂的场景中，最好在应用程序逻辑级别处理此类并发问题。 要执行原子操作，最好使用单个 SQL 语句。varvar

上述任何变体都需要在 SQL 和 PL/SQL 之间进行 2 次上下文切换以及 2 次查询，因此在表中找到行的情况下，执行速度比下面描述的任何变体要慢。

还有另一种变体可以无一例外地检查行的存在：

select max(a), count(1) into var, row_count 
from foo 
where bar = 123 and rownum < 3;

如果 row_count = 1 则只有一行满足条件。

有时只检查是否存在就足够了，因为唯一的约束foo保证. 例如是主键。 在这种情况下，可以简化查询：barfoobar

select max(a) into var from foo where bar = 123;
if(var is not null) then 
  ...
end if;

或使用游标处理值：

for cValueA in ( 
  select a from foo where bar = 123
) loop
  ...  
end loop;

下一个变体来自链接，由@user272735 在他的回答中提供：

select 
  (select a from foo where bar = 123)
  into var 
from dual;

根据我的经验，在大多数情况下，任何没有异常块的变体都比具有异常的变体更快，但是如果此类块的执行次数较低，那么最好使用带有异常处理no_data_found和too_many_rows异常的异常块来提高代码可读性。

选择使用异常或不使用异常的正确点是问一个问题“这种情况对于应用程序来说是否正常？”。如果没有找到行并且这是可以处理的预期情况（例如添加新行或从另一个地方获取数据等），最好避免异常。如果发生意外并且无法修复情况，则捕获异常以自定义错误消息，将其写入事件日志并重新抛出，或者根本不捕获它。

要比较性能，只需在您的系统上创建一个简单的测试用例，这两种变体都被多次调用并进行比较。
再说了，在 90% 的应用程序中，这个问题更多的是理论而不是实际，因为还有很多其他的性能问题来源必须首先考虑。

更新

我在 SQLFiddle 站点的此页面上复制了示例，并进行了一些更正（链接）。
结果证明，选择 from 的变体dual表现最好：当大多数查询成功时有一点开销，而当缺失行数增加时，性能下降最低。
令人惊讶的是，如果所有查询都失败了，count() 和两个查询的变体显示出最好的结果。

| FNAME | LOOP_COUNT | ALL_FAILED | ALL_SUCCEED | variant name |
----------------------------------------------------------------
|    f1 |       2000 |       2.09 |        0.28 |  exception   |
|    f2 |       2000 |       0.31 |        0.38 |  cursor      |
|    f3 |       2000 |       0.26 |        0.27 |  max()       |
|    f4 |       2000 |       0.23 |        0.28 |  dual        |
|    f5 |       2000 |       0.22 |        0.58 |  count()     |

-- FNAME        - tested function name 
-- LOOP_COUNT   - number of loops in one test run
-- ALL_FAILED   - time in seconds if all tested rows missed from table
-- ALL_SUCCEED  - time in seconds if all tested rows found in table
-- variant name - short name of tested variant

下面是测试环境和测试脚本的设置代码。

create table t_test(a, b)
as
select level,level from dual connect by level<=1e5
/
insert into t_test(a, b) select null, level from dual connect by level < 100
/

create unique index x_text on t_test(a)
/

create table timings(
  fname varchar2(10), 
  loop_count number, 
  exec_time number
)
/

create table params(pstart number, pend number)
/
-- loop bounds
insert into params(pstart, pend) values(1, 2000)
/

-- f1 - 异常处理

create or replace function f1(p in number) return number
as
  res number;
begin
  select b into res
  from t_test t
  where t.a=p and rownum = 1;
  return res;
exception when no_data_found then
  return null;
end;
/

-- f2 - 光标循环

create or replace function f2(p in number) return number
as
  res number;
begin
  for rec in (select b from t_test t where t.a=p and rownum = 1) loop
    res:=rec.b;
  end loop;
  return res;
end;
/

-- f3 - 最大值（）

create or replace function f3(p in number) return number
as
  res number;
begin
  select max(b) into res
  from t_test t
  where t.a=p and rownum = 1;
  return res;
end;
/

-- f4 - 在 select from dual 中选择为字段

create or replace function f4(p in number) return number
as
  res number;
begin
  select
    (select b from t_test t where t.a=p and rownum = 1)
    into res
  from dual;
  return res;
end;
/

-- f5 - 检查 count() 然后获取值

create or replace function f5(p in number) return number
as
  res number;
  cnt number;
begin
  select count(*) into cnt
  from t_test t where t.a=p and rownum = 1;

  if(cnt = 1) then
    select b into res from t_test t where t.a=p;
  end if;

  return res;
end;
/

测试脚本：

declare
  v       integer;
  v_start integer;
  v_end   integer;

  vStartTime number;

begin
  select pstart, pend into v_start, v_end from params;

  vStartTime := dbms_utility.get_cpu_time;

  for i in v_start .. v_end loop
    v:=f1(i);
  end loop;

  insert into timings(fname, loop_count, exec_time) 
    values ('f1', v_end-v_start+1, (dbms_utility.get_cpu_time - vStartTime)/100) ;
end;
/

declare
  v       integer;
  v_start integer;
  v_end   integer;

  vStartTime number;

begin
  select pstart, pend into v_start, v_end from params;

  vStartTime := dbms_utility.get_cpu_time;

  for i in v_start .. v_end loop
    v:=f2(i);
  end loop;

  insert into timings(fname, loop_count, exec_time) 
    values ('f2', v_end-v_start+1, (dbms_utility.get_cpu_time - vStartTime)/100) ;
end;
/

declare
  v       integer;
  v_start integer;
  v_end   integer;

  vStartTime number;

begin
  select pstart, pend into v_start, v_end from params;

  vStartTime := dbms_utility.get_cpu_time;

  for i in v_start .. v_end loop
    v:=f3(i);
  end loop;

  insert into timings(fname, loop_count, exec_time) 
    values ('f3', v_end-v_start+1, (dbms_utility.get_cpu_time - vStartTime)/100) ;
end;
/

declare
  v       integer;
  v_start integer;
  v_end   integer;

  vStartTime number;

begin
  select pstart, pend into v_start, v_end from params;

  vStartTime := dbms_utility.get_cpu_time;

  for i in v_start .. v_end loop
    v:=f4(i);
  end loop;

  insert into timings(fname, loop_count, exec_time) 
    values ('f4', v_end-v_start+1, (dbms_utility.get_cpu_time - vStartTime)/100) ;
end;
/

declare
  v       integer;
  v_start integer;
  v_end   integer;

  vStartTime number;

begin
  select pstart, pend into v_start, v_end from params;
  --v_end := v_start + trunc((v_end-v_start)*2/3);

  vStartTime := dbms_utility.get_cpu_time;

  for i in v_start .. v_end loop
    v:=f5(i);
  end loop;

  insert into timings(fname, loop_count, exec_time) 
    values ('f5', v_end-v_start+1, (dbms_utility.get_cpu_time - vStartTime)/100) ;
end;
/

select * from timings order by fname
/
于 2013-08-08T08:27:59.690 回答
4

首先请参阅：Oracle PL/SQL - NO_DATA_FOUND 异常对存储过程性能有害吗？这与您的问题基本相同。之后请参阅关于异常处理的性能。

在这两种情况下，您还应该准备好处理too_many_rows异常，除非您的数据库模式强制bar.

这是 PL/SQL，因此您一直在进行数据库之旅——相反，您应该害怕/意识到PL/SQL-SQL 上下文切换。另请参阅汤姆所说的：

但是不要害怕从 PLSQL 调用 SQL——这是 PLSQL 最擅长的。

首先，您不应该担心程序的性能，而应该担心程序的正确性。在这方面，我投票支持方案#2。

于 2013-08-08T06:18:29.197 回答
3

我不确定更快，但我会说（2）显然更优越，因为您没有考虑有人DELETE FROM foo where bar='123'在您的（1）中的陈述之间提出问题的情况。

于 2013-08-08T00:15:28.543 回答
0

这种情况我通常是这样做的：

DECALRE
   CURSOR cur IS
   SELECT a FROM foo where bar = 123;
BEGIN
   OPEN cur;
   FETCH cur INTO var;
   IF cur%FOUND THEN
      -- do stuff, maybe a LOOP if required
   ELSE
      --do other stuff
   END;
END;

这有一些好处：

您只从数据库中读取一条记录，其余的则跳过。如果您只需要知道行数是否> 1，应该是最快的方法。

您不会使用“异常”处理程序处理“正常”情况，有些人认为这是“更漂亮”的编码。

于 2014-01-09T19:21:58.080 回答