Nonrecursive incremental evaluation of Datalog queries

Abstract

We consider the problem of repeatedly evaluating the same (computationally expensive) query to a database that is being updated between successive query requests. In this situation, it should be possible to use the difference between successive database states and the answer to the query in one state to reduce the cost of evaluating the query in the next state. We use nonrecursive Datalog (which are unions of conjunctive queries) to compute the differences, and call this process "incremental query evaluation using conjunctive queries."After formalizing the notion of incremental query evaluation using conjunctive queries, we give an algorithm that constructs, for each regular chain query (including transitive closure as a special case), a nonrecursive Datalog program to compute the difference between the answer after an update and the answer before the update. We then extend this result to weakly regular queries, which are regular chain programs augmented with conjunctive queries having the so-called cartesian-closed increment property, and to the case of unbounded-set insertions where the sets are binary cartesian products. Finally, we show that the class of conjunctive queries with the cartesian-closed increment property is decidable.

Incremental Classification of Description Logics Ontologies

“…There has been substantial work on incremental query and view maintenance in databases (e.g., [6,38,40]) and rule-based systems (e.g., Datalog [13,14]). While related, our work addresses a more expressive formalism.…”

A Top-Down Query Answering Procedure for Normal Logic Programs Under the Any-World Assumption

“…and that any successive evaluation step corresponds to the execution of the same query over an updated database. We refer the reader to e.g., [6,7] concerning the problem of repeatedly evaluating the same query to a database that is being updated between successive query requests. In this situation, it may be possible to use the difference between successive database states and the answer to the query in one state to reduce the cost of evaluating the query in the next state.…”

History Matters: Incremental Ontology Reasoning Using Modules

“…That is, the number of subsumptions that change their entailment status w.r.t. the ontology, like, say, α 1 or α 2 in Table 2, is probably small compared to the number of subsumptions that do not, like α 3 or α 4 . If so, then many (possibly expensive) re-computations can be avoided by reusing the subsumption relations computed for the previous version of the ontology.…”

“…In other words, the case of axiom α 4 in Figure 2 is likely to be the most one after a change in an ontology. 4 In this paper we propose an alternative approach for incremental reasoning based on the module-extraction techniques introduced in [2]. Our technique can be used to keep track of "evidences" for both subsumptions and non-subsumptions modulo arbitrary changes in ontologies, and works in combination with any DL-reasoner providing for standard reasoning services.…”

“…There has been substantial work on incremental query and view maintenance in databases (e.g., [1,15,16]) and rule-based systems (e.g., Datalog [4,5]). While related, our work addresses a more expressive formalism; further, traditionally in database systems the problem of incremental maintenance is considered with respect to data (corresponding to DL ABoxes) and not with respect to the database schema (corresponding to DL TBoxes).…”