Results 1  10
of
13
Incremental Recomputation of Recursive Queries with Nested Sets and Aggregate Functions
, 1997
"... We examine the power of incremental evaluation systems that use an SQLlike language for maintaining recursivelydefined 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 r ..."
Abstract

Cited by 18 (7 self)
 Add to MetaCart
We examine the power of incremental evaluation systems that use an SQLlike language for maintaining recursivelydefined 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...
Incremental Maintenance of Recursive Views Using Relational Calculus/SQL
 SIGMOD Record
, 2000
"... Views are a central component of both traditional database systems and new applications such as data warehouses. Very often the desired views (e.g. the transitive closure) cannot be defined in the standard language of the underlying database system. Fortunately, it is often possible to incrementall ..."
Abstract

Cited by 15 (1 self)
 Add to MetaCart
Views are a central component of both traditional database systems and new applications such as data warehouses. Very often the desired views (e.g. the transitive closure) cannot be defined in the standard language of the underlying database system. Fortunately, it is often possible to incrementally maintain these views using the standard language. For example, transitive closure of acyclic graphs, and of undirected graphs, can be maintained in relational calculus after both single edge insertions and deletions. Many such results have been published in the theoretical database community. The purpose of this survey is to make these useful results known to the wider database research and development community. There are many interesting issues involved in the maintenance of recursive views. A maintenance algorithm may be applicable to just one view, or to a class of views specified by a view definition language such as Datalog. The maintenance algorithm can be specified in a maintenance language of different expressiveness, such as the conjunctive queries, the relational calculus or SQL. Ideally, this maintenance language should be less expensive than the view definition language. The maintenance algorithm may allow updates of different kinds, such as just single tuple insertions, just single tuple deletions, special setbased insertions and/or deletions, or combinations thereof. The view maintenance algorithms may also need to maintain auxiliary relations to help maintain the views of interest. It is of interest to know the minimal arity necessary for these auxiliary relations
Dynamic Tree Isomorphism via Firstorder Updates to a Relational Database
 In PODS'98
"... In databases, as in other computational settings, one would like to efficiently update answers to queries while minor changes are being made to the data. Dynamic complexity asks what resources are required to perform such updates. In this paper our main focus will be a particular dynamic graph prob ..."
Abstract

Cited by 14 (0 self)
 Add to MetaCart
In databases, as in other computational settings, one would like to efficiently update answers to queries while minor changes are being made to the data. Dynamic complexity asks what resources are required to perform such updates. In this paper our main focus will be a particular dynamic graph problem, tree isomorphism, and the efficiency of our update scheme will be measured in terms of how expressive a query language is required to express our update. Working in the framework developed by [DS93, PI97] for dynamic query evaluation, we show that dynamic tree isomorphism can be performed via firstorder updates to a relational database (in [DS93] this framework is called a firstorder incremental evaluation system, and in [PI97] it is called DynFO). In [EI95] it was shown that treeisomorphism can not be expressed in firstorder logic augmented with a transitive closure operator and counting, (FO + TC + COUNT) (but without ordering). We thus obtain a first example of a graph problem...
Maintaining the transitive closure of graphs in SQL
 In Int. J. Information Technology
, 1999
"... 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 upd ..."
Abstract

Cited by 7 (3 self)
 Add to MetaCart
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
Incremental Recomputation in Local Languages
 INFCTRL: Information and Computation (formerly Information and Control
, 2001
"... We study the problem of maintaining recursivelydened views, such as the transitive closure of a relation, in traditional relational languages that do not have recursion mechanisms. The main results of this paper are negative ones: we show that a certain property of query languages implies imposs ..."
Abstract

Cited by 7 (0 self)
 Add to MetaCart
We study the problem of maintaining recursivelydened views, such as the transitive closure of a relation, in traditional relational languages that do not have recursion mechanisms. The main results of this paper are negative ones: we show that a certain property of query languages implies impossibility of such incremental maintenance. The property we use is locality of queries, which is known to hold for relational calculus and various extensions, including those with grouping and aggregate constructs (essentially, plain SQL). 1
Dynamic Complexity Theory Revisited
 Proc. Annual Symposium on Theoretical Aspects of Computer Science (STACS 05), Springer LNCS 3404, 2005
, 2005
"... Abstract. Dynamic complexity asks for the effort needed to maintain the information about properties of a structure under operations changing the structure. This paper introduces a refined notion of dynamic problems which takes the initial structure into account. It develops the basic structural com ..."
Abstract

Cited by 6 (0 self)
 Add to MetaCart
Abstract. Dynamic complexity asks for the effort needed to maintain the information about properties of a structure under operations changing the structure. This paper introduces a refined notion of dynamic problems which takes the initial structure into account. It develops the basic structural complexity notions accordingly. It also shows that the dynamic version of the LOGCFLcomplete problem D2LREACH(acyclic) can be maintained with firstorder updates. 1
THE DYNAMIC COMPLEXITY OF FORMAL LANGUAGES
 STACS
, 2009
"... 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 quantifierfree firstorder updates, with and without auxiliary functions, respectively. It is shown that the lang ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
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 quantifierfree firstorder 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 contextfree language can be maintained in DynFO and a number of specific contextfree languages, for example all Dycklanguages, are maintainable in DynQF. Furthermore, the dynamic complexity of regular tree languages is investigated and some results concerning arbitrary structures are obtained: there exist firstorder definable properties which are not maintainable in DynPROP. On the other hand any existential firstorder property can be maintained in DynQF when allowing precomputation.
Dynamic Definability
, 2012
"... We investigate the logical resources required to maintain knowledge about a property of a finite structure that undergoes an ongoing series of local changes such as insertion or deletion of tuples to basic relations. Our framework is closely related to the DynFOframework of Patnaik and Immerman an ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
We investigate the logical resources required to maintain knowledge about a property of a finite structure that undergoes an ongoing series of local changes such as insertion or deletion of tuples to basic relations. Our framework is closely related to the DynFOframework of Patnaik and Immerman and the FOIESframework of Dong, Libkin, Su and Wong, and also builds on work of Weber and Schwentick. We assume that the dynamic process starts with an arbitrary, nonempty structure, but in contrast to previous work, we assume that, in general, structures are unordered. We show how to modify known dynamic algorithms for symmetric reachability, bipartiteness, kedge connectivity and more, to work also without an order and with dynamic processes starting at an arbitrary graph. A history independent dynamic system (also called deterministic or memoryless) is one that maintains all auxiliary information independent of the update order. In 1997, Dong and Su posed the problem whether there exist history independent dynamic systems with FOupdates for symmetric reachability or bipartiteness. We give a positive answer to this question. We further show that there is a history independent system for tree isomorphism with FO+Cupdates. On the other hand we show that on unordered structures firstorder logic is too weak to maintain enough information to answer the equal cardinality query and the tree isomorphism query dynamically.
Properties of Languages That Make Recursive Views Unmaintainable
"... We study the problem of maintaining recursivelydefined views, such as the transitive closure of a relation, in traditional relational languages that do not have recursion mechanisms. The main results of this paper show that in most cases such incremental maintenance is impossible if either no au ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
We study the problem of maintaining recursivelydefined views, such as the transitive closure of a relation, in traditional relational languages that do not have recursion mechanisms. The main results of this paper show that in most cases such incremental maintenance is impossible if either no auxiliary relations are used or they are limited to be deterministic. Instead of concentrating on proving these results for some particular languages, we try to identify properties of query languages that make such incremental maintenance impossible. That is, we want to use known results on expressive power of languages to derive new results on expressiveness of incremental recomputation. We identify two properties, studied previously in the literature on expressive power of query languages and finitemodel theory, that imply unmaintainability of several recursive queries under insertions or deletions. Furthermore, using known results on expressive power of query languages, we simplify...
Some Relationships between the FOIES and ... Arity Hierarchies
, 1996
"... Introduction A firstorder incremental evaluation system (foies) uses firstorder queries to maintain a database view which is defined by a nonfirstorder query; some auxiliary relations (views) may also need to be maintained similarly. In foies, monadic auxiliary relations were known to be strict ..."
Abstract
 Add to MetaCart
Introduction A firstorder incremental evaluation system (foies) uses firstorder queries to maintain a database view which is defined by a nonfirstorder 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 kary 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