精华内容
下载资源
问答
  • oracle执行where条件执行顺序是从右往左还是从左往右?分区查询大数据条件放最后吗?
  • ORACLEwhere部分条件执行顺序测试

    千次阅读 2017-12-10 18:03:06
    ORACLEwhere部分条件执行顺序测试 实验1:证明oracle SQL的语法分析应该是从右到左的 实验2:证明了oracle SQL条件的执行是从右到左的 ...实验3:证明同一个where子句中条件先后顺序对效率影响不大

    ORACLE中where部分条件执行顺序测试

    实验1:证明oracle SQL的语法分析应该是从右到左的

    测试语句

    --语句1
    Select 'ok' From Dual Where 1 / 0 = 1 And 1 = 2;
    --语句2
    Select 'ok' From Dual Where 1 = 2 And 1 / 0 = 1;
    
    10g环境下测试结果

    如图所示,语句1不会报错,语句2报错
    10g执行除0
    执行计划如下:
    语句1先除0

    语句2后除0

    结论1:10g环境下的实验结果说明oracle SQL的语法分析应该是从右到左的

    11g环境下测试结果

    如图所示,语句1和语句2都没有报错
    11g除0操作

    执行计划如下:
    语句1先除0

    语句2后除0

    从两者的执行计划中可以看出plan hash value值相同,filter的过滤条件也相同,都使用了filter(NULL IS NOT NULL),这是优化器非常聪明的“短路”操作

    结论2:由此可见在11g时oracle数据库对后除0操作做了特殊处理

    实验2:证明了oracle SQL条件的执行是从右到左的

    测试SQL

    drop table temp;
    create table temp( t1 varchar2(10),t2 varchar2(10));
    insert into temp values('zm','abcde');
    insert into temp values('sz','1');
    insert into temp values('sz','2');
    commit;
    --语句1
    select * from temp where to_number(t2)>1 and t1='sz';
    --语句2
    select * from temp where t1='sz' and to_number(t2)>1;
    
    9i环境下测试结果

    网络上有博文指出在9i上执行, 第1条语句执行不会出错,第2条语句会提示“无效的数字”,说明在9i上,SQL条件的执行确实是从右到左的,没有亲自验证。

    10g环境下测试结果

    这里写图片描述

    这里写图片描述

    11g环境下测试结果

    这里写图片描述

    这里写图片描述

    实验3:证明同一个where子句中条件的先后顺序对效率影响不大

    部分博文中提到ORACLE采用自下而上的顺序解析WHERE子句,根据这个原理,表之间的连接必须写在其他WHERE条件之前,
    那些可以过滤掉最大数量记录的条件必须写在WHERE子句的末尾.

    测试语句

    --语句1
    SELECT * 
    FROM scott.EMP E
    WHERE  SAL > 1000
    AND    JOB = 'MANAGER'
    AND    2 < (SELECT COUNT(*) FROM scott.EMP
                         WHERE MGR=E.EMPNO);
    --语句2
    SELECT * 
    FROM scott.EMP E
    WHERE 2 < (SELECT COUNT(*) FROM scott.EMP
                         WHERE MGR=E.EMPNO)
    and SAL > 1000
    AND    JOB = 'MANAGER';
    
    10g环境下测试结果

    两条语句在10g环境下的执行计划如下图

    这里写图片描述

    这里写图片描述

    关于 Recursive Calls可以参考Oracle Recursive Calls说明

    11g环境下测试结果

    两条语句在11g环境下的执行计划如下图
    这里写图片描述

    这里写图片描述

    两者的where条件顺序有差异,但是从执行计划中可以看出都是一致的。
    结论3:11g环境下同一个where子句中条件的先后顺序对效率影响不大

    参考文章链接:
    Oracle中的where部分的各个条件的执行顺序

    Oracle数据库中的Where条件执行顺序是从后往前的?

    展开全文
  • 1、Oracle数据库Where条件执行顺序:由于SQL优化起来比较复杂,并且还会受环境限制,在开发过程中,写SQL必须必须要遵循以下几点的原则: 1.ORACLE采用自下而上的顺序解析WHERE子句,根据这个原理,表之间的连接必须写在...

    1、Oracle数据库Where条件执行顺序:

    由于SQL优化起来比较复杂,并且还会受环境限制,在开发过程中,写SQL必须必须要遵循以下几点的原则:

      1.ORACLE采用自下而上的顺序解析WHERE子句,根据这个原理,表之间的连接必须写在其他WHERE条件之前, 那些可以过滤掉最大数量记录的条件必须写在WHERE子句的末尾.

      例如:

      (低效)

      SELECT … FROM EMP E WHERE SAL > 50000 AND JOB = ‘MANAGER’ AND 25 < (SELECT COUNT(*) FROM EMP WHERE MGR=E.EMPNO);

      (高效)

      SELECT … FROM EMP E WHERE 25 < (SELECT COUNT(*) FROM EMP WHERE MGR=E.EMPNO) AND SAL > 50000 AND JOB = ‘MANAGER’;

      2.SELECT子句中避免使用’*’

      当在SELECT子句中列出所有的COLUMN时,使用动态SQL列引用 ‘*’ 是一个方便的方法.可是,这是一个非常低效的方法. 实际上,ORACLE在解析的过程中, 会将’*’ 依次转换成所有的列名, 这个工作是通过查询数据字典完成的, 这意味着将耗费更多的时间.

      3.使用表的别名(Alias)

      当在SQL语句中连接多个表时, 请使用表的别名并把别名前缀于每个Column上.这样一来,就可以减少解析的时间并减少那些由Column歧义引起的语法错误.

      注:Column歧义指的是由于SQL中不同的表具有相同的Column名,当SQL语句中出现这个Column时,SQL解析器无法判断这个Column的归属。

     

    2、oracle中Where子句的条件顺序对性能的影响:

        经常有人问到oracle中的Where子句的条件书写顺序是否对SQL性能有影响,我的直觉是没有影响,因为如果这个顺序有影响,Oracle应 该早就能够做到自动优化,但一直没有关于这方面的确凿证据。在网上查到的文章,一般认为在RBO优化器模式下无影响(10G开始,缺省为RBO优化器模 式),而在CBO优化器模式下有影响,主要有两种观点:

      a.能使结果最少的条件放在最右边,SQL执行是按从右到左进行结果集的筛选的;

      b.有人试验表明,能使结果最少的条件放在最左边,SQL性能更高。

      查过oracle8到11G的在线文档,关于SQL优化相关章节,没有任何文档说过where子句中的条件对SQL性能有影响,到底哪种观点是 对的,没有一种确切的结论,只好自己来做实验证明。结果表明,SQL条件的执行是从右到左的,但条件的顺序对SQL性能没有影响。

      实验一:证明了SQL的语法分析是从右到左的

      下面的试验在9i和10G都可以得到相同的结果: 第1条语句执行不会出错,第2条语句会提示除数不能为零。

      1.Select 'ok' From Dual Where 1 / 0 = 1 And 1 = 2;

      2.Select 'ok' From Dual Where 1 = 2 And 1 / 0 = 1;

      证明了SQL的语法分析是从右到左的。

      实验二:证明了SQL条件的执行是从右到左的

     


      drop table temp; 
      create table temp( t1 varchar2(10),t2 varchar2(10)); 
      insert into temp values('zm','abcde'); 
      insert into temp values('sz','1'); 
      insert into temp values('sz','2'); 
      commit;

      1. select * from temp where to_number(t2)>1 and t1='sz';

      2. select * from temp where t1='sz' and to_number(t2)>1;

      在9i上执行, 第1条语句执行不会出错,第2条语句会提示“无效的数字”

      在10G上执行,两条语句都不会出错。

      说明:9i上,SQL条件的执行确实是从右到左的,但是10G做了什么调整呢?

      实验三:证明了在10g上SQL条件的执行是从右到左的

    Create Or Replace Function F1(v_In Varchar2) Return Varchar2 Is 
      Begin 
      Dbms_Output.Put_Line('exec F1'); 
      Return v_In; 
      End F1; 
      / 
      Create Or Replace Function F2(v_In Varchar2) Return Varchar2 Is 
      Begin 
      Dbms_Output.Put_Line('exec F2'); 
      Return v_In; 
      End F2; 
      / 
      SQL> set serverout on; 
      SQL> select 1 from dual where f1('1')='1' and f2('1')='1'; 
      1 
      ---------- 
      1 
      exec F2 
      exec F1 
      SQL> select 1 from dual where f2('1')='1' and f1('1')='1'; 
      1 
      ---------- 
      1 
      exec F1 
      exec F2

      结果表明,SQL条件的执行顺序是从右到左的。

      那么,根据这个结果来分析,把能使结果最少的条件放在最右边,是否会减少其它条件执行时所用的记录数量,从而提高性能呢?

      例如:下面的SQL条件,是否应该调整SQL条件的顺序呢?

      Where A.结帐id Is Not Null

      And A.记录状态<>0

      And A.记帐费用=1

      And (Nvl(A.实收金额, 0)<>Nvl(A.结帐金额, 0) Or Nvl(A.结帐金额, 0)=0)

      And A.病人ID=[1] And Instr([2],','||Nvl(A.主页ID,0)||',')>0

      And A.登记时间Between [3] And [4]

      And A.门诊标志<>1

      实际上,从这条SQL语句的执行计划来分析,Oracle首先会找出条件中使用索引或表间连接的条件,以此来过滤数据集,然后对这些结果数据块所涉及的记录逐一检查是否符合所有条件,所以条件顺序对性能几乎没有影响。

    Create Or Replace Function F1(v_In Varchar2) Return Varchar2 Is 
      Begin 
      Dbms_Output.Put_Line('exec F1'); 
      Return v_In; 
      End F1; 
      / 
      Create Or Replace Function F2(v_In Varchar2) Return Varchar2 Is 
      Begin 
      Dbms_Output.Put_Line('exec F2'); 
      Return v_In; 
      End F2; 
      / 
      SQL> set serverout on; 
      SQL> select 1 from dual where f1('1')='1' and f2('1')='1'; 
      1 
      ---------- 
      1 
      exec F2 
      exec F1 
      SQL> select 1 from dual where f2('1')='1' and f1('1')='1'; 
      1 
      ---------- 
      1 
      exec F1 
      exec F2

      结果表明,SQL条件的执行顺序是从右到左的。

      那么,根据这个结果来分析,把能使结果最少的条件放在最右边,是否会减少其它条件执行时所用的记录数量,从而提高性能呢?

      例如:下面的SQL条件,是否应该调整SQL条件的顺序呢?

      Where A.结帐id Is Not Null

      And A.记录状态<>0

      And A.记帐费用=1

      And (Nvl(A.实收金额, 0)<>Nvl(A.结帐金额, 0) Or Nvl(A.结帐金额, 0)=0)

      And A.病人ID=[1] And Instr([2],','||Nvl(A.主页ID,0)||',')>0

      And A.登记时间Between [3] And [4]

      And A.门诊标志<>1

      实际上,从这条SQL语句的执行计划来分析,Oracle首先会找出条件中使用索引或表间连接的条件,以此来过滤数据集,然后对这些结果数据块所涉及的记录逐一检查是否符合所有条件,所以条件顺序对性能几乎没有影响。

    展开全文
  • (1)选择最有效率的表名顺序(只在基于规则的优化器中有效):Oracle的解析器按照从右到左的顺序处理FROM子句中的表名,FROM子句中写在最后的表(基础表 driving table)将被最先处理,在FROM子句中包含多个表的情况下,...

    (1)选择最有效率的表名顺序(只在基于规则的优化器中有效): 

    Oracle的解析器按照从右到左的顺序处理FROM子句中的表名,FROM子句中写在最后的表(基础表 driving table)将被最先处理,在FROM子句中包含多个表的情况下,你必须选择记录条数最少的表作为基础表。如果有3个以上的表连接查询, 那就需要选择交叉表(intersection table)作为基础表, 交叉表是指那个被其他表所引用的表。

    (2)WHERE子句中的连接顺序: 

    Oracle采用自下而上的顺序解析WHERE子句,根据这个原理,表之间的连接必须写在其他WHERE条件之前, 那些可以过滤掉最大数量记录的条件必须写在WHERE子句的末尾。 中.国.站长站

    (3)SELECT子句中避免使用‘*’:

    Oracle在解析的过程中, 会将‘*’依次转换成所有的列名, 这个工作是通过查询数据字典完成的, 这意味着将耗费更多的时间。

    (4)减少访问数据库的次数:

    Oracle在内部执行了许多工作: 解析SQL语句, 估算索引的利用率, 绑定变量 , 读数据块等。

    (5)在SQL*Plus , SQL*Forms和Pro*C中重新设置ARRAYSIZE参数, 可以增加每次数据库访问的检索数据量 ,建议值为200。


    (6)使用DECODE函数来减少处理时间: 

    使用DECODE函数可以避免重复扫描相同记录或重复连接相同的表。 

    (7)整合简单,无关联的数据库访问:


    如果你有几个简单的数据库查询语句,你可以把它们整合到一个查询中(即使它们之间没有关系)。


    (8)删除重复记录: 

    最高效的删除重复记录方法 ( 因为使用了ROWID)例子: 
    DELETE FROM EMP E WHERE E.ROWID > (SELECT MIN(X.ROWID) FROM EMP X WHERE X.EMP_NO = E.EMP_NO);

    (9)用TRUNCATE替代DELETE: 

    当删除表中的记录时,在通常情况下, 回滚段(rollback segments ) 用来存放可以被恢复的信息. 如果你没有COMMIT事务,ORACLE会将数据恢复到删除之前的状态(准确地说是恢复到执行删除命令之前的状况) 而当运用TRUNCATE时, 回滚段不再存放任何可被恢复的信息。当命令运行后,数据不能被恢复.因此很少的资源被调用,执行时间也会很短。(TRUNCATE只在删除全表适 用,TRUNCATE是DDL不是DML)。 Chinaz_com

    (10)尽量多使用COMMIT:

    只要有可能,在程序中尽量多使用COMMIT, 这样程序的性能得到提高,需求也会因为COMMIT所释放的资源而减少,COMMIT所释放的资源:

    a. 回滚段上用于恢复数据的信息。

    b. 被程序语句获得的锁。

    c. redo log buffer 中的空间。 Chinaz@com

    d. Oracle为管理上述3种资源中的内部花费。


    (11)用Where子句替换HAVING子句: 

    避免使用HAVING子句,HAVING 只会在检索出所有记录之后才对结果集进行过滤。这个处理需要排序,总计等操作。如果能通过WHERE子句限制记录的数目,那就能减少这方面的开销。(非 oracle中)on、where、having这三个都可以加条件的子句中,on是最先执行,where次之,having最后,因为on是先把不符合 条件的记录过滤后才进行统计,它就可以减少中间运算要处理的数据,按理说应该速度是最快的,where也应该比having快点的,因为它过滤数据后才进 行sum,在两个表联接时才用on的,所以在一个表的时候,就剩下where跟having比较了。在这单表查询统计的情况下,如果要过滤的条件没有涉及 到要计算字段,那它们的结果是一样的,只是where可以使用rushmore技术,而having就不能,在速度上后者要慢如果要涉及到计算的字段,就 表示在没计算之前,这个字段的值是不确定的,根据上篇写的工作流程,where的作用时间是在计算之前就完成的,而having就是在计算后才起作用的, 所以在这种情况下,两者的结果会不同。在多表联接查询时,on比where更早起作用。系统首先根据各个表之间的联接条件,把多个表合成一个临时表后,再 由where进行过滤,然后再计算,计算完后再由having进行过滤。由此可见,要想过滤条件起到正确的作用,首先要明白这个条件应该在什么时候起作 用,然后再决定放在那里。

    (12)减少对表的查询: 
    在含有子查询的SQL语句中,要特别注意减少对表的查询。例子: Chinaz

    SELECT TAB_NAME FROM TABLES WHERE (TAB_NAME,DB_VER) = ( SELECTTAB_NAME,DB_VER FROM TAB_COLUMNS WHERE VERSION = 604)

    (13)通过内部函数提高SQL效率:

    复杂的SQL往往牺牲了执行效率。能够掌握上面的运用函数解决问题的方法在实际工作中是非常有意义的。 

    (14)使用表的别名(Alias): 
    当在SQL语句中连接多个表时, 请使用表的别名并把别名前缀于每个Column上。这样一来,就可以减少解析的时间并减少那些由Column歧义引起的语法错误。 Chinaz_com

    (15)用EXISTS替代IN、用NOT EXISTS替代NOT IN:


    在许多基于基础表的查询中,为了满足一个条件,往往需要对另一个表进行联接。在这种情况下,使用EXISTS(或NOT EXISTS)通常将提高查询的效率。在子查询中,NOT IN子句将执行一个内部的排序和合并。无论在哪种情况下,NOT IN都是最低效的 (因为它对子查询中的表执行了一个全表遍历)。为了避免使用NOT IN ,我们可以把它改写成外连接(Outer Joins)或NOT EXISTS。


    例子: 
    (高效)SELECT * FROM EMP (基础表) WHERE EMPNO > 0 AND EXISTS (SELECT ‘X' FROM DEPT WHERE DEPT.DEPTNO = EMP.DEPTNO AND LOC = ‘MELB')(低效)SELECT * FROM EMP (基础表) WHERE EMPNO > 0 AND DEPTNO IN(SELECT DEPTNO FROM DEPT WHERE LOC = ‘MELB')

    (16)识别‘低效执行’的SQL语句:

    虽然目前各种关于SQL优化的图形化工具层出不穷,但是写出自己的SQL工具来解决问题始终是一个最好的方法: 

    SELECT EXECUTIONS , DISK_READS, BUFFER_GETS, ROUND((BUFFER_GETS-DISK_READS)/BUFFER_GETS,2) Hit_radio, ROUND(DISK_READS/EXECUTIONS,2) Reads_per_run, SQL_TEXT FROM V$SQLAREA WHERE EXECUTIONS>0 AND BUFFER_GETS > 0 AND (BUFFER_GETS-DISK_READS)/BUFFER_GETS < 0.8 ORDER BY 4 DESC;

    索引是表的一个概念部分,用来提高检索数据的效率,Oracle使用了一个复杂的自平衡B-tree结构。通常,通过索引查询数据比全表扫描要快。当 Oracle找出执行查询和Update语句的最佳路径时, Oracle优化器将使用索引。同样在联结多个表时使用索引也可以提高效率。另一个使用索引的好处是,它提供了主键(primary key)的唯一性验证。那些LONG或LONG RAW数据类型, 你可以索引几乎所有的列。通常, 在大型表中使用索引特别有效. 当然,你也会发现, 在扫描小表时,使用索引同样能提高效率。虽然使用索引能得到查询效率的提高,但是我们也必须注意到它的代价。索引需要空间来存储,也需要定期维护, 每当有记录在表中增减或索引列被修改时, 索引本身也会被修改。这意味着每条记录的INSERT,DELETE , UPDATE将为此多付出4、 5次的磁盘I/O 。因为索引需要额外的存储空间和处理,那些不必要的索引反而会使查询反应时间变慢。定期的重构索引是有必要的:

    ALTER INDEX <INDEXNAME> REBUILD <TABLESPACENAME>

    (18)用EXISTS替换DISTINCT:

    当提交一个包含一对多表信息(比如部门表和雇员表)的查询时,避免在SELECT子句中使用DISTINCT。一般可以考虑用EXIST替换, EXISTS 使查询更为迅速,因为RDBMS核心模块将在子查询的条件一旦满足后,立刻返回结果。例子:

    (低效): SELECT DISTINCT DEPT_NO,DEPT_NAME FROM DEPT D , EMP E WHERE D.DEPT_NO = E.DEPT_NO (高效): SELECT DEPT_NO,DEPT_NAME FROM DEPT D WHERE EXISTS ( SELECT ‘X' FROM EMP E WHERE E.DEPT_NO = D.DEPT_NO);

    (19)SQL语句用大写的;因为Oracle总是先解析SQL语句,把小写的字母转换成大写的再执行。 

    (20)在Java代码中尽量少用连接符“+”连接字符串。

    (21)避免在索引列上使用NOT通常,我们要避免在索引列上使用NOT, NOT会产生在和在索引列上使用函数相同的影响。当Oracle“遇到”NOT,他就会停止使用索引转而执行全表扫描。

    (22)避免在索引列上使用计算。WHERE子句中,如果索引列是函数的一部分。优化器将不使用索引而使用全表扫描。

    低效: SELECT … FROM DEPT WHERE SAL * 12 > 25000; 高效: SELECT … FROM DEPT WHERE SAL > 25000/12;

    (23)用>=替代>:

    高效:SELECT * FROM EMP WHERE DEPTNO >=4 低效: SELECT * FROM EMP WHERE DEPTNO >3

    两者的区别在于,前者DBMS将直接跳到第一个DEPT等于4的记录而后者将首先定位到DEPTNO=3的记录并且向前扫描到第一个DEPT大于3的记 录。

    (24)用UNION替换OR (适用于索引列):

    通常情况下,用UNION替换WHERE子句中的OR将会起到较好的效果。对索引列使用OR将造成全表扫描。注意,以上规则只针对多个索引列有效。如果有 column没有被索引,查询效率可能会因为你没有选择OR而降低。在下面的例子中,LOC_ID 和REGION上都建有索引。

    高效:SELECT LOC_ID 。 LOC_DESC ,REGION FROM LOCATION WHERE LOC_ID = 10 UNION SELECT LOC_ID ,LOC_DESC ,REGION FROM LOCATION WHERE REGION = “MELBOURNE” 

    低效: SELECT LOC_ID ,LOC_DESC ,REGION FROM LOCATION WHERE LOC_ID = 10 OR REGION = “MELBOURNE”

    (25)用IN来替换OR: 

    这是一条简单易记的规则,但是实际的执行效果还须检验,在Oracle8i下,两者的执行路径似乎是相同的: 

    低效:


    SELECT…. FROM LOCATION WHERE LOC_ID = 10 OR LOC_ID = 20 OR LOC_ID = 30


    高效:

    SELECT… FROM LOCATION WHERE LOC_IN IN (10,20,30);

    (26)避免在索引列上使用IS NULL和IS NOT NULL:


    避免在索引中使用任何可以为空的列,Oracle将无法使用该索引。对于单列索引,如果列包含空值,索引中将不存在此记录。对于复合索引,如果每个列都为 空,索引中同样不存在此记录。如果至少有一个列不为空,则记录存在于索引中。举例:如果唯一性索引建立在表的A列和B列上,并且表中存在一条记录的A,B 值为(123,null), Oracle将不接受下一条具有相同A,B值(123,null)的记录(插入)。 然而如果所有的索引列都为空,Oracle将认为整个键值为空而空不等于空。因此你可以插入1000 条具有相同键值的记录,当然它们都是空! 因为空值不存在于索引列中,所以WHERE子句中对索引列进行空值比较将使ORACLE停用该索引。

    低效: (索引失效)

    SELECT … FROM DEPARTMENT WHERE DEPT_CODE IS NOT NULL; 

    高效:(索引有效) 

    SELECT … FROM DEPARTMENT WHERE DEPT_CODE >=0; 站长.站

    (27)总是使用索引的第一个列: 
    如果索引是建立在多个列上,只有在它的第一个列(leading column)被where子句引用时,优化器才会选择使用该索引。这也是一条简单而重要的规则,当仅引用索引的第二个列时,优化器使用了全表扫描而忽略 了索引。 

    (28)用UNION-ALL 替换UNION ( 如果有可能的话):

    当SQL语句需要UNION两个查询结果集合时,这两个结果集合会以UNION-ALL的方式被合并,然后在输出最终结果前进行排序。如果用UNION ALL替代UNION,这样排序就不是必要了。效率就会因此得到提高。需要注意的是,UNION ALL 将重复输出两个结果集合中相同记录。因此各位还是要从业务需求分析使用UNION ALL的可行性。 UNION 将对结果集合排序,这个操作会使用到SORT_AREA_SIZE这块内存。对于这块内存的优化也是相当重要的。下面的SQL可以用来查询排序的消耗量: Www.Chinaz.com

    低效: SELECT ACCT_NUM, BALANCE_AMT FROM DEBIT_TRANSACTIONS WHERE TRAN_DATE = '31-DEC-95' UNION SELECT ACCT_NUM, BALANCE_AMT FROM DEBIT_TRANSACTIONS WHERE TRAN_DATE = '31-DEC-95' 高效: SELECT ACCT_NUM, BALANCE_AMT FROM DEBIT_TRANSACTIONS WHERE TRAN_DATE = '31-DEC-95' UNION ALL SELECT ACCT_NUM, BALANCE_AMT FROM DEBIT_TRANSACTIONS WHERE TRAN_DATE = '31-DEC-95'

    (29)用WHERE替代ORDER BY:

    ORDER BY 子句只在两种严格的条件下使用索引。

    ORDER BY中所有的列必须包含在相同的索引中并保持在索引中的排列顺序。 

    ORDER BY中所有的列必须定义为非空。 

    WHERE子句使用的索引和ORDER BY子句中所使用的索引不能并列。 

    例如: 表DEPT包含以下列: 

    DEPT_CODE PK NOT NULL 

    DEPT_DESC NOT NULL

    DEPT_TYPE NULL 

    低效: (索引不被使用) 

    SELECT DEPT_CODE FROM DEPT ORDER BY DEPT_TYPE

    高效: (使用索引) 

    SELECT DEPT_CODE FROM DEPT WHERE DEPT_TYPE > 0 

    (30)避免改变索引列的类型: 

    当比较不同数据类型的数据时, ORACLE自动对列进行简单的类型转换。 假设 EMPNO是一个数值类型的索引列:SELECT … FROM EMP WHERE EMPNO = ‘123'。 实际上,经过Oracle类型转换, 语句转化为: SELECT … FROM EMP WHERE EMPNO = TO_NUMBER(‘123') 。

    幸运的是,类型转换没有发生在索引列上,索引的用途没有被改变。现在,假设EMP_TYPE是一个字符类型的索引列:SELECT … FROM EMP WHERE EMP_TYPE = 123 。

    这个语句被Oracle转换为: SELECT … FROM EMP WHERETO_NUMBER(EMP_TYPE)=123。因为内部发生的类型转换, 这个索引将不会被用到! 为了避免Oracle对你的SQL进行隐式的类型转换,最好把类型转换用显式表现出来。注意当字符和数值比较时,Oracle会优先转换数值类型到字符类 型。

    (31)需要当心的WHERE子句: 

    某些SELECT 语句中的WHERE子句不使用索引。这里有一些例子:

    (1)‘!=' 将不使用索引。记住, 索引只能告诉你什么存在于表中, 而不能告诉你什么不存在于表中。

    (2)‘||'是字符连接函数。就象其他函数那样, 停用了索引。 

    (3)‘+'是数学函数。就象其他数学函数那样, 停用了索引。 

    (4)相同的索引列不能互相比较,这将会启用全表扫描。 

    (32)a. 如果检索数据量超过30%的表中记录数,使用索引将没有显著的效率提高。 

    b. 在特定情况下,使用索引也许会比全表扫描慢,但这是同一个数量级上的区别。而通常情况下,使用索引比全表扫描要块几倍乃至几千倍!


    (33)避免使用耗费资源的操作:

    带有DISTINCT,UNION,MINUS,INTERSECT,ORDER BY的SQL语句会启动SQL引擎执行耗费资源的排序(SORT)功能。DISTINCT需要一次排序操作,而其他的至少需要执行两次排序。通常,带有 UNION, MINUS , INTERSECT的SQL语句都可以用其他方式重写。如果你的数据库的SORT_AREA_SIZE调配得好。使用UNION , MINUS, INTERSECT也是可以考虑的, 毕竟它们的可读性很强。

    (34)优化GROUP BY:

    提高GROUP BY 语句的效率,可以通过将不需要的记录在GROUP BY 之前过滤掉。下面两个查询返回相同结果但第二个明显就快了许多。


    低效: SELECT JOB , AVG(SAL) FROM EMP GROUP JOB HAVING JOB = ‘PRESIDENT' OR JOB = ‘MANAGER' 高效: SELECT JOB , AVG(SAL) FROM EMP WHERE JOB = ‘PRESIDENT' OR JOB = ‘MANAGER' GROUP JOB

    转载于:https://www.cnblogs.com/zhuyeshen/p/10998315.html

    展开全文
  • mysql中where条件执行顺序 1.ORACLE中where部分条件执行顺序 oracle SQL的语法分析应该是从右到左的 如: -语句1 Select 'ok' From Dual Where 1 / 0 = 1 And 1 = 2; --语句2 Select 'ok' From Dual Where 1 =...

    oracle&mysql中where条件执行顺序

    1.ORACLE中where部分条件执行顺序
    	oracle SQL的语法分析应该是从右到左的
    	如:
    	-语句1
    	Select 'ok' From Dual Where 1 / 0 = 1 And 1 = 2;
    	--语句2
    	Select 'ok' From Dual Where 1 = 2 And 1 / 0 = 1;
    2.mysql where执行顺序
    	where执行顺序是从左往右执行的,在数据量小的时候不用考虑,
    但数据量多的时候要考虑条件的先后顺序,此时应遵守一个原则:
    排除越多的条件放在第一个
    
    注:分区 索引字段这种第一批次可以过滤大量数据的,应当放在第一执行序位
    

    转载地址:
    https://blog.csdn.net/u013600225/article/details/51166688
    https://www.cnblogs.com/shoshana-kong/p/11195647.html

    还有几个网址:
    http://blog.csdn.net/sforiz/article/details/5345359
    要提高SQL查询效率where语句条件的先后次序应如何写

    SQL中的where的条件的执行顺序
    http://bbs.csdn.net/topics/350234598

    展开全文
  • 因在工作中数据库查询数量百万级表中需要多条件查询,但是筛选条件只有一列有索引,查询效率很低,后查阅资料后修改where后执行的条件顺序,瞬间执行查询语句提速至毫秒级。故以此为记。 eg:SELECT 列名 FROM 表名...
  • oracleWhere子句的条件顺序对性能的影响 - Oracle - 网站开发-技术教程-中国素材网 经常有人问到oracle中的Where子句的条件书写顺序是否对SQL性能有影响,我的直觉是没有影响,因为如果这个顺序有影响,...
  • WHERE条件的执行先后顺序(sql)

    千次阅读 2018-10-23 20:02:19
    mysql 从左到右 即过滤最多数据的条件放左边 Oracle 从右到左 即过滤最多数据的条件放右边
  • 由于Oracle解析Where查询条件是自左向左,自下而上进行的。所以,可以过滤越多记录的条件越应该往后面移动。最大限制的Where子句放在句末。 --摘录 -- (低效,执行时间156.3秒) SELECT … FROM EMP E ...
  • 表之间的连接必须写在其他where条件之前 |--2.那些可以过滤掉最大数量记录的条件必须写在where子句的末尾 引发效率问题举例 | |--(低效)|---select … from emp e where | | sal > 50000 | | and job = '...
  • 标题where后面的条件执行先后顺序 在mysql中where后面的条件是从左往右执行的(Oracle从右往左),所以把过滤数据量大的条件放左边先执行。
  • 3.在多表连接时,是表与表先连接起来,再执行对单表的限制条件where条件;还是先执行单表的限制where条件,再进行表连接? 4.多表连接时,如4个表,我自己做了一个实验:4个表连接执行查询[b]vs[/b]2个表查询放入...
  • 在编写SQL时,会建议将选择性高(过滤数据多)的条件放到WHERE条件的前面,这是为了让查询优化器优先考虑这些条件,减少生成最优(或相对最优)的执行计划的时间,但最终的执行计划生成过滤顺序还是决定这些条件的选择...
  • 要提高SQL查询效率where语句条件先后次序应如何写 2010年03月04 阅读数:42441 我们要做到不但会写SQL,还要做到写出性能优良的SQL语句。 (1)选择最有效率的表名顺序(只在基于规则的优化器中有效): Oracle的...
  • 2.在使用left jion时,on和where条件的区别如下: 1、on条件是在生成临时表时使用的条件,它不管on中的条件是否为真,都会返回左边表中的记录。 2、where条件是在临时表生成好后,再对临时表进行过滤的条件。这时...
  • SQL 条件字段(Where 部分)的分析和执行顺序[ 右——>左 ] 实验一:证明了SQL的语法分析是从右到左的 下面的试验在9i和10G都可以得到相同的结果: 第1条语句执行不会出错,第2条语句会提示除数不能为零。 1.Select...
  • Oracle数据库,sql语句,where的执行顺序,是从左到右执行; 例子: 数据库中存储 scarleimp表 |sequence_no|transdate |seller_code| |202012211111|20201126|009| |202012211112|20201125|009| | | | scarle表 |...
  • SQL中on条件与where条件的区别   数据库在通过连接两张或多张表来返回记录时,都会生成一张中间的临时表,然后再将这张临时表返回给用户。  在使用left jion时,on和where条件的区别如下: 1、 on条件是在...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,613
精华内容 2,645
关键字:

oraclewhere条件先后