从五个SQL看with as使用

 

SQL语句是关系型数据库最直接也是最普遍的数据访问、操作方式。应该说，RDBMS的成功因素之中，SQL语言标准的推广有不可磨灭的功劳。Oracle、SQL Server和DB2等主流数据库都是在标准SQL的基础上，加以个性化拓展，实现高效的数据库应用。

with as是Oracle SQL语系里面经常使用到的一种语句结构。特别是在一些数据仓库挖掘系统中，SQL语句结构和嵌套结构是很复杂的。with as可以帮助我们简化语句结构，提高语句可读性，另外还可以提升语句执行计划控制性。下面我们通过五个SQL语句，分析其执行计划看with as特性。

 

1、环境介绍

 

我们选择Oracle 10gR2进行实验，实验schema为scott。

 

SQL> select * from v$version;

 

BANNER

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

Oracle Database 10g Release 10.2.0.4.0 - 64bit Production

PL/SQL Release 10.2.0.4.0 - Production

CORE 10.2.0.4.0 Production

 

SQL> select table_name from user_tables;

 

TABLE_NAME

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

DEPT

EMP

BONUS

SALGRADE

 

从语法上看，with as就是将SQL语句中单独的子查询语句提取出来，作为一个单独的命名进行组织。在原来的语句中，就可以使用新的别名来替代。

 

SQL> select count(*)

  2  from (select emp.empno empno, dept.dname from emp, dept where emp.deptno=dept.deptno);

 

  COUNT(*)

----------

        14

 

SQL> with a as (select emp.empno empno, dept.dname from emp, dept where emp.deptno=dept.deptno)

  2  select count(*)

  3  from a;

 

  COUNT(*)

----------

        14

 

2、语句分析

 

在很多文档中，都介绍了with as的用途中有一条是数据临时表化。当我们在一个SQL中包括子查询的时候，Oracle可能不会按照“子查询=》主查询”的顺序执行语句的。SQL Transformation过程中有一个子查询展开（subquery unnested）。一般的子查询都会被展开，作为一系列的join动作出现在执行计划中。with as所谓的数据临时表化，就是支持将subquery先进行执行，形成内存中的临时表，再进行后续操作。

下面是我们第一个SQL语句，是一个子查询与一个数据表的连接。

 

SQL> explain plan for with a as (select emp.empno, emp.ename, dept.loc, emp.job from emp, dept where emp.deptno=dept.deptno)

  2   select *

  3   from a m, dept n

  4   where m.loc=n.loc;

 

Explained

 

SQL> select * from table(dbms_xplan.display);

 

PLAN_TABLE_OUTPUT

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

Plan hash value: 3732937302

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

| Id  | Operation                     | Name    | Rows  | Bytes | Cost (%CPU)| T

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

|   0 | SELECT STATEMENT              |         |    14 |   728 |    10  (20)| 0

|*  1 |  HASH JOIN                    |         |    14 |   728 |    10  (20)| 0

|   2 |   MERGE JOIN                  |         |    14 |   448 |     6  (17)| 0

|   3 |    TABLE ACCESS BY INDEX ROWID| DEPT    |     4 |    44 |     2   (0)| 0

|   4 |     INDEX FULL SCAN           | PK_DEPT |     4 |       |     1   (0)| 0

|*  5 |    SORT JOIN                  |         |    14 |   294 |     4  (25)| 0

|   6 |     TABLE ACCESS FULL         | EMP     |    14 |   294 |     3   (0)| 0

|   7 |   TABLE ACCESS FULL           | DEPT    |     4 |    80 |     3   (0)| 0

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

Predicate Information (identified by operation id):

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

   1 - access("DEPT"."LOC"="N"."LOC")

   5 - access("EMP"."DEPTNO"="DEPT"."DEPTNO")

       filter("EMP"."DEPTNO"="DEPT"."DEPTNO")

 

21 rows selected

 

上面SQL中，将子查询整理在with as中，以a的别名出现在系统中。在主查询里面，a与dept进行连接。从执行计划看，虽然有用with as组织，Oracle优化器CBO还是将子查询展开了，作为一系列的join操作。由此：在单次使用with as的情况下，临时表预执行动作是不会进行的。

下面语句，我们同样抽取a，主查询中两次使用a查询结果。

 

SQL> explain plan for with a as (select emp.empno, emp.ename, dept.loc, emp.job from emp, dept where emp.deptno=dept.deptno)

  2   select *

  3   from a m, a n

  4   where m.loc=n.loc;

 

Explained

 

SQL> select * from table(dbms_xplan.display);

 

PLAN_TABLE_OUTPUT

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

Plan hash value: 202182242

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

| Id  | Operation                      | Name                        | Rows  | B

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

|   0 | SELECT STATEMENT               |                             |    49 |

|   1 |  TEMP TABLE TRANSFORMATION     |                             |       |

|   2 |   LOAD AS SELECT               |                             |       |

|   3 |    MERGE JOIN                  |                             |    14 |

|   4 |     TABLE ACCESS BY INDEX ROWID| DEPT                        |     4 |

|   5 |      INDEX FULL SCAN           | PK_DEPT                     |     4 |

|*  6 |     SORT JOIN                  |                             |    14 |

|   7 |      TABLE ACCESS FULL         | EMP                         |    14 |

|*  8 |   HASH JOIN                    |                             |    49 |

|   9 |    VIEW                        |                             |    14 |

|  10 |     TABLE ACCESS FULL          | SYS_TEMP_0FD9D6605_207360D8 |    14 |

|  11 |    VIEW                        |                             |    14 |

|  12 |     TABLE ACCESS FULL          | SYS_TEMP_0FD9D6605_207360D8 |    14 |

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

Predicate Information (identified by operation id):

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

   6 - access("EMP"."DEPTNO"="DEPT"."DEPTNO")

       filter("EMP"."DEPTNO"="DEPT"."DEPTNO")

   8 - access("M"."LOC"="N"."LOC")

 

26 rows selected

 

执行计划出现了变化。最典型的是在之前，使用Temp Table Transformation，将子查询进行预加载，形成内存中的SYS_TEMP_0FD9D6605_207360D8临时表。之后，对这个临时表进行join连接操作。这也就是我们经常看到的对于with as预加载的现象。对比之前的实验，我们可以知道：只有在主查询中超过一次使用with as中的子查询结构，Oracle才会“自动”的进行临时表预加载。

这样的处理也是有道理的。子查询和查询嵌套主要是便于可读性提升上，绝大多数的子查询和嵌套，都可以通过一系列的连接来完成。而数据库系统是擅长连接操作的。所以，从CBO角度看，大多数子查询被打开，构成系列的连接动作。

此外，子查询单独执行还存在临时空间占用的问题。如果进行子查询单独执行，临时结果的缓存要占用额外的空间，成本消耗相对较高。

但是如果在主查询中多次使用with as确定的别名，情况就不一样了。缓存一部分数据，要比重新执行一遍或者多次连接子查询数据表要强得多。所以，当多次进行with as子循环检索的时候，Oracle会自动的进行临时表化。

下面我们看第三个SQL语句。

 

SQL> explain plan for with a as (select /*+MATERIALIZE*/emp.empno, emp.ename, dept.loc, emp.job from emp, dept where

 

emp.deptno=dept.deptno)

  2   select *

  3   from a m, dept n

  4   where m.loc=n.loc;

 

Explained

 

SQL> select * from table(dbms_xplan.display);

 

PLAN_TABLE_OUTPUT

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

Plan hash value: 2532848790

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

| Id  | Operation                      | Name                        | Rows  | B

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

|   0 | SELECT STATEMENT               |                             |    14 |

|   1 |  TEMP TABLE TRANSFORMATION     |                             |       |

|   2 |   LOAD AS SELECT               | DEPT                        |       |

|   3 |    MERGE JOIN                  |                             |    14 |

|   4 |     TABLE ACCESS BY INDEX ROWID| DEPT                        |     4 |

|   5 |      INDEX FULL SCAN           | PK_DEPT                     |     4 |

|*  6 |     SORT JOIN                  |                             |    14 |

|   7 |      TABLE ACCESS FULL         | EMP                         |    14 |

|*  8 |   HASH JOIN                    |                             |    14 |

|   9 |    TABLE ACCESS FULL           | DEPT                        |     4 |

|  10 |    VIEW                        |                             |    14 |

|  11 |     TABLE ACCESS FULL          | SYS_TEMP_0FD9D6606_207360D8 |    14 |

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

Predicate Information (identified by operation id):

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

   6 - access("EMP"."DEPTNO"="DEPT"."DEPTNO")

       filter("EMP"."DEPTNO"="DEPT"."DEPTNO")

   8 - access("M"."LOC"="N"."LOC")

 

25 rows selected

 

这个SQL中，我们使用了with as，在主查询中只引用了一次a。但是，在执行计划中还是出现了临时表加载计算动作。区别就在于在子查询中使用了materialize的hint。

with as和materialize是经常匹配出现的。如果with as不满足临时表加载动作条件（引用两次），但是使用了materialize标记的话，Oracle还是会生成对应的临时表加载执行计划的。

如果不使用with as子句，而是直接使用materialize hint的话，会不会也出现临时表加载动作呢？

 

SQL> explain plan for select *

  2  from (select /*+MATERIALIZE*/emp.empno, emp.ename, dept.loc, emp.job from emp, dept where emp.deptno=dept.deptno) m,

  3       (select /*+MATERIALIZE*/emp.empno, emp.ename, dept.loc, emp.job from emp, dept where emp.deptno=dept.deptno) n

  4  where m.loc=n.loc;

 

Explained

 

SQL> select * from table(dbms_xplan.display);

 

PLAN_TABLE_OUTPUT

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

Plan hash value: 2298815876

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

| Id  | Operation                      | Name    | Rows  | Bytes | Cost (%CPU)|

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

|   0 | SELECT STATEMENT               |         |    49 |  3136 |    13  (16)|

|*  1 |  HASH JOIN                     |         |    49 |  3136 |    13  (16)|

|*  2 |   HASH JOIN                    |         |    14 |   602 |    10  (20)|

|   3 |    MERGE JOIN                  |         |    14 |   448 |     6  (17)|

|   4 |     TABLE ACCESS BY INDEX ROWID| DEPT    |     4 |    44 |     2   (0)|

|   5 |      INDEX FULL SCAN           | PK_DEPT |     4 |       |     1   (0)|

|*  6 |     SORT JOIN                  |         |    14 |   294 |     4  (25)|

|   7 |      TABLE ACCESS FULL         | EMP     |    14 |   294 |     3   (0)|

|   8 |    TABLE ACCESS FULL           | DEPT    |     4 |    44 |     3   (0)|

|   9 |   TABLE ACCESS FULL            | EMP     |    14 |   294 |     3   (0)|

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

Predicate Information (identified by operation id):

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

   1 - access("EMP"."DEPTNO"="DEPT"."DEPTNO")

   2 - access("DEPT"."LOC"="DEPT"."LOC")

   6 - access("EMP"."DEPTNO"="DEPT"."DEPTNO")

       filter("EMP"."DEPTNO"="DEPT"."DEPTNO")

 

24 rows selected

 

单独使用materialize hint，是不会起到临时表作用的。with as可以支持多个别名块创建动作，看第五个SQL。

 

SQL> explain plan for with a as (select /*+MATERIALIZE*/emp.empno, emp.ename, dept.loc, emp.job from emp, dept where

 

emp.deptno=dept.deptno),

  2                        b as (select /*+MATERIALIZE*/emp.empno, emp.ename, dept.loc, emp.job from emp, dept where

 

emp.deptno=dept.deptno)

  3  select *

  4  from a m,

  5       b n

  6  where m.loc=n.loc;

 

Explained

 

SQL> select * from table(dbms_xplan.display);

 

PLAN_TABLE_OUTPUT

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

Plan hash value: 1083325232

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

| Id  | Operation                      | Name                        | Rows  | B

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

|   0 | SELECT STATEMENT               |                             |    49 |

|   1 |  TEMP TABLE TRANSFORMATION     |                             |       |

|   2 |   LOAD AS SELECT               |                             |       |

|   3 |    MERGE JOIN                  |                             |    14 |

|   4 |     TABLE ACCESS BY INDEX ROWID| DEPT                        |     4 |

|   5 |      INDEX FULL SCAN           | PK_DEPT                     |     4 |

|*  6 |     SORT JOIN                  |                             |    14 |

|   7 |      TABLE ACCESS FULL         | EMP                         |    14 |

|   8 |   LOAD AS SELECT               |                             |       |

|   9 |    MERGE JOIN                  |                             |    14 |

|  10 |     TABLE ACCESS BY INDEX ROWID| DEPT                        |     4 |

|  11 |      INDEX FULL SCAN           | PK_DEPT                     |     4 |

|* 12 |     SORT JOIN                  |                             |    14 |

|  13 |      TABLE ACCESS FULL         | EMP                         |    14 |

|* 14 |   HASH JOIN                    |                             |    49 |

|  15 |    VIEW                        |                             |    14 |

|  16 |     TABLE ACCESS FULL          | SYS_TEMP_0FD9D6607_207360D8 |    14 |

|  17 |    VIEW                        |                             |    14 |

|  18 |     TABLE ACCESS FULL          | SYS_TEMP_0FD9D6608_207360D8 |    14 |

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

Predicate Information (identified by operation id):

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

   6 - access("EMP"."DEPTNO"="DEPT"."DEPTNO")

       filter("EMP"."DEPTNO"="DEPT"."DEPTNO")

  12 - access("EMP"."DEPTNO"="DEPT"."DEPTNO")

       filter("EMP"."DEPTNO"="DEPT"."DEPTNO")

  14 - access("M"."LOC"="N"."LOC")

 

34 rows selected

 

3、结论

 

综合上面的讨论，我们可以得到with as应用的条件和好处。总体上看，with as可以带来两方面的好处。第一是语句清晰度上，将原有的复杂子查询内容拆解为若干语句块，提高了可读性。第二是对于自动临时表，可以将子查询数据先检索出来，在内存中进行组织连接。

最后我们想讨论一下对于subquery unnested特性。大多数情况下，我们认为Oracle这个特性是可以生成更好地执行计划的。但是，在实践中我们也的确发现过很多这样的场景：子查询速度很快、数据量也不大，但是连接之后速度变慢，结果是发现执行计划中子查询被打开。

默认情况下，Oracle在估算多条件语句结果集数量的时候，是有“计算偏小”的特性的。也就是估算的结果集数量要小于实际数量，这个是由于默认统计量没有考虑列相关性的原因。所以，大部分查询展开都是被通过的。

如果出现这样的情况，with as + materialize是一种强制进行子查询先执行的好办法。

来自 “ ITPUB博客 ” ，链接：http://blog.itpub.net/17203031/viewspace-1166038/，如需转载，请注明出处，否则将追究法律责任。

转载于:http://blog.itpub.net/17203031/viewspace-1166038/