Results 1  10
of
11
FirstOrder Incremental Evaluation of Datalog Queries
 Annals of Mathematics and Artificial Intelligence
, 1993
"... 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 stat ..."
Abstract

Cited by 52 (18 self)
 Add to MetaCart
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 firstorder queries to compute the differences, and call this process "firstorder incremental query evaluation." After formalizing the notion of firstorder incremental query evaluation, we give an algorithm that constructs, for each regular chain query (including transitive closure as a special case), a nonrecursive 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 socalled cartesianclosed increment property, and to the case of unbound...
Computing Complete Answers to Queries in the Presence of Limited Access Patterns
 Journal of VLDB
, 1999
"... In data applications such as information integration, there can be limited access patterns to relations, i.e., binding patterns require values to be specified for certain attributes in order to retrieve data from a relation. As a consequence, we cannot retrieve all tuples from these relations. In th ..."
Abstract

Cited by 33 (3 self)
 Add to MetaCart
In data applications such as information integration, there can be limited access patterns to relations, i.e., binding patterns require values to be specified for certain attributes in order to retrieve data from a relation. As a consequence, we cannot retrieve all tuples from these relations. In this article we study the problem of computing the complete answer to a query, i.e., the answer that could be computed if all the tuples could be retrieved. A query is stable if for any instance of the relations in the query, its complete answer can be computed using the access patterns permitted by the relations. We study the problem of testing stability of various classes of queries, including conjunctive queries, unions of conjunctive queries, and conjunctive queries with arithmetic comparisons.
Undecidable Boundedness Problems for Datalog Programs
 JOURNAL OF LOGIC PROGRAMMING
, 1995
"... A given Datalog program is bounded if its depth of recursion is independent of the input database. Deciding boundedness is a basic task for the analysis of database logic programs. The undecidability of Datalog boundedness was first demonstrated by Gaifman et al. We introduce new techniques for p ..."
Abstract

Cited by 24 (0 self)
 Add to MetaCart
A given Datalog program is bounded if its depth of recursion is independent of the input database. Deciding boundedness is a basic task for the analysis of database logic programs. The undecidability of Datalog boundedness was first demonstrated by Gaifman et al. We introduce new techniques for proving the undecidability of (various kinds of) boundedness, which allow us to considerably strengthen the results of Gaifman et al. In particular: (1) We use a new generic reduction technique to show that program boundedness is undecidable for arity 2 predicates, even with linear rules. (2) We use the mortality problem of Turing machines to show that uniform boundedness is undecidable for arity 3 predicates and for arity 1 predicates when is also allowed. (3) By encoding all possible transitions of a twocounter machine in a single rule, we show that program (resp., predicate) boundedness is undecidable for two linear rules (resp., one rule and a projection) and one initialization rule, where all predicates have small arities (6 or 7).
Nonrecursive Incremental Evaluation of Datalog Queries
 Annals of Mathematics and Artificial Intelligence
, 1995
"... 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 stat ..."
Abstract

Cited by 22 (10 self)
 Add to MetaCart
(Show Context)
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 havin...
Necessary and sufficient conditions to linearize doubly recursive programs in logic databases
 ACM TRANS. DATABASE SYST
, 1990
"... Linearization of nonlinear recursive programs is an important issue in logic databases for both practical and theoretical reasons. If a nonlinear recursive program can be transformed into an equivalent linear recursive program, then it may be computed more efficiently than when the transformation is ..."
Abstract

Cited by 10 (0 self)
 Add to MetaCart
Linearization of nonlinear recursive programs is an important issue in logic databases for both practical and theoretical reasons. If a nonlinear recursive program can be transformed into an equivalent linear recursive program, then it may be computed more efficiently than when the transformation is not possible. We provide a set of necessary and sufficient conditions for a simple doubly recursive program to be equivalent to a simple linear recursive program. The necessary and sufficient conditions can be verified effectively.
Structural Query Optimization  A Uniform Framework For Semantic Query Optimization In Deductive Databases
, 1991
"... this paper we propose the factoring technique as a general technique which can detect opportunities for making the recursion less "intensive". For example, this technique can detect that certain subgoals need only be examined a bounded number of times in certain subtrees of the proof trees ..."
Abstract

Cited by 8 (1 self)
 Add to MetaCart
this paper we propose the factoring technique as a general technique which can detect opportunities for making the recursion less "intensive". For example, this technique can detect that certain subgoals need only be examined a bounded number of times in certain subtrees of the proof trees of the query predicate. More precisely, given a program and a query predicate (the recursive predicate), the factoring technique can determine when it is possible to limit the number of occurrences of a subgoal in selected subtrees of the proof trees of the query predicate. We call this property of subgoals proof tree removability. Our technique can also exploit the knowledge about proof tree removability in transforming a program into an equivalent program such that the proof trees constructed using the transformed program always contain a limited number of occurrences of the subgoal in selected subtrees. Proof tree removability is thus a notion that generalizes the notion of "recursively redundant" introduced by Naughton [N1, N2] in the sense that a subgoal a need not be recursively redundant w.r.t. a predicate and yet its repeated occurrences in certain subtrees of the query predicate may well be redundant. (See Section 9 for examples.) Factoring is one type of proof tree transformation, (e.g. see [RSUV, Sar]), only that it is achieved at the level of rules. In principle it may be possible to start with Naughton and others' characterization of recursively redundant predicates and then try to generalize the conditions to a larger class of rules to capture the notion of "subtree redundancy of predicates" above. Such a generalization is not at all obvious and we find it convenient to start with simple syntactic criteria for predicates to be "factored" out of linear sirups and then ...
On Transformations into Linear Database Logic Programs
 Perspectives of Systems Informatics, 2nd International Andrei Ershov Memorial Conference, Akademgorodik
, 1996
"... Abstract. We consider the problem of transformations of logic programs without function symbols (database logic programs) into a special subclass, namely linear logic programs. Linear logic programs are dened to be the programs whose rules have at most one intentional atom in their bodies. a) We inv ..."
Abstract

Cited by 6 (5 self)
 Add to MetaCart
Abstract. We consider the problem of transformations of logic programs without function symbols (database logic programs) into a special subclass, namely linear logic programs. Linear logic programs are dened to be the programs whose rules have at most one intentional atom in their bodies. a) We investigate linearizability of several syntactically de ned subclasses of programs and present both positive and negative results (i.e. demonstrate programs that cannot be transformed into a linear program by any transformation technique), and b) We develop an algorithm which transforms any program in a speci c subclass namely the piecewise logic programs into a linear logic program.
Increment boundedness and nonrecursive incremental evaluation of datalog queries
 In LNCS 893: Proceedings of 5th International Conference on Database Theory
, 1995
"... Abstract. Given a recursive (datalog) query, the nonrecursive incremental evaluation approach uses nonrecursive (datalog) programs to compute the difference of the answers to the query against successive databases between updates. The mechanism used in this approach is called a “FirstOrder Incremen ..."
Abstract

Cited by 5 (3 self)
 Add to MetaCart
(Show Context)
Abstract. Given a recursive (datalog) query, the nonrecursive incremental evaluation approach uses nonrecursive (datalog) programs to compute the difference of the answers to the query against successive databases between updates. The mechanism used in this approach is called a “FirstOrder Incremental Evaluation System ” (FOIES). We show that for two large classes of datalog queries, called “generalized (weakly) regular queries”, FOIES always exist. We also define “increment boundedness ” and its variations, which generalize boundedness. Increment bounded queries are shown to have FOIES of certain forms. We also relate increment boundedness to structural recursion, which was proposed for bulk data types. We characterize increment boundednessusing the “insertion idempotency”, “insertion commutativity”, and “determinism ” properties of structural recursion. Finally, we show that the increment boundedness notions are undecidable and a decidable sufficient condition is given. 1
Computing Complete Answers to Queries with Binding Restrictions
, 1999
"... We consider the problem of computing the complete answer to a query when there is limited access to relations, i.e., when binding patterns require values to be specified for certain attributes in order to retrieve data from a relation. This problem is common in informationintegration systems, wh ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
We consider the problem of computing the complete answer to a query when there is limited access to relations, i.e., when binding patterns require values to be specified for certain attributes in order to retrieve data from a relation. This problem is common in informationintegration systems, where heterogeneous sources have diverse and limited query capabilities. A query is stable if for any instance of the relations mentioned in the query, the complete answer to the query can be computed, using only the binding patterns permitted for queries at the various sources. We first study conjunctive queries, and we show that a conjunctive query is stable if and only if its minimal equivalent query Qm has an order of all the subgoals in Qm , such that each subgoal in the order can be queried with a legal binding pattern. We propose two algorithms for testing stability of conjunctive queries, and we prove this problem is NPhard. For a nonstable conjunctive query, whether its comp...
Homomorphic Tree Embeddings and Their Applications to Recursive Program Optimization
, 1993
"... This paper is concerned with the problems of stage preserving linearization and 1boundedness for ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
This paper is concerned with the problems of stage preserving linearization and 1boundedness for