We examine the power of incremental evaluation systems that use an SQL-like language for maintaining recursively-defined views. We show that recursive queries such as transitive closure, and "alternating paths" can be incrementally maintained in a nested relational language, when some auxiliary relations are allowed. In the presence of aggregate functions, even more queries can be maintained, for example, the "same generation" query. In contrast, it is still an open problem whether such queries are maintainable in relational calculus. We then restrict the language so that no nested relations are involved (but wekeep the aggregate functions). Such a language captures the capability of most practical relational database systems. We prove that this restriction does not reduce the incremental computational power; that is, any query that can be maintained in a nested language with aggregates, is still maintainable using only flat relations. We also show that one does not need auxiliar...

Abstract. The development of ontologies involves continuous but relatively small modifications. Existing ontology reasoners, however, do not take advantage of the similarities between different versions of an ontology. In this paper, we propose a technique for incremental reasoning—that is, reasoning that reuses information obtained from previous versions of an ontology—based on the notion of a module. Our technique does not depend on a particular reasoning calculus and thus can be used in combination with any reasoner. We have applied our results to incremental classification of OWL DL ontologies and found significant improvement over regular classification time on a set of real-world ontologies. 1

It is common knowledge that relational calculus and even SQL are not expressive enough to express recursive queries such as the transitive closure. In a real database system, one can overcome this problem by storing a graph together with its transitive closure and maintaining the latter whenever updates to the former occur. This leads to the concept of an incremental evaluation system, or IES. Much is already known about the theory of IES but very little has been translated into practice. The purpose of this paper is to ll in this gap by providing a gentle introduction to and an overview of some recent theoretical results on IES. The introduction is through the translation into SQL of three interesting positive maintenance results that have practical importance { the maintenance of the transitive closure of acyclic graphs, of undirected graphs, and of arbitrary directed graphs. Interestingly, these examples also allow ustoshow the relationship between power and cost in the incremental maintenance of database queries. 1

We study the problem of incrementally maintaining the result of an XPath query on an XML database under updates. In its most general form, this problem asks to maintain a materialized XPath view over an XML database. It assumes an underlying XML database D and a query Q. One is given a sequence of updates U to D and the problem is to compute the result of Q(U(D)), i.e., the result of evaluating query Q on the database D after having applied the updates U. In order to quickly answer this question, we are allowed to maintain an auxiliary data structure, and the complexity of the maintenance algorithms is measured in (i) the size of the auxiliary data structure, (ii) the worst-case time per update needed to compute Q(U(D)) and (iii) the worst-case time per update needed to bring the auxiliary data structure up to date. We allow three kinds of updates: node insertion, node deletion, and node relabeling. Our main results are that downward XPath queries can be incrementally maintained in time O(depth(D) · poly(|Q|)) per update and conjunctive forward XPath queries in time O(depth(D)·log(width(D))·poly(|Q|)) per update, where |Q | is the size of the query, and depth(D) and width(D) are the nesting depth and maximum number of siblings in the database D, respectively. The auxiliary data structures for maintenance are linear in |D | and polynomial in |Q | in all these cases.

Syndication on the Web has attracted a great amount of attention in recent years. However, today’s state-of-the-art syndication approaches still provide relatively weak ex-pressive power from a modeling perspective and provide very little automated reasoning support. If a more expressive approach with a formal semantics can be provided, many benefits can be achieved, including a rich semantics-based mechanism for expressing sub-scriptions and published content and automated reasoning for discovering subscription matches not found using traditional syntactic syndication approaches. In this dissertation, I develop a syndication framework based on the Web Ontology Language (OWL), which is the standardized language for representing the semantics of information on the Web. One of the main advantages of the framework is its support for formal reasoning, as the semantics of subsets of OWL are founded in description logic (a decidable fragment of first-order logic). Therefore, the previously mentioned benefits can be achieved using description logic (DL) reasoning. However, the main limitation in using OWL as the underlying representation model is related to the overhead of DL reasoning under changing data, which makes the approach

this report, we only consider queries from flat relations to flat relations; and the criteria for permissible update is restricted to the insertion and deletion of a single tuple. A restriction is also imposed so that the constants that appear in the auxiliary database must also appear in the database or in the answer or in some fixed set. In this report, this fixed set is Q , the set of rational numbers. We use the first-order incremental evaluation system, IES(FO)(called FOIES in [10]), to illustrate the concept. IES(FO) uses first-order logic to express update functions [9, 11]. For each relation symbol R,

. The incremental view maintenance problem deals with the efficient updating of materialized views in response to updates to base relations. This paper considers the problem in a distributed database environment, with communication cost minimization as the primary objective. The views considered are defined based on the relational join operation. The approach is to use "yes"/"no" tags as auxiliary data on tuples in the base relations to indicate whether the tuples participate in joins. These tags will help avoid sending irrelevant data over the network and thus reduce the communication cost. Two basic view maintenance algorithms are proposed using the tags. In addition to reducing communication costs, an important feature of these two basic algorithms is that they derive the "exact change" to views without looking at the old views. This feature allows us to maintain certain aggregates on views without actually materializing the views themselves; this feature is useful in applications s...

The paper investigates the power of the dynamic complexity classes DynFO, DynQF and DynPROP over string languages. The latter two classes contain problems that can be maintained using quantifier-free first-order updates, with and without auxiliary functions, respectively. It is shown that the languages maintainable in DynPROP exactly are the regular languages, even when allowing arbitrary precomputation. This enables lower bounds for DynPROP and separates DynPROP from DynQF and DynFO. Further, it is shown that any context-free language can be maintained in DynFO and a number of specific context-free languages, for example all Dyck-languages, are maintainable in DynQF. Furthermore, the dynamic complexity of regular tree languages is investigated and some results concerning arbitrary structures are obtained: there exist first-order definable properties which are not maintainable in DynPROP. On the other hand any existential first-order property can be maintained in DynQF when allowing precomputation.

Introduction A first-order incremental evaluation system (foies) uses first-order queries to maintain a database view which is defined by a non-first-order query; some auxiliary relations (views) may also need to be maintained similarly. In foies, monadic auxiliary relations were known to be strictly weaker than binary ones; however, it is open whether k-ary auxiliary relations are strictly weaker than (k+1)-ary ones for k ? 2 if we limit the arity of the input relations to be at most k. (In the full version of the PODS'95 paper [DS95b] which will appear in JCSS, it is shown that the answer to this question is positive if we do not limit the arity of the input relations.) It appears hard to generalize the techniques used for current separation results to solve the above problem. On the other hand, the arity hierarchy of \Sigma 1 1 was shown to be strict. The purposes of this note are two f

Introduction A first-order incremental evaluation system (foies) uses first-order queries to maintain a database view which is defined by a non-first-order query; some auxiliary relations (views) may also need to be maintained similarly. In foies, monadic auxiliary relations were known to be strictly weaker than binary ones; however, it is open whether k-ary auxiliary relations are strictly weaker than (k+1)-ary ones for k ? 2 if we limit the arity of the input relations to be at most k. (In the full version of the PODS'95 paper [DS95b] which will appear in JCSS, it is shown that the answer to this question is positive if we do not limit the arity of the input relations.) It appears hard to generalize the techniques used for current separation results to solve the above problem. On the other hand, the arity hierarchy of \Sigma 1 1 was shown to be strict. The purposes of this note are two f