Materialized Views, 其实不是View。我觉得把它归类于Index可能还准确一些。

View在我们的印象里总是逻辑存在的。即使前面加上一个Materialized，我们只会觉得奇怪，干嘛要对View进行物化呢？

把它理解为一种特殊的Index未尝不可，况且，它与Index有一些相同点：

• They consume storage space.
• They must be refreshed when the data in their master tables changes.
• They improve the performance of SQL execution when they are used for query rewrites.
• Their existence is transparent to SQL applications and users.

而一般的View呢？

• They don’t consume storage space.
• They don’t need to be refreshed when the data in their master tables changes.
• They don’t improve the performance of SQL execution, database just maps the View to the underlying Table when executing.
• Their existence is transparent to SQL applications and users.

不过，Materialized View为什么特殊，我觉得在于它的应用场合——数据仓库。或许我们可以说，Materialized View 是专门用于数据仓库的Index。

问题在于，数据仓库场合和OLTP场合对Index的要求有哪些不同，干嘛需要一个专门的Materialized View？

数据仓库的查询一般都是”大”查询。何谓大？多表联合（n个大表join在一起），多维度分析（一长串的group by），聚合统计（avg, count, sum,rank,cube）。

数据库如何跑这种查询呢？硬件方面，用更多的CPU和硬盘；软件方面，采用数据分区，并行执行。软硬件一起提供的厂商，如Oracle的Exadata, Teradata, Netezza, 可能做到数据库软件与硬件的紧密结合，从而实现对数据的智能扫描（在IO这一层实现对不需要数据的过滤）等技术。

这种做法可以很好地应对数据仓库里一类重要的查询：随机查询。例如，某位领导突然想到了一个决策方案，开发人员必须为这种决策提供分析数据。

另一方面，如果某类“大”查询经常被执行，我们就得想办法对其进行优化了。最直接的方法就是缓存中间结果，多表连接的结果，多维度分析的结果，聚合统计的结果，对了，这就是Materialized View的用武之地了。

Materialized View缓存了中间结果，Oracle通过Query Rewrite的技术把对基表的访问转换成对Materialized View的访问。这个对性能的提高可以是成千上万倍的。

如何创建Materialized View以便让Query Rewrite用到，这也许是Materialized View里面最重要的部分，也是理解Query Rewrite如何工作的一个途径。最好的参考文献当然是Oracle的Oracle® Database Data Warehousing Guide.

以后的文章再回来看看Query Rewrite的实现。

对上一篇文章里提到两条语句
select distinct begin_date, end_date, begin_date + level -1 day  from test connect by begin_date + level -1 <= end_date order by 1,2,3;
和
select one_date
  from (select start_date + level – 1 one_date
          from (select min(start_date) start_date, max(end_date) end_date
                  from test) test
        connect by start_date + level – 1 < = end_date ) all_date,
       test
where one_date between start_date and end_date;

它们都实现相同的功能，即: 当一个表里面有两个列，分别为begin_date和end_date时，如何针对这个表的每一行，用SQL返回begin_date和end_date之间的所有连续日期。

首先，我们关注第一条语句在没有distinct的情况下返回的行数。

会使问题简单化，假设对于表里的每行数据，end_date – begin_date + 1 的值都是一样的，设为 n 。假设test里总共有 m 行(m>1)。
那么，这时返回的行数是 m * ( power(m,n) – 1 )/( m – 1 ) 。
(
这是一个等比数列，公式为
1 +  m +  power(m,2) + ….  power(m,n-1) = ( 1 – power (m,n)) / (1 – m),
)
这些行可以用一系列的树加以形象的表示，如下所示：

当 n 和 m 很大时，会使结果集变得非常之大，为 power(m,n).

因此，下面语句在数据量变大的情况下，性能将急剧下降!
select distinct begin_date, end_date, begin_date + level -1 day  from test connect by begin_date + level -1 <= end_date order by 1,2,3;

对于语句2，我们关注以下子查询所返回的行数:
select start_date + level – 1 one_date
          from (select min(start_date) start_date, max(end_date) end_date
                  from test) test
        connect by start_date + level – 1 < = end_date

这时，表实质上只有1行时，存贮的是原来表的最大值和最小值。也就是说，这时 m = 1 。

当m=1时，情况变得不同了。这时，返回的行数刚好就是 n 。
如果以树加以表示的话，这时上面的图形已经退化成一棵只有一个支干的树。

因此，当原来的查询m 和 n都很大时，返回的行数为 将为n。

从上面的表述可清晰地看出，语句2在大数据量的情形下将能体现出良好的性能。

从另一方面看，出现distinct的地方，或许就是性能调整应该关注的地方了。

举个例子，假设有两个日期 2009-03-20和2009-03-23，如果用SQL返回2009-03-20, 2009-03-21, 2009-03-22, 2009-03-23。
更一般的，当一个表里面有两个列，分别为begin_date和end_date时，如何针对这个表的每一行，用SQL返回begin_date和end_date之间的所有连续日期。

在层次查询中，Oracle引入了一个伪列level,用来表示当前行（节点）对应的level，它从1开始计数，每多一层level的值就加1。我们可以据此实现对两个日期/整数之间所有日期/整数的遍历。

SQL> CREATE TABLE test (begin_date date,end_date date);
SQL> INSERT INTO test VALUES(trunc(sysdate), trunc(sysdate+5));
SQL> SELECT begin_date, end_date, begin_date + level -1 day FROM test connect BY begin_date + level -1 <= end_date;
BEGIN_DAT END_DATE  DAY
--------- --------- ---------
23-MAR-09 28-MAR-09 23-MAR-09
23-MAR-09 28-MAR-09 24-MAR-09
23-MAR-09 28-MAR-09 25-MAR-09
23-MAR-09 28-MAR-09 26-MAR-09
23-MAR-09 28-MAR-09 27-MAR-09
23-MAR-09 28-MAR-09 28-MAR-09
 
6 rows selected.

当test表里面有多行时，这个方法还行得通吗？

SQL> INSERT INTO test VALUES(trunc(sysdate+4),trunc(sysdate+7));
SQL> SELECT  begin_date, end_date, begin_date + level -1 day  FROM test connect BY begin_date + level -1 <= end_date ORDER BY 1,2,3;
 
BEGIN_DAT END_DATE  DAY
--------- --------- ---------
23-MAR-09 28-MAR-09 23-MAR-09
23-MAR-09 28-MAR-09 24-MAR-09
23-MAR-09 28-MAR-09 24-MAR-09
23-MAR-09 28-MAR-09 25-MAR-09
23-MAR-09 28-MAR-09 25-MAR-09
23-MAR-09 28-MAR-09 25-MAR-09
23-MAR-09 28-MAR-09 25-MAR-09
23-MAR-09 28-MAR-09 26-MAR-09
23-MAR-09 28-MAR-09 26-MAR-09
23-MAR-09 28-MAR-09 26-MAR-09
23-MAR-09 28-MAR-09 26-MAR-09
23-MAR-09 28-MAR-09 26-MAR-09
23-MAR-09 28-MAR-09 26-MAR-09
23-MAR-09 28-MAR-09 26-MAR-09
23-MAR-09 28-MAR-09 26-MAR-09
23-MAR-09 28-MAR-09 27-MAR-09
23-MAR-09 28-MAR-09 27-MAR-09
23-MAR-09 28-MAR-09 27-MAR-09
23-MAR-09 28-MAR-09 27-MAR-09
23-MAR-09 28-MAR-09 27-MAR-09
23-MAR-09 28-MAR-09 27-MAR-09
23-MAR-09 28-MAR-09 27-MAR-09
23-MAR-09 28-MAR-09 27-MAR-09
23-MAR-09 28-MAR-09 27-MAR-09
23-MAR-09 28-MAR-09 27-MAR-09
23-MAR-09 28-MAR-09 27-MAR-09
23-MAR-09 28-MAR-09 27-MAR-09
23-MAR-09 28-MAR-09 27-MAR-09
23-MAR-09 28-MAR-09 27-MAR-09
23-MAR-09 28-MAR-09 27-MAR-09
23-MAR-09 28-MAR-09 27-MAR-09
23-MAR-09 28-MAR-09 28-MAR-09
23-MAR-09 28-MAR-09 28-MAR-09
23-MAR-09 28-MAR-09 28-MAR-09
23-MAR-09 28-MAR-09 28-MAR-09
23-MAR-09 28-MAR-09 28-MAR-09
23-MAR-09 28-MAR-09 28-MAR-09
23-MAR-09 28-MAR-09 28-MAR-09
23-MAR-09 28-MAR-09 28-MAR-09
23-MAR-09 28-MAR-09 28-MAR-09
23-MAR-09 28-MAR-09 28-MAR-09
23-MAR-09 28-MAR-09 28-MAR-09
23-MAR-09 28-MAR-09 28-MAR-09
23-MAR-09 28-MAR-09 28-MAR-09
23-MAR-09 28-MAR-09 28-MAR-09
23-MAR-09 28-MAR-09 28-MAR-09
23-MAR-09 28-MAR-09 28-MAR-09
27-MAR-09 30-MAR-09 27-MAR-09
27-MAR-09 30-MAR-09 28-MAR-09
27-MAR-09 30-MAR-09 28-MAR-09
27-MAR-09 30-MAR-09 29-MAR-09
27-MAR-09 30-MAR-09 29-MAR-09
27-MAR-09 30-MAR-09 29-MAR-09
27-MAR-09 30-MAR-09 29-MAR-09
27-MAR-09 30-MAR-09 30-MAR-09
27-MAR-09 30-MAR-09 30-MAR-09
27-MAR-09 30-MAR-09 30-MAR-09
27-MAR-09 30-MAR-09 30-MAR-09
27-MAR-09 30-MAR-09 30-MAR-09
27-MAR-09 30-MAR-09 30-MAR-09
27-MAR-09 30-MAR-09 30-MAR-09
27-MAR-09 30-MAR-09 30-MAR-09
 
62 rows selected.

或许应该加上一个distinct

SQL> SELECT DISTINCT begin_date, end_date, begin_date + level -1 day  FROM test connect BY begin_date + level -1 <= end_date ORDER BY 1,2,3;
 
BEGIN_DAT END_DATE  DAY
--------- --------- ---------
23-MAR-09 28-MAR-09 23-MAR-09
23-MAR-09 28-MAR-09 24-MAR-09
23-MAR-09 28-MAR-09 25-MAR-09
23-MAR-09 28-MAR-09 26-MAR-09
23-MAR-09 28-MAR-09 27-MAR-09
23-MAR-09 28-MAR-09 28-MAR-09
27-MAR-09 30-MAR-09 27-MAR-09
27-MAR-09 30-MAR-09 28-MAR-09
27-MAR-09 30-MAR-09 29-MAR-09
27-MAR-09 30-MAR-09 30-MAR-09
 
10 rows selected.
 
SQL>

另外一种方法是先得到min(begin_date) 和 max(end_date)之间所有的连续日期，假设这些日期放在表all_date里面，再用表all_date和原来的表test做连接，从而得到最后的结果。

SELECT one_date
  FROM (SELECT start_date + level - 1 one_date
          FROM (SELECT min(start_date) start_date, max(end_date) end_date
                  FROM test) test
        connect BY start_date + level - 1 < = end_date ) all_date,
       test
 WHERE one_date BETWEEN start_date AND end_date;

下篇文章探讨下两种方式的性能。

汇总统计是数据处理中常见的一个操作。对于一般的数据模型来说，一般是有一个事实表，若干个维度表，通过事实表与维度表的连接，实现不同层次的查询汇总。
问题是对于组织结构而言，一般所有的数据都存贮于一个表中，而且，组织结构的层次也是动态的。那么，在这种情况下，如何实现员工工资的汇总呢？一个比较有趣的问题是: 如何统计员工及其所有被管理员工的总工资，举个例子，CEO的总工资就是整个公司总有员工的总工资之和，包括他自己。

Oracle 引入了一个扩展的运算符，专门用来处理此种情形，它就是connect_by_root。
当以connect_by_root修饰一个列名时，Oracle将返回根节点对应的此列的值。例如，当start with 为 last_name = ‘King’时，这时返回的所有行的connect_by_root last_name的值都将为’King’。这时，对所有行的累计就是对’King’的数据的累计了。当不指定start with 子句时，Oracle将对每个节点依次进行遍历，于是，我们可以对返回的结果对last_name进行一次group by，那么我们就得到了所有last_name对应的汇总工资了。

下面是Oracle 文档中的例子。
The following example returns the last name of each employee in department 110, each manager above that employee in the hierarchy, the number of levels between manager and employee, and the path between the two:

SELECT last_name "Employee", CONNECT_BY_ROOT last_name "Manager",
   LEVEL-1 "Pathlen", SYS_CONNECT_BY_PATH(last_name, '/') "Path"
   FROM employees
   WHERE LEVEL > 1 AND department_id = 110
   CONNECT BY PRIOR employee_id = manager_id
   ORDER BY "Employee", "Manager", "Pathlen", "Path";
 
Employee        Manager            Pathlen Path
--------------- --------------- ---------- ------------------------------
Gietz           Higgins                  1 /Higgins/Gietz
Gietz           King                     3 /King/Kochhar/Higgins/Gietz
Gietz           Kochhar                  2 /Kochhar/Higgins/Gietz
Higgins         King                     2 /King/Kochhar/Higgins
Higgins         Kochhar                  1 /Kochhar/Higgins

The following example uses a GROUP BY clause to return the total salary of each employee in department 110 and all employees below that employee in the hierarchy:

SELECT name, SUM(salary) "Total_Salary" FROM (
   SELECT CONNECT_BY_ROOT last_name AS name, Salary
      FROM employees
      WHERE department_id = 110
      CONNECT BY PRIOR employee_id = manager_id)
      GROUP BY name
   ORDER BY name, "Total_Salary";
 
NAME                      Total_Salary
------------------------- ------------
Gietz                             8300
Higgins                          20300
King                             20300
Kochhar                          20300

虽然Oracle不是一个层次型的数据库，不过它却对层次型应有不错的支持。

层次型应用最常见的是一个公司内部的组织结构。

在计算机科学中，或者更具体地说，在数据结构中，层次型结构是由“树”来描述的。节点之间的关系代表着上下两个层次之间节点的关系，即父子关系。这一般是一对多的关系。

一般地，我们会把这一系列的父子关系存贮到数据库里的一个表里面。

而Oracle的任务，就是要重现这棵树，并实现有关层次关系的运算。例如，打印出层次结构图，统计层次结构中每个节点对应的直接子节点数，对应的直接子节点和间接子节点数，统计每个节点的所处的层次。

以公司内部组织结构为例，则要求实现对公司组织结构的重现，统计每位经理所直接管理员工的数目，直接和间接管理员工的数目，每位经理所处的级别，还有，每位经理所管理的所有员工的总有工资的总和，等等。

为了实现这些功能，Oracle引入了几个关键词，connect by, prior 和 start with。connect by实现了表中两个直接层次间数据行的连接，而prior则是用来标记哪个是父节点。start with则代表从哪些节点开始遍历。如下图所示:

下面是Oracle如何处理connect by 和prior的官方描述
Oracle processes hierarchical queries as follows:
    * A join, if present, is evaluated first, whether the join is specified in the FROM clause or with WHERE clause predicates.
    * The CONNECT BY condition is evaluated.
    * Any remaining WHERE clause predicates are evaluated.

更详细地:
   1. Oracle selects the root row(s) of the hierarchy—those rows that satisfy the START WITH condition.
   2. Oracle selects the child rows of each root row (from all the rows in the table). Each child row must satisfy the condition of the CONNECT BY condition with respect to one of the root rows.
   3. Oracle selects successive generations of child rows. Oracle first selects the children of the rows returned in step 2, and then the children of those children, and so on. Oracle always selects children by evaluating the CONNECT BY condition with respect to a current parent row.
   4. If the query contains a WHERE clause without a join, then Oracle eliminates all rows from the hierarchy that do not satisfy the condition of the WHERE clause. Oracle evaluates this condition for each row individually, rather than removing all the children of a row that does not satisfy the condition.
   5. Oracle returns the rows in the order shown in Figure 9-1. In the diagram, children appear below their parents.

Figure 9-1 Hierarchical Queries

关于第5点，这就是大家熟悉的树的中序遍历算法。而前面的4点，应该说是一个层次遍历。我想我们更应该记住的是第5点，谁知道Oracle内部具体实现时是不是按照前4点的描述呢。

以上面这个图为例子。我们可以利用Oracle的查询语句打印出类似目录树的输出。做为对基础知识的一个实践。

CREATE TABLE hierarchy (id number, parent_id number);
INSERT INTO hierarchy(1,NULL);
INSERT INTO hierarchy(2,1);
INSERT INTO hierarchy(7,1);
INSERT INTO hierarchy(9,1);
INSERT INTO hierarchy(3,2);
INSERT INTO hierarchy(4,2);
INSERT INTO hierarchy(8,7);
INSERT INTO hierarchy(10,9);
INSERT INTO hierarchy(12,9);
INSERT INTO hierarchy(5,4);
INSERT INTO hierarchy(6,4);
INSERT INTO hierarchy(11,10);
col tree format a10
col path format a15
SELECT level,rpad(’-',level,’-') || id tree, sys_connect_by_path(id,’/') Path, connect_by_root id
from hierarchy
start with parent_id is null
connect by parent_id = prior id;

输出如下所示:

connect by 和connect_by_root 还有许多有趣的扩展应用。后继文章再详细探讨一下。