Dynamic Materialized Views
Jingren Zhou Per-Ake˚ Larson Jonathan Goldstein Luping Ding Microsoft Research Microsoft Research Microsoft Research Worcester Polytechnic Institute [email protected] [email protected] [email protected] [email protected]
Abstract Example 1 Consider the following parameterized query against the TPC-H database that finds information for a A conventional materialized view blindly materializes given part. and maintains all rows of a view, even rows that are never Q1:select p partkey, p name, p retailprice, s name, accessed. We propose a more flexible materialization strat- s suppkey, s acctbal, l quantity, l extendedprice from part, lineitem, supplier egy aimed at reducing storage space and view maintenance where p partkey=l partkey and s suppkey=l suppkey costs. A dynamic materialized view selectively materializes and p partkey=@pkey only a subset of rows, for example, the most frequently ac- Suppose Q1 is executed frequently but its current re- cessed rows. One or more control tables are associated sponse time is deemed too high for the application’s needs. with the view and define which rows are currently mate- To speed up the query, we could define a materialized view rialized. The set of materialized rows can be changed dy- V1 that precomputes the join. namically, either manually or automatically by an internal cache manager using a feedback loop. Dynamic execution create view V1 as select p partkey, p name, p retailprice, s name, plans are generated to decide whether the view is applicable s suppkey, s acctbal, l quantity, l extendedprice at run time. Experimental results in Microsoft SQL Server from part, lineitem, supplier show that compared with conventional materialized views, where p partkey=l partkey and s suppkey=l suppkey dynamic materialized views greatly reduce storage require- If the view result is clustered on (p partkey, s suppkey), ments and maintenance costs while achieving better query the three-table join in the query is replaced by a very effi- performance with improved buffer pool efficiency. cient index lookup of the clustered index. V1 materializes the complete join, so it may be quite 1 Introduction large. On a database at scale factor 1, there would be 200,000 parts and the view would contain 6 million rows. Judicious use of materialized views can speed up the Now consider a scenario where the access pattern is highly processing of queries by several orders of magnitude. The skewed and, in addition, changes over time. Suppose 1,000 idea of using materialized views is more than twenty years parts account for 90% of the queries on any given day but old [17, 22] and all major database systems (DB2, Oracle, this subset of parts changes seasonally - some parts are pop- SQL Server) now support materialized views [2, 23, 5]. The ular during summer but not during winter and vice versa. In support included in those systems consists of computing, this scenario, we could get 90% of the benefit of the mate- materializing, and maintaining all rows of the view defini- rialized view by materializing only 0.5% of the rows. This tion result, which we refer to as static materialized views. would both reduce overhead for maintaining the view dur- However, storage costs may be high for large static views ing updates and also save storage space. However, this is and maintenance can also be costly if the views are fre- not possible with today’s materialized view technology be- quently updated. If only a small subset of the full view cause the seasonally changing contents of the materialized result is used over a period of time, disk storage is wasted view cannot be specified by a static predicate. for the unused records and many records that are never used Dynamic materialized views are ideally suited for situ- are unnecessarily kept up to date. ations like this. To handle our example query, we create a In this paper we introduce dynamic materialized views control table hotspot and a dynamic materialized view DV1 which selectively materialize only some of the rows in the whose content is controlled by hotspot. view, for example, only the most frequently accessed rows. create table hotspot(hotpartkey int primary key) Which rows are currently materialized is specified by one or more control tables associated with the view. Changing create view DV1 as which rows are materialized can be done dynamically (at select p partkey, p name, p retailprice, s name, s suppkey, s acctbal, l quantity, l extendedprice run time) simply by modifying data in a control table. We from part, lineitem, supplier illustrate the basic idea by an example. where p partkey=l partkey and s suppkey=l suppkey where the replicated data can be treated as dynamic materi- and exists(select * from hotspot hs alized views and contain only the most frequently accessed where p partkey=hs.hotpartkey) rows. A dynamic view can also be used for incremental view materialization. Conventionally, materialized views Query Q1 Case 1: Case 2: cannot be exploited before the materialization finishes. The Using View Using Tables Checking Run-time process can be very lengthy for an expensive view. Before the view gets fully materialized, we can treat it as a dynamic
3 r1 materialized view and the contents of the control table rep- 7 r2 19 r3 hit miss resent the current materialization progress. As a result, the 3 DV1 hotspot 7 view can be exploited even before it is fully materialized! 19 ... Base Tables We discuss other potential applications in Section 4. Record New hot The main contributions of our paper are as follows: DBA Event keys • Cache Manager We provide a new mechanism to dynamically adapt and exploit the contents of materialized views. Com- Figure 1. Overall Architecture pared with traditional approaches, dynamic material- While the static view V1 materializes information about ized views significantly reduce view maintenance costs all parts, DV1 only materializes information about the parts and storage requirements. listed in the control table hotspot, that is, parts satisfying • We extend conventional view matching and mainte- the exists clause. The control table is invisible – queries do nance algorithms to dynamic materialized views. Dy- not need to explicitly reference the control table to exploit namic query execution plans determine at run time the view. whether a view can be used or not. Figure 1 outlines the overall architecture of using dy- • We introduce a feedback loop with a novel caching namic materialized views in a database system. Query Q1 policy to automatically adapt the contents of dynamic can be answered from the view if the key of the desired part materialized views. is found in hotspot. To exploit the view safely, the opti- • We outline several potential applications of dynamic mizer produces a query plan that first checks at run-time materialized views across different areas in database whether the desired part key exists in hotspot,shownas systems. ① step in Figure 1. If it does, the plan evaluates the query The rest of this paper is organized as follows. In Sec- DV ② using a simple select against 1 (step ). Otherwise, the tion 2, we introduce the general form of a dynamic mate- ③ query is evaluated using the base tables (step ). rialized view, and present view matching and maintenance Upon updates to the base tables, only changes affecting algorithms. We describe several types of control schemas the hot parts need to be propagated to DV1, which greatly and dynamic views with more complex control designs in reduces the view maintenance cost. The content of DV1 Section 3. In Section 4, we explain how to adapt the con- can be changed dynamically by updating the control table tents of the dynamic view using a feedback loop and outline hotspot. Inserting a new part key into the control table other applications. Experimental results in Microsoft SQL automatically adds its information to the view. The dele- Server are presented in Section 5. We review related work tions happen in a similar way. We delay discussion of in- in Section 6 and conclude in Section 7. crementally maintaining dynamic materialized views until Section 2. 2 Dynamic Materialized Views Figure 1 also shows two possible ways to manage the In this section, we define dynamic materialized views DV content of 1. A DBA can manually change the contents and describe how to extend regular view matching and of the control table according to new business requirements maintenance algorithms to work with dynamic materialized ④ (step ). Or, the control table can be automatically man- views. For ease of presentation, we use a dynamic materi- aged by an internal cache manager using a feedback loop. alized view with a single control table as an example. The Q During execution of 1, the cache manager records whether techniques presented here are also applicable to more ad- ⑤ the query could be answered from the view or not (step ). vanced dynamic materialized views in Section 3. The cache manager implements some caching policy and recommends admitting or evicting rows in the control ta- 2.1 View Definitions ble based on its policy (step ⑥). The recommended updates Let Vb denote the query expression defining a standard of the control table are done asynchronously so that normal SPJG (select, project, join and an optional group-by) view 1 query execution is not affected . and Pv its select-join predicate. We refer to Vb as the base Dynamically materializing only part of a view can be view. Borrowing from SQL, we use the shorthand Vb.∗ to useful in many scenarios. For example, dynamic views can denote all columns of view Vb. be extremely useful for a mid-tier database cache [16, 1, 8], A dynamic materialized view Vd is defined over the base view Vb but has materialization controlled by a control table 1 The update process is not shown in the figure. Tc and a control predicate Pc(Vb,Tc). V exists (select 1 from hotspot create view d as ChoosePlan where hotpartkey = @pkey) select Vb.* from Vb True False T P V T Guard Condition where exists (select 1 from c where c( b, c)) SELECT JOIN p_partkey = @pkey Control table Tc can be a regular table or even another DV1 JOIN Supplier materialized view. Control predicate Pc references columns Using View from Tc and only non-aggregated output columns from Vb. SELECT Lineitem This restriction is important for view matching and for view p_partkey = @pkey maintenance as described in Section 2.2 and Section 2.3. Part Fallback plan The exists clause in the definition restricts the rows actu- Figure 2. Dynamic execution plan for Q1 ally materialized in Vd to those satisfying the control pred- V icate Pc for rows currently stored in Tc. Hence, by adding More formally, let d be a dynamic materialized SPJ V P and deleting rows from Tc, we control the contents of Vd. view with base view b and control predicate c. Denote V P The dynamic materialized view DV1 defined earlier has the select-join predicate of b with v. Consider a SPJ Q V the following components. We omit the full column list. query over the same tables as b and denote its combined select-join predicate by P . Due to space limitation, all the Vb:select ... q from part, lineitem, supplier proofs are omitted and can be found in [24]. where p partkey=l partkey and s suppkey=l suppkey Containment checking requires that Pq ⇒ (Pv ∧ Pc) in Q V P ∧ order to answer from d. The control table is invisible v:(p partkey=l partkey) (l suppkey=s suppkey) P Tc:hotspot(hotpartkey int) to the query so q does not reference the control table. The Pc(Vb,Tc):(p partkey=hotpartkey) implication cannot be proven at compile time because it de- 2.2 View Matching pends on the contents of the view at run time. To deal with this, we break up the test into three parts; the first two are A view matching algorithm for regular materialized evaluated at optimization time and the third one – the guard views is described in [5]. A view can be used to answer the condition – is evaluated at execution time. whole query or some subexpressions. To determine whether The first part is Pq ⇒ Pv, which tests whether the query a query expression can be computed from a view, the query is contained in the view if it is fully materialized. Clearly, and view expressions are first converted into normal form. the query cannot be contained in a dynamic materialized Next containment is tested, that is, whether all rows re- view if it is not even contained in the corresponding fully quired by the query are contained in the view. Finally, ad- materialized view. ditional requirements such as whether the view supplies all For the second part, we add a guard predicate Pg, if pos- required columns and has the correct duplication factor are sible, to the antecedent, obtaining the condition (Pg∧Pq) ⇒ checked. In this section, we show how to extend this algo- (Pv ∧ Pc). This condition asks the question: “If the addi- rithm to handle dynamic materialized views. tional condition Pg is satisfied, is the query then contained For regular views, containment of the query in the view in the view?” If the first condition, Pq ⇒ Pv, is satisfied, can be tested at optimization time but for dynamic materi- this second condition can be simplified to (Pg ∧ Pq) ⇒ Pc. alized views, part of the testing has to be postponed to ex- The third part of the test consists of verifying, at execu- ecution time. We call the test evaluated at execution time a tion time, that a tuple satisfying the guard predicate exists guard condition. In this paper, we assume that guard condi- in the control table, that is, ∃t ∈ Tc : Pg(t). tions are limited to checking whether one or a few covering Q values exist in the control table. If the desired values are Theorem 1 Consider an SPJ query with a conjunctive P V found in the control table, then all tuples associated with predicate q and a dynamic materialized SPJ view d with base view predicate P , control predicate P , and control those values are currently materialized. v c table T . Then query Q is covered by view V if there exists At optimization time, we construct the guard condition c d apredicatePg such that the following three conditions are so that the query is guaranteed to be contained in the view satisfied. if the guard condition evaluates to true. The evaluation of P ⇒ P (1) the guard condition is delayed until execution time. The q v (P ∧ P ) ⇒ P query plan must also contain an alternative subplan, called g q c (2) a fallback plan, that computes the query expression from ∃t ∈ Tc : Pg(t) (3) other input sources in case the guard condition evaluates to Example 2 For our example view PV1 and query Q1,itis false. easy to see that the first test is true. Choosing the guard Figure 2 shows a possible dynamic query plan for Q1. predicate as (hotpartkey=@pkey), the second test (Pg ∧ The ChoosePlan operator first evaluates the guard condi- P ) ⇒ P is simplified to tion shown on the right. (The operator tree for evaluating q c ∧ ⇒ the guard condition is not shown.) If it evaluates to true, (hotpartkey=@pkey) (p partkey=@pkey) (p partkey=hotpartkey) the dynamic view contains the required rows and the left branch using the view is executed. Otherwise, the right It is easy to see that this condition is also true. The last branch computing the result from base tables is executed. test, to be evaluated at execution time, equals ∃ t∈ hotspot:(t.hotpartkey=@pkey) 2.3 View Maintenance This condition, expressed in SQL, is shown in Figure 2. Incremental maintenance of materialized views is a well- studied problem, and efficient maintenance algorithms are Whether the dynamic materialized view is guaranteed known for SPJG views. Compared with a fully material- P to contain all required rows depends on whether g, with ized view, a dynamic materialized view can be maintained known parameters, evaluates to true at execution time. The more efficiently, because only a small number of rows are following theorem considers queries with non-conjunctive actually materialized. However, current view maintenance predicates. algorithms are designed for SPJG views and do not support Theorem 2 Consider an SPJ query Q with a non- views containing exist subqueries. In this section, we out- conjunctive predicate Pq, which can be converted to dis- line how to incrementally maintain a dynamic materialized P = P 1 ∨···∨P n junctive normal form as q q q and a dy- view. The general observation is that if the base view Vb namic materialized SPJ view Vd with base view predicate is maintainable, the corresponding dynamic view Vd is also Pv and control predicate Pc referencing a control table Tc. maintainable. Q V Then query is covered by view d if, for each disjunct If the query expression in the exists clause returns at most i =1, 2, ···,n P i , there exists a predicate g such that the one row for each possible value of the control columns, the following three conditions are satisfied. subquery can be converted to a join. A dynamic material- V P i ⇒ P (4) ized view d that satisfies this requirement can, for main- q v tenance purposes, be treated as the regular view V shown (P i ∧ P i) ⇒ P d g q c (5) below. ∃t ∈ T : P i(t ) V i c g i (6) create view d as select Vb.* from Vb, Tc where Pc(Vb,Tc) Q Example 3 The following query is similar to 1 but the The view V is a regular SPJG view and can be incre- equality predicate has been changed to an IN predicate. d mentally maintained. For example, the view DV1 is of this An IN predicate can be rewritten as a disjunction of equal- type because hotpartkey is a primary key of the control table ity predicates, which after conversion to disjunctive normal hotspot. Converting the subquery to an inner join produces form, produces the two disjuncts shown below. the following equivalent definition DV Q1:select ... create view 1 as from part, lineitem, supplier select ... where p partkey=l partkey and s suppkey=l suppkey from part, lineitem, supplier, hotspot and p partkey in (12, 25) where p partkey=l partkey and s suppkey=l suppkey and p partkey=hotpartkey P 1 ∧ q :( p partkey=l partkey) (s suppkey=l suppkey) ∧ (p partkey=12) If the query expression in the exists clause may return P 2 ∧ more than one row, converting the subquery into a join may q :( p partkey=l partkey) (s suppkey=l suppkey) ∧ (p partkey=15) produce duplicate rows. We consider two situations based on whether V contains aggregation. The view matching tests for this example will be the b Case 1: First consider the case when Vb is a SPJ view. same as in Example 2, except @pkey is replaced by 12 or 2 If the output columns of Vb contain a unique key , we can by 15. The optimization-time tests still evaluate to true. For V V convert the view d into the following aggregation view d the query to be covered, both execution-time tests must be to make it incrementally maintainable. satisfied, which produces the following guard condition. V create view d as ∃ t1∈ hotspot:(t1.hotpartkey=12) ∧ select Vb.*, count(*) as cnt ∃ t2∈ hotspot:(t2.hotpartkey=15) from Vb, Tc where Pc(Vb, Tc) group by Vb.* All the output columns of V have to be included as which can be expressed in SQL most efficiently as b group-by columns so that they can be output. The group-by 2=(select count(*) from hotspot V operation in d simply removes the duplicated rows and the where hotpartkey in (12,15)) V count is added for view maintenance. The view d contains V An aggregation query or view is treated as an SPJ query exactly the same rows as the view d; the only difference is that each row has an additional column cnt. followed by a group-by operation. Aggregation adds one V step to view matching that tests whether the grouping in If the output columns of b do not contain a unique key, the view is compatible with that in the query. For a dy- an extra join is required during maintenance so as not to introduce duplicates. We will show the rewrite assuming a namic aggregation view the grouping-compatibility test is C the same as for a regular view because of our requirement single control column and denote this column by c.The generalization to multiple view columns is straightforward. that the control predicate Pc of the view involves only non- We rewrite Vd using a self-join for maintenance purposes. aggregated output columns ofthebaseviewVb. Hence, ei- ther all the rows in a group or none of them will satisfy the 2In Microsoft SQL Server, a materialized view is required have a control predicate. unique key. V create view d as where p partkey=l partkey and s suppkey=l suppkey select Vb.* and exists (select * from hotrange from Vb v1 join where p partkey>lowerkey and p partkey
the cache controller is in memory, the cache policy needs to create view DV4 as select ... from orders be very space efficient too. where exists (select * from DV4 We designed a novel cache policy based on the 2Q algo- where o custkey=c custkey) rithm [14]. Due to space limitation, we can only highlight The two views can of course be used independently, that the important features of the algorithm. is, DV4 for queries against the customer table where the • Similar to the 2Q algorithm, we make use of two market segment is specified and DV4 for queries against the queues, one for admissions and one for evictions. orders table where the customer key is specified. In addition • We consider admission of a new row on its second and they can be used for queries joining customer and orders subsequent accesses. that specify a market segment, e.g. the following query. • We keep track of the approximate temperature (time select ... from customer, orders since last access) of every row in both queues. where c custkey=o custkey and c mktsegment=’Household’ • If the cache is full, a row is admitted only of it is hotter Dynamic views with other powerful and flexible control than the coolest row already in the cache. This reduces schemes are possible; further details can be found in [24]. the admission/eviction rate and keeps the hit rate high. • We use bitmaps and hashing to significantly reduce 4 Control Table Management memory requirements. Control table updates are treated no differently than nor- Experiments showed that our new policy is much more mal base table updates. As detailed in Section 2.3, a dy- space efficient than competing policies and achieves a com- namic materialized view can be properly maintained with- petitive hit rate coupled with a low admission/eviction rate out distinguishing whether the update applies to a control and rapid response to changing access patterns. table or a base table. Automatic caching can also be extremely useful for a A materialization policy are simply rules for deciding mid-tier database cache, such as Microsoft’s MTCache [16, which rows to materialize and when. The choice of ma- 15] and IBM’s DBCache [1]. A mid-tier cache replicates terialization policy depends on the applications. A policy part of the data from a backend server and attempts to han- can be manually performed by a DBA or automatically de- dle as many queries as possible from the replicated data to ployed by the system. In this section we describe a few achieve improved scale-out. MTCache models local data important applications and their corresponding policies. as materialized views [16] that are updated asynchronously. Automatic Caching: A materialized policy can be im- Sometimes it would be preferable to automatically materi- plemented using some form of caching policy. For exam- alize only the most frequently accessed rows and change the ple, we implemented a feedback loop in Microsoft SQL set of rows in response to the access pattern of queries. We Server to automatically manage the contents of the con- describe various models using dynamic views in [8]. trol table of a dynamic materialized view. An in-memory Incremental View Materialization: A dynamic view cache controller is associated with each control table. Dur- can be used to incrementally materialize an expensive view. ing execution of a query that uses a dynamic materialized This can be done using a range control table and slowly in- view we record in its cache controller whether the required creasing the range covered. Having the control predicates rows were covered by the control table, that is, whether the range over the view’s clustering key would materialize the query could be answered by the view or not. A cache con- view page by page and minimize overhead. Before the view troller implements some caching policy and recommends gets fully materialized, we treat it as a dynamic materialized admitting or evicting rows in the control table based on its view and the contents of the control table represent the cur- policy. The recommended updates to the control table are rent materialization progress. The view can be exploited done asynchronously so that normal query execution is not even before it is fully materialized! When materialization affected. A cache controller’s data structures are stored in completes, all we need to do is to mark the view as being a memory only and not persisted to disk. The cache controller fully materialized view and abandon the fallback plans. is created the first time a dynamic materialized view is used Dynamic views can also be useful for clustering hot after system startup. items, views with non-distributive aggregates, and view An analysis of commonly used caching policies (LRU, support for parameterized queries and queries with parame- LRU-k, Clock, GClock, 2Q) revealed that none of them ters in complex subqueries; the details can be found in [24]. 5 Experimental Results s suppkey, s name, s acctbal
We have prototyped support for dynamic views with create view V5 as equality control predicates in Microsoft SQL Server 2005. select Q5.* from part, supplier, lineitem We ran a series of experiments to compare the performance where p partkey=l partkey and s suppkey=l suppkey of a dynamic view with that of a fully materialized view. group by p partkey, p name, p retailprice, s suppkey, s name, s acctbal All experiments were performed on a workstation with dual 3.2 GHz Xeon processor, 2GB of memory and two create table hotspot(hotpartkey int primary key) 70GB SCSI disks, running Windows Server 2003. All DV queries were against a 10GB version (SF=10) of the TPC-H create view 5 as select Q5.* from part, supplier, lineitem database. Automatic control table management as described where p partkey=l partkey and s suppkey=l suppkey in Section 4 was used throughout our experiments. We fixed and exists (select * from hotspot hs the maximum size of the dynamic view and the cache con- where p partkey=hs.hotpartkey) group by p partkey, p name, p retailprice, troller determined which rows to materialize based on ob- s suppkey, s name, s acctbal served access patterns. The workload consisted of query Q5 with varying pa- Dynamic materialized views are intended for applica- rameter values. Three different database designs were con- tions with skewed access patterns. One main benefit of a dy- sidered: using a dynamic materialized view (DMV) DV5, namic view is reduced maintenance overhead, in case of fre- using a fully static materialized view (FMV) V5, and us- quent updates with either uniformly distributed or skewed ing no views. When using the fully materialized view, the update patterns. In this section, we focus in particular on query execution plan is a simple index lookup of V5.When the following areas. using the dynamic materialized view DV5, the query exe- • Due to partial materialization, a dynamic view cannot cution plan is a dynamic plan with two branches. The fast answer every possible query. With skewed access pat- branch consists of a simple index lookup against DV5.The terns and a fixed size, we want to verify that its query fallback branch consists of an index lookup against the part performance is no worse than that of a fully material- table followed by two indexed nested loop joins with the ized view, even if occasionally some queries have to supplier table and the lineitem table, respectively, and a fi- use the fallback plan. nal aggregation. • Secondly, we want to examine the query performance We ran the query one million times with randomly se- of a dynamic materialized view when memory space lected partkey values drawn from a Zipfian distribution with (for the buffer pool) is limited. skew factor α. To avoid running a long series of queries • Finally, we want to investigate the maintenance over- to warm up the control table for every experiment, we head for a dynamic view. Different update patterns preloaded the control table hotspot of view DV5 with the need to be considered, either quite different or the most frequent accessed partkeys for each scenario 3. same as the query access pattern. The size of the fully materialized view V5 is about 1GB. We fixed the size of the dynamic materialized view DV5 to 5.1 Query Performance 5% of the size of V5, that is, about 51 MB. By varying the With unlimited buffer pool size, the query performance skew factor α, we were able to change the view’s hit rate, 4 provided by a dynamic view improves with the hit rate be- that is, the fraction of queries answered from DV5 . cause fewer queries use the more expensive fallback plan. We considered different skew factors. The larger the The higher the hit rate, the closer its performance is to skew factor α, the more skewed the access pattern and the that of a fully materialized view, assuming both views fit higher the hit rate for DV5. We reported the results for three in memory. However, if the buffer pool size is limited, a scenarios so that DV5 covered 90%, 95%, and 97.5%, re- larger fraction of a dynamic view fits in memory, which re- spectively, of the query executions. The guard condition duces disk I/O. As a result, the overall query performance was evaluated by an index lookup against the 1MB control of a dynamic view may even be better than that of a fully table – the overhead was very small. The feedback loop is materialized view despite the fact the view may not cover enabled so that new hot partkeys, if any, are automatically all queries. The experiments reported in this section are loaded or evicted from the view. The view’s cache con- designed to quantify the net effect on query performance troller is called on every access and adds to the CPU load. and how it is affected by skewness in the access pattern and 3We experimentally verified that preloading resulted in the cor- buffer pool size. rect initial state, that is, the same state as would have been reached Q5:select p partkey, p name, p retailprice, s suppkey by running a series of warm-up queries, and also that beginning s name, s acctbal, sum(l quantity) as sum qty with a cold cache controller did not materially affect the admis- sum(l extendedprice*(1-l discount)*(1+l tax)) sion/eviction rate after warm-up. as revenue 4We also ran experiments for dynamic views with various sizes, from part, supplier, lineitem V where p partkey=l partkey and s suppkey=l suppkey up to 100% of the size of 5. The results are similar; we do not and p partkey=@partkey report them here due to lack of space. As its size increased, the per- group by p partkey, p name, p retailprice, formance of the dynamic view converged to that of the full view. 7 6 4.5 4 6 5 3.5 5 4 3 4 2.5 3 3 2 2 1.5 2 1 1 1 0.5 Execution Time (K seconds) Execution Time (K seconds) Execution Time (K seconds) 0 0 0 64 128 256 512 64 128 256 512 64 128 256 512 Buffer Pool Size (MB) Buffer Pool Size (MB) Buffer Pool Size (MB) DMV FMV No View DMV FMV No View DMV FMV No View (a) 90% (α =1) (b) 95% (α =1.1) (c) 97.5% (α =1.115) Figure 3. Effect of Buffer Pool Size and Access Skew In all the experiments, both the overhead of evaluating the included a small index scan using the view’s clustering in- guard condition and the cache controller overhead was too dex. No matter which view is used, the number of rows low to measure reliably. scanned is the same, and so is the cost of computing the rest For each scenario, we also varied the buffer pool size. of the query. Therefore, the overall number of rows pro- Figure 3 shows the total execution time with different buffer cessed is the same for both views and the savings in elapsed pool sizes for the three scenarios. The buffer pool is too time is due to improved buffer pool utilization. small to hold all three base tables (part, partsupp and sup- What if the views are not clustered on the control col- plier), which have a combined size of 1.5 GB. Because the umn? In this case, fewer pages need to be fetched and fewer hot part keys are randomly distributed over the key space, rows processed when using a dynamic materialized view in- we expect to have poor buffer pool usage and significant stead of a fully materialized view. Simply put, there is less disk I/O. The smaller the buffer pool, the more severe the “junk” (non-qualifying rows) to wade through to find the I/O problem. With the fully materialized view V5, no joins target rows. Query performance should improve because are needed and CPU time is saved. However, V5 is still too less work needs to be done. large to fit completely in the buffer pool, resulting in some To investigate this effect, we created the follow- I/O. The dynamic view DV5 is small enough to fit com- ing dynamic view with an equality control predicate on pletely in the buffer pool. s nationkey and ran a query with selection predicates on As expected, it is much faster to use a materialized view p type and s nationkey. than computing the query from scratch, as shown in Fig- create table hotnation(nationkey int primary key) ure 3. All three plan types benefit from an increase in buffer pool size. Using the dynamic view DV5 can be up to 33% create view DV6 as select p partkey, p name, p type, s name, faster than using the full view V5 because of better buffer sp supplycost, s suppkey, s name, s nationkey pool utilization; performance is slightly worse only when from part, partsupp, supplier the buffer pool is very small. When the access pattern is where p partkey=sp partkey and s suppkey=sp suppkey highly skewed, as shown in Figure 3(c), the dynamic view and exists (select * from hotnation ht can achieve about the same performance as the fully ma- where s nationkey=ht.nationkey) terialized view with only a quarter of the memory. When Q6:select p partkey, p name, p type, s name, the access pattern is less skewed, as shown in Figure 3(a), sp supplycost, s suppkey, s name, s nationkey the dynamic view achieves comparable performance as the from part, partsupp, supplier where p partkey=sp partkey and s suppkey=sp suppkey fully materialized view. For the 10% of the queries that the and p type like ’STANDARD POLISHED%’ dynamic view cannot answer, it is sufficiently expensive to and s nationkey=@nkey compute the results from scratch with the limited memory DV available to cancel the savings resulting from better buffer To speed up processing of the query, both 6 and the pool utilization for the other 90% of the queries. corresponding fully materialized view were clustered on In summary, the performance benefits of using a dy- (p type, s nationkey, p partkey, s suppkey). We varied the DV namic view depends on several factors, such as the amount size of the dynamic view 6 by varying the number of DV of memory available, the skew in the access pattern, and the rows in the control table. 6 always contained the nation- Q relative cost of the fallback plan, etc. The benefit is higher key for Argentina. We ran query 6 with @nkey=1 (Ar- if the access pattern is more skewed and the dynamic mate- gentina) 100 times and computed the average elapsed time. rialized view covers more queries, not taking into account hotnation Size Full View Dynamic View Savings(%) buffer pool effects. 1 1.130 0.121 89% 5 1.130 0.294 74% 5.2 Processing Fewer Rows 10 1.130 0.594 47% In the previous experiment, both views were clustered 25 1.130 1.170 -3% on the control column p partkey. Query Q5 includes the The above table compares query Q9 execution time with very selective predicate (p partkey=@pkey), so both plans a cold buffer pool. For both view types, the main part of Apply Apply Apply the execution consisted of an index scan using the view’s Update Update Update clustering index. Because DV6 only contains rows from a Aggregate Aggregate Aggregate subset of nations, fewer rows need to be read and processed Nested Nested Merge compared with a fully materialized view. As expected, the Loops Loop Join savings is highest when the dynamic materialized view is Nested IndexSeek Nested IndexSeek Nested IndexScan Loops supplier Loop supplier Loop hotspot small and increases linearly with the view size. The 3% Nested IndexSeek Nested IndexSeek Nested IndexSeek increase when the dynamic materialized view contains all Loops lineitem Loop hotspot Loop part
delta IndexSeek delta IndexSeek delta IndexSeek rows is caused by higher query startup cost and the the cost part hotspot lineitem part supplier lineitem of evaluating the guard condition. (a) Update Part (b) Update Lineitem (c) Update Supplier Experiments with a warm buffer pool gave similar results but the savings were lower. With a warm buffer pool, no I/O Figure 5. Update Plans is required to answer the query regardless of view type so the total update costs for the uniform update scenario. As the reduction in execution time is strictly due to reduced expected, the observed cost is much lower – up to 20 times CPU time. – when using a dynamic view DV5 than when using a fully materialized view V5. 5.3 Update Performance The gain when updating lineitem is much smaller than
18 14 when updating supplier. The reason is that each update 16 12 V5 14 only affects one row in the full materialized view .Even 10 12 though we do much less maintenance work for the dynamic 10 8 DV 8 6 materialized view 5, the total execution cost is so low 6 4 that the query initialization cost is a significant fraction of 4 2 2 the overall cost. The initialization cost is the same whether Execution TimeExecution seconds) (x100 Execution Time (x100 seconds) (x100 Time Execution 0 0 Part (20K Lineitem (20K Supplier (10K Part (20K Updates) Lineitem (20K Supplier (10K we use a fully or dynamic materialized view. However, Updates) Updates) Updates) Updates) Updates) when updating the supplier table, each update affects hun- DMV FMV DMV FMV dredsofrowsinV5 and those rows are not clustered to- (a) Uniform Update (b) Skewed Update gether, which means that many disk pages are affected by Figure 4. Maintenance Costs each update. In this case, the reduced maintenance work for Dynamic views are expected to have lower maintenance DV5 makes a huge difference. cost than the corresponding fully materialized view. To in- In the second scenario the rows to be updated were ran- vestigate this issue, we created two instances of the 10GB domly selected using a skewed (Zipfian) distribution. The TPC-H database, one with the dynamic view DV5 and the update columns are the same as the first scenario. The up- other with the fully materialized view V5. We chose the date plans generated were the same as shown in Figure 5. view configuration corresponding to Figure 3(b) (skew fac- When updating the part table, the updates had the same tor α =1.1,sizeofDV5 5% of the size of V5) and set the skewed distribution as queries. As DV5 covered 95% of 5 maximum buffer pool size of 512MB. the query execution, DV5 was also affected by 95% of the For each base table, we issued a series of updates, each updates. This is the extreme case when the update skew is one updating a single column of a single table row selected the exactly the same as the query skew. As shown in Fig- based on the primary key of the table. The updates modi- ure 4(b), the benefits of using DV5 is not as high as for uni- fied p retailprice in the part table, l quantity in the lineitem formly distributed updates. Still, maintaining the dynamic table, and s acctbal in the supplier table, respectively. view is cheaper by a factor of two. For 95% of the updates, We ran experiments with two scenarios: uniform updates the dynamic view and the fully materialized view were both with random key value selection and skewed updates with affected by the update. However, the affected rows in the skewed key value selection. We measured the total update fully materialized view are scattered over the whole view. time, including the time for the base table update and view Maintaining them requires many more disk I/Os than main- maintenance and the time to flush updated pages to disk. taining the dynamic materialized view. Figure 5 shows the corresponding update plans. Recall When updating the lineitem and supplier tables, the up- that the control table contains only 5% of the part keys dates had a skewed distribution based on l orderkey and (100,000 keys), so it is relatively small compared with the s suppkey with a skew factor α =1.0, respectively. How- base tables. The join with the control table greatly reduces ever, the skew was not correlated to p partkey. Again, main- the number of rows so it is applied as early as possible in taining the dynamic materialized view DV5 is much cheaper each of the plans. The more significant savings, however, and the improvement is up to a factor of 15. results from having far fewer updates to apply to the view. In summary, compared with maintaining a fully mate- In the uniform update case, the parameter values were rialized view, the maintenance saving for a dynamic view uniformly distributed over their domains. Figure 4(a) shows depends on several factors. • 5The results for other configurations are similar, and are omit- The cost of computing the delta rows for the view. ted due to space considerations. • How many rows in the view are affected by an update. • Whether the affected rows are clustered or not. buffer pool requirements. The new mechanism to dynami- • cally adapt and exploit materialized views is ideal for many If an update affects very few rows, the benefit may not database applications. be significant because of the constant startup cost. References 6 Related Work The problems of view matching and view maintenance [1] M. Altinel, C. Bornhovd, S. Krishnamurthy, C. Mohan, H. Pirahesh, have received considerable attention in the research com- and B. Reinwald. Cache tables: Paving the way for an adaptive database cache. In Proc. of VLDB Conference, 2003. munity for the last two decades. However, to the best of our [2] R.G.Bello,K.Dias,A.Downing,J.J.Feenan,J.L.Finnerty,W.D. knowledge, researchers have only considered fully materi- Norcott, H. Sun, A. Witkowski, and M. Ziauddin. Materialized views alized views. in Oracle. In Proc. of VLDB Conference, 1998. Answering queries using views has been studied in [17, [3] J. A. Blakeley, P. Larson, and F. W. Tompa. Efficiently updating 22, 4, 20]. Larson and Yang [17, 22] were the first to de- materialized views. In Proc. of SIGMOD Conference, 1986. scribe view matching algorithms for SPJ queries and views. [4] S. Chaudhuri, R. Krishnamurthy, S. Potamianos, and K. Shim. Op- timizing queries with materialized views. In Proc. of ICDE Confer- Srivastava et al. [20] proposed a view-matching algorithm ence, 1995. for queries and views with aggregation. Chaudhuri et al. [5] J. Goldstein and P. Larson. Optimizing queries using materialized [4] considered using materialized views in a System-R style views: A practical, scalable solution. In Proc. of SIGMOD Confer- query optimizer. A thorough survey of work on answering ence, 2001. queries using views can be found in [12]. [6] G. Graefe and K. Ward. Dynamic query evaluation plans. In Proc. Incremental view maintenance has been studied in [3, 11, of SIGMOD Conference, 1989. 7, 18]. They all use the update delta paradigm - compute [7] T. Griffin and L. Libkin. Incremental maintenance of views with duplicates. In Proc. of SIGMOD Conference, 1995. a set of changed tuples (inserted or deleted) that are then [8] H. Guo, P. Larson, and R. Ramakrishnan. Caching with ’good used to update the materialized view. Gupta et al. [10] also enough’ currency, consistency, and completeness. In Proc. of VLDB described incremental view adaption techniques. Conference, 2005. Materialized views have been adopted in all major com- [9] H. Guo, P. Larson, R. Ramakrishnan, and J. Goldstein. Relaxed cur- mercial database systems. Oracle was the first commercial rency and consistency: how to say ”good enough” in sql. In Proc. of database system to support materialized views [2]. Zahar- SIGMOD Conference, 2004. ioudakis et al. [23] described a bottom-up view matching [10] A. Gupta, I. S. Mumick, and K. A. Ross. Adapting materialized views after redefinitions. In Proc. of SIGMOD Conference, 1995. algorithm in IBM DB2. Goldstein and Larson [5] presented [11] A. Gupta, I. S. Mumick, and V. S. Subrahmanian. Maintaining views algorithms to matching views in Microsoft SQL Server. incrementally. In Proc. of SIGMOD, 1993. Partial indexes that contain only some of the values in a [12] A. Y. Halevy. Answering queries using views: A survey. The VLDB column of a table were proposed in [21, 19]. The restric- Journal, 10(4), 2001. tion is represented by a static predicate in the index defini- [13] IBM. Red Brick Warehouse 6.3, Peformance Guide, 2004. tion. Similar to a regular materialized view, a partial index [14] T. Johnson and D. Shasha. 2Q: A low overhead high performance is defined over a single table by a select-project expression. buffer management replacement algorithm. In Proc. of VLDB Con- ference, 1994. Dynamic views are much more flexible. [15] P. Larson, J. Goldstein, H. Guo, and J. Zhou. Mtcache: Mid-tier Dynamic plans were proposed by Graefe and Ward database caching for sql server. Data Engineering Bulletin, 27(2), in [6]. They have been used in the context of mid-tier 2004. caching in [1, 16, 9] and probably also in other contexts. At [16] P. Larson, J. Goldstein, and J. Zhou. MTCache: Mid-tier database least one commercial system, Red Brick Warehouse [13], cache in SQL server. In Proc. of ICDE Conference, 2004. implements dynamic plans. [17] P. Larson and H. Z. Yang. Computing queries from derived relations. In Proc. of VLDB Conference, 1985. 7Conclusion [18] I. S. Mumick, D. Quass, and B. S. Mumick. Maintenance of data cubes and summary tables in a warehouse. In Proc. of SIGMOD In current database systems, a view must be either fully Conference, 1997. materialized or not materialized at all. A dynamic view ma- [19] P. Seshadri and A. Swami. Generalized partial indexes. In Proc. of terializes only some of the rows and which rows are ma- ICDE Conference, 1995. terialized can be easily and quickly modified by updating [20] D. Srivastava, S. Dar, H. V. Jagadish, and A. Y. Levy. Answering a control table. Adapting the contents can be done either queries with aggregation using views. In Proc. of VLDB Conference, manually by a DBA or automatically by an internal caching 1996. strategy that monitors which rows of the view are most fre- [21] M. Stonebraker. The case for partial indexes. SIGMOD Record, 18(4), 1989. quently requested. We showed that dynamic views can be [22] H. Z. Yang and P. Larson. Query transformation for psj-queries. In seamlessly integrated into the existing materialized view in- Proc. of VLDB Conference, 1987. frastructure. [23] M. Zaharioudakis, R. Cochrane, G. Lapis, H. Pirahesh, and M. Urata. Dynamic views offer significant performance benefits Answering complex sql queries using automatic summary tables. In compared to regular materialized view for applications with Proc. of SIGMOD Conference, 2000. skewed access patterns. The primary benefits are lower [24] J. Zhou, P.-A.˚ Larson, and J. Goldstein. Partially materialized views. storage requirements, lower maintenance costs and lower Technical Report MSR-TR-2005-77, Microsoft Research, 2005.