View Management Techniques and Their Application to Data Stream Management - Evolving Application Domains of Data Warehousing and Mining - page 87

consider distributive and algebraic functions, as
only those can be maintained efficiently.
The approach by Mumick et al. (1997) uses
summary delta tables which compute the aggregate
functions for those tuples which have been inserted
or deleted in a view. The results of the summary
delta tables are then combined with the previous
values in the view. Thus, it can be applied only to
algebraic and distributive aggregate functions.
Methods for maintaining views using non-dis-
tributive aggregate functions have been proposed
(Li and Wang, 2006; Palpanas et al., 2002). The
approach by Li and Wang (2006) can be applied to
the median function and is based on the quotient
cube (Lakshmanan et al., 2002) which partitions a
cube into several cells with similar behavior. The
aggregate values need then to be maintained only
if a cell is affected by an update and not for all
tuples of the base relation. A similar idea is used
by Palpanas et al. (2002) which recomputes the
values only for affected groups.
Views using outer joins are common in data
integration and data warehousing, but they cannot
easily be maintained using the scheme described
above. Suppose we want to maintain a view with
an outer join between R and S, then if a tuple is
inserted into R, it might be necessary to remove
a tuple from S for which previously there was no
matching tuple in R. These special characteristics
of outer joins have to be taken into account in view
maintenance. Larson and Zhou (2007) present a
method which can efficiently maintain outer join
views. It also exploits foreign key constraints: in
the example above, if the join is between a foreign
key in R and a key in S, then if a tuple is inserted
into S, we can directly insert the tuple extended
with null values into the view, as there can be no
matching tuple in R because of the foreign key
constraint. In other cases, the maintenance of the
view is done in two phases: a primary delta table
represents all tuples which need to be inserted into
the view; the secondary delta removes those tuples
with extended null values from the view which
now have a joining tuple in the other relation.

The secondary delta can be computed using the
primary delta and either the base tables or the view.
Other approaches for the maintenance of outer
join views (Griffin and Kumar, 1998; Gupta and
Mumick, 2006) are either less efficient, incorrect,
or incomplete (Larson and Zhou, 2007).
Maintenance of views over XML data has
also been considered. Early approaches studied
maintenance of views over the semistructured data
model (Abiteboul et al., 1998; Zhuge and Garcia-
Molina, 1998) which provides only a rough,
graph-based abstraction of XML data (e.g., the
order of XML elements is not represented in the
semistructured data model). Liefke and Davidson
(2000) use a subset of the XML-QL query language
(which can be seen as a predecessor of XQuery),
supporting also restructuring operations such as
regrouping, flattening and aggregations. However,
ordered data structures are not supported. In an
order-sensitive approach (Dimitrova et al., 2003)
queries are expressed in an XML algebra in which
corresponding update propagation operations can
be defined for each operation. However, these
update propagation operations need to be pro-
cessed by a special query engine and require the
materialization of intermediate results.
These weaknesses have been identified by El-
Sayed et al. (2006) who also present a framework
for maintenance of views defined in XQuery. The
framework works in three phases: validate, propa-
gate and apply. In the validate phase, update trees
are generated from the source updates, and it is
verified whether these update trees are relevant for
a view. Multiple update trees can be combined to a
batch update tree if they are semantically related.
In the propagate phase, the update trees are used
to derive incremental maintenance plans (IMPs)
from the XQuery views. The IMPs generate delta
update trees which represent the updates to be
performed on the view extents. These delta update
trees are then applied in the last phase, in which
the necessary modifications to the materialized
views are done.