ArticlePDF Available

Soft stratification for transformation-based approaches to deductive databases /

Authors:
  • Technical University of Cologne

Abstract and Figures

Bonn, University, Diss., 2004 (Nicht für den Austausch).
Content may be subject to copyright.
A preview of the PDF is not available
... Our choice to express integrity constraints as datalog denials rather than relational algebraic expressions is motivated by the availability of proof tools for first-order logic that allow one to reason easily about formulas. The preference granted to datalog with respect to relational calculus is, however, only made for uniformity with recent works in the field (such as [70,20]) and for the closer similarity with Prolog, that will prove a useful test platform for some of our experiments (see chapter 6). ...
... Recently, renewed attention arose in the field of update propagation building on previous investigations in the area of view maintenance [99]. Continuing the work of [98], the author of [20] regards integrity checking as an instance of update propagation. In the proposed method, integrity constraints are expressed as propositional predicates that must always be derivable. ...
... It is important that UP ensures that the augmented rule set (which includes UP rules as shown in Figure 2 and the original rules like those for LCOM 1) generated for a set of logic rules which is guaranteed to terminate, still keeps this property. This was shown for the language set of Datalog [1], [7], which only allows straight forward declarative rules, in comparison to Prolog. We also need to assure this in Prolog, it would be unfavourable if the UP rules got stuck in infinite loops. ...
Article
Full-text available
Logic programs are now used as a representation of object-oriented source code in academic prototypes for about a decade. This representation allows a clear and concise implementation of analyses of the object-oriented source code. The full potential of this approach is far from being explored. In this paper, we report about an application of the well-established theory of update propagation within logic programs. Given the representation of the object-oriented code as facts in a logic program, a change to the code corresponds to an update of these facts. We demonstrate how update propagation provides a generic way to generate incremental versions of such analyses.
... For example 7 the II, to be checked after the update, is ← (p(b, x) ∨ b = x) ∧ (p(x, a) ∨ a = x). We evaluate the performance of this result in section 6. In [3], integrity checking is regarded as an instance of update propagation, i.e., the problem of determining the effect of an update on a set of rules. The method extends the database with rules that express the incremental evaluation of the new state and the ICs themselves are defined by rules. ...
Conference Paper
Efficient and incremental maintenance of integrity constraints involving recursive views is a difficult issue that has received some atten- tion in the past years, but for which no widely accepted solution exists yet. In this paper a technique is proposed for compiling such integrity constraints into incremental and optimized tests specialized for given update patterns. These tests may involve the introduction of new views, but for relevant cases of recursion, simplified integrity constraints are obtained that can be checked more efficiently than the original ones and without auxiliary views. Notably, these simplified tests are derived at de- sign time and can be executed before the particular database update is made and without simulating the updated state. In this way all overhead due to optimization or execution of compensative actions at run time is avoided. It is argued that, in the recursive case, earlier approaches have not achieved comparable optimization with the same level of generality.
... Proof. cf [4]. For illustrating the notations introduced above, consider the following example of a stratifiable deductive database D = F, RR: ...
Conference Paper
Full-text available
We reconsider query evaluation in stratifiable deductive databases using Magic Sets. On the basis of the soft stratification approach, a new solution to the problem of optimizing existential queries in a set-oriented database language like Datalog is presented. To this end, the query answering process is optimized in such a way that after the generation of one appropriate answer fact with respect to a (derived) existential query, the redundant computations of alternative answer facts are avoided. The same technique can be employed for avoiding the generation of subsumed answers and sub-queries as well. It is shown that in presence of recursion or stratified negation this may considerably reduce the total number of facts generated.
Article
Full-text available
Sentences in first-order predicate logic can be usefully interpreted as programs. In this paper the operational and fixpoint semantics of predicate logic programs are defined, and the connections with the proof theory and model theory of logic are investigated. It is concluded that operational semantics is a part of proof theory and that fixpoint semantics is a special case of model-theoretic semantics.
Conference Paper
Query optimizers often limit the search space for join orderings, for example by excluding Cartesian products in subplans or by restricting plan trees to left-deep vines. Such exclusions are widely assumed to reduce optimization effort while minimally affecting plan quality. However, we show that searching the complete space of plans is more affordable than has been previously recognized, and that the common exclusions may be of little benefit.We start by presenting a Cartesian product optimizer that requires at most a few seconds of workstation time to search the space of bushy plans for products of up to 15 relations. Building on this result, we present a join-order optimizer that achieves a similar level of performance, and retains the ability to include Cartesian products in subplans wherever appropriate. The main contribution of the paper is in fully separating join-order enumeration from predicate analysis, and in showing that the former problem in particular can be solved swiftly by novel implementation techniques. A secondary contribution is to initiate a systematic approach to the benchmarking of join-order optimization, which we apply to the evaluation of our method.
Article
The study of negation in logic programming has been the topic of substantial research activity during the past several years, starting with the negation as failure semantics in Clark (1978), and Apt and van Emden (1982). More recently, a major direction of research has focused on the class of stratified logic programs, in which no predicate is defined recursively in terms of its own negation and which can be given natural semantics in terms of iterated fixpoints. Stratified logic programs were introduced and studied first by Chandra and Hare1 (1985), but soon attracted the interest of researchers from both database theory and artificial intelligence. Recent research work on stratified logic programs and their generalizations includes the papers by Apt, Blair, and Walker (1988), Van Gelder (1986) Lifschitz (1988), Przymusinski (1988), Apt and Pugin (1987) and others. At the same time, stratified logic programs became the choice for the treatment of negation in the NAIL ! system developed at Stanford University by Ullman and his co-workers (cf. Morris
Conference Paper
For a deductive database we present an algorithm to efficiently compute the changes in virtual predicates induced by updates. We first define different classes of potential changes introduced by updates. These definitions are expressed as rules, and merged into the rules defining the database views. This enables the system to determine changes induced by an update with minimum redundancy. Moreover the evaluation of the merged rules mirror the evaluation of the rules defining the views: as a result no new evaluation machinery is needed, and any optimizations applied to the rules defining the views are inherited by the merged rules. The method is introduced by giving a detailed analysis of the difference between two states. We describe a mechanism compiling the original rules into a format amenable to a standard query evaluator. The algorithm is applied to the integrity checking problem. The integrity constraints are boolean views, defined by rules, and their validity after an update is checked by computing the induced changes on predicates defined by these rules.
Chapter
For applications such as deductive databases employing the Open World Assumption, failed derivations have a lesser importance. In this case, use of the identical equivalences based upon the functional semantics [P] and the logical consequences of P allows the application of two different and powerful tools to reason about programs. In particular, these equivalences seem ideal for discussing the deductive structure of such deductive databases, independent of any particular state of the database of facts. When negation-as-failure is used in evaluating queries, the equivalence of completed programs is more appropriate. This equivalence is only slightly stronger than (high level) operational equivalence and the well-developed formalism of logic is available to facilitate reasoning about programs.
Chapter
In this paper a theoretical framework for efficiently checking the consistency of deductive databases is provided and proven to be correct. Our method is based on focussing on the relevant parts of the database by reasoning forwards from the updates of a transaction, and using this knowledge about real or just possible implicit updates for simplifying the consistency constraints in question. Opposite to the algorithms by Kowalski/Sadri and Lloyd/Topor, we are neither committed to determine the exact set of implicit updates nor to determine a fairly large superset of it by only considering the head literals of deductive rule clauses. Rather, our algorithm unifies these two approaches by allowing to choose any of the above or even intermediate strategies for any step of reasoning forwards. This flexibility renders possible the integration of statistical data and knowledge about access paths into the checking process. Second, deductive rules are organized into a graph to avoid searching for applicable rules in the proof procedure. This graph resembles a connection graph, however, a new method of interpreting it avoids the introduction of new clauses and links.