Results 1  10
of
11
Magic Templates: A Spellbinding Approach to Logic Programs
 Journal of Logic Programming
, 1988
"... We consider a bottomup queryevaluation scheme in which facts of relations are allowed to have nonground terms. The Magic Sets queryrewriting technique is generalized to allow arguments of predicates to be treated as bound even though the rules do not provide ground bindings for those arguments. I ..."
Abstract

Cited by 133 (14 self)
 Add to MetaCart
We consider a bottomup queryevaluation scheme in which facts of relations are allowed to have nonground terms. The Magic Sets queryrewriting technique is generalized to allow arguments of predicates to be treated as bound even though the rules do not provide ground bindings for those arguments. In particular, we regard as "bound" any argument containing a function symbol or a variable that appears more than once in the argument list. Generalized "magic " predicates are thus defined to compute the set of all goals reached in a topdown exploration of the rules, starting from a given query goal; these goals are not facts of constants as in previous versions of the Magic Sets algorithm. The magic predicates are then used to restrict a bottomup evaluation of the rules so that there are no redundant actions; that is, every step of the bottomup computation must be performed by any algorithm that uses the same sideways information passing strategy (sips). The price paid, compared to prev...
The LDL System Prototype
 IEEE Transactions on Knowledge and Data Engineering
, 1990
"... The LDL system provides a declarative logicbased language and integrates relational database and logic programming technologies so as to support advanced data and knowledgebased applications. This paper contains a comprehensive overview of the system and contains a description of the LDL language ..."
Abstract

Cited by 82 (2 self)
 Add to MetaCart
The LDL system provides a declarative logicbased language and integrates relational database and logic programming technologies so as to support advanced data and knowledgebased applications. This paper contains a comprehensive overview of the system and contains a description of the LDL language and the compilation techniques employed to translate LDL queries into target queries on the stored data. The paper further contains a description of the architecture and runtime environment of the system and the optimization techniques employed in order to improve the performance and assure the safety of the compiled queries. The paper concludes with an account of the experience gained so far with the system, and discusses application areas where the LDL approach appears to be particularly effective.
Foundations of secure deductive databases
 IEEE Transactions on Knowledge and Data Engineering
, 1995
"... AbstractIn this paper, we develop a formal logical foundation for secure deductive databases. This logical foundation is based on an extended logic involving several modal operators. We develop two models of interaction between the user and the datathe space of admissible responses (e.g., yes, no, ..."
Abstract

Cited by 42 (5 self)
 Add to MetaCart
(Show Context)
AbstractIn this paper, we develop a formal logical foundation for secure deductive databases. This logical foundation is based on an extended logic involving several modal operators. We develop two models of interaction between the user and the datathe space of admissible responses (e.g., yes, no, don’t know, rehse to tell you), and the initial body of knowledge the user may possess. base called “yesno ” dialogs, and “yesnodon’t know ” dialogs. Both dialog frameworks allow the database to lie to the user. We develop an algorithm for answering queries using yesno dialogs and prove that secure query processing using yesno dialogs is NPcomplete. Consequently, the degree of computational intractability of query processing with yesno dialogs is no worse than In this paper, we consider the problem of security in deductive databases. A deductive database is a kite set of formulas of
The Generalized Counting Method for Recursive Logic Queries
"... This paper treats the problem of implementing efficiently recursive Horn Clauses queries, including those with function symbols. In particular, the situation is studied where the initial bindings of the arguments in the recursire query goal can be used in the topdown (as in backward chaining) execu ..."
Abstract

Cited by 23 (5 self)
 Add to MetaCart
This paper treats the problem of implementing efficiently recursive Horn Clauses queries, including those with function symbols. In particular, the situation is studied where the initial bindings of the arguments in the recursire query goal can be used in the topdown (as in backward chaining) execution phase to improve the efficiency and, often, to guarantee the termination, of the forward chaining execution phase that implements the fixpoint computation for the recursire query. A general method is given for solving these queries; the method performs an analysis of the binding passing behavior of the query, and then reschedules the overall execution as two fixpoint computations derived as results of this analysis. The first such computation emulates the propagation of bindings in the topdown phase; the second generates the desired answer by proving the goals left unsolved during the previous step. Finally, sufficient conditions for safety are derived, to ensure that the fixpoint computations are completed in a finite number of steps.
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.
Evaluating Recursive Queries in Distributed Databases
 IEEE Transactions on Knowledge and Data Engineering
, 1993
"... In this paper, we study the execution of logic queries in a distributed database environment. We assume that each local database system can execute logic queries, and we design methods for the efficient execution of queries requiring data from multiple sites. Conventional optimization strategies ..."
Abstract

Cited by 10 (2 self)
 Add to MetaCart
In this paper, we study the execution of logic queries in a distributed database environment. We assume that each local database system can execute logic queries, and we design methods for the efficient execution of queries requiring data from multiple sites. Conventional optimization strategies which are wellknown in the field of distributed databases, such as the early evaluation of selection conditions and the clustering of processing to manipulate and exchange large sets of tuples, are redefined in view of the additional difficulties due to logic queries, in particular to recursive rules. In order to allow efficient processing of these logic queries we present several program transformation techniques which attempt to minimize distribution costs based on the idea of semijoins and generalized semijoins in conventional databases. Although local computation of semijoins is not possible for the general case, we indicate classes of programs for which these transformation...
Grammars And Automata To Optimize Chain Logic Queries
, 1999
"... The critical problem of finding efficient implementations for recursive queries with bound arguments offers many open challenges of practical and theoretical import. In particular, we need methods that are effective for the general case, such as nonlinear programs, as well as for specialized cases, ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
The critical problem of finding efficient implementations for recursive queries with bound arguments offers many open challenges of practical and theoretical import. In particular, we need methods that are effective for the general case, such as nonlinear programs, as well as for specialized cases, such as leftrecursive linear programs. In this paper, we propose a novel approach that solves this problem for chain queries, i.e., for queries where bindings are propagated from arguments in the head to arguments in the tail of the rules, in a chainlike fashion. The method, called pushdown method, is based on the fact that each chain query can be associated with a contextfree language, and that a pushdown automaton recognizing this language can be emulated by rewriting the query as a particular factorized leftlinear program. The proposed method generalizes and unifies previous techniques such as the `counting' and `right, left, mixedlinear' methods. It succeeds in reducing many nonlinear programs to queryequivalent linear ones.
On the BottomUp Evaluation of Recursive Queries
"... In this article, we present an optimal bottomup evaluation method for handling both linear and nonlinear recursion. Based on the wellknown magicset method. we develop a technique: labeling to record the cyclic paths during the execution of the first phase of the magicset method and suspending th ..."
Abstract
 Add to MetaCart
(Show Context)
In this article, we present an optimal bottomup evaluation method for handling both linear and nonlinear recursion. Based on the wellknown magicset method. we develop a technique: labeling to record the cyclic paths during the execution of the first phase of the magicset method and suspending the computation for the cyclic data in the second phase to avoid the redundant evaluation. Then we postpone this computation to an iteration process (the third phase) which evaluates the remaining answers only along each cyclic path. In this way. we can guarantee the completeness. In addition. for a large class of programs we further optimize our method by elaborating the iteration process and generating most answers for each cyclic path directly from the intermediate results instead of evaluating them by performing algebraic operations (after some of the answers for the first cyclic path are produced). Because the cost of generating an answer is much less than that of evaluating an answer, this optimization is significant. © 1996 John Wiley & Sons. Inc. I.
0 ptimization of Li.near P rograms Using Counting Methods
"... We present a general solution to the problem of optimized execution of logic progmms containing linear recursive rules. Our solution is based on extension8 of the classical counting method, which ia known to be eficient but of limited applicability. In fact, the range of applicability of the countin ..."
Abstract
 Add to MetaCart
(Show Context)
We present a general solution to the problem of optimized execution of logic progmms containing linear recursive rules. Our solution is based on extension8 of the classical counting method, which ia known to be eficient but of limited applicability. In fact, the range of applicability of the counting method, and its variants proposed by previous researchers, sufier from one or more of the following limitationa: the method can be applied only when (I) the adorned program contains one recursive rule, (2) the ‘left part ’ and the ‘right part ’ of the recursive rule do not have any common variable and (3) the relation associated with the left part of the recursive rule is ‘acyclic’. In this paper, a simple and unified framework ia presented, where those limitations are removed, and the counting method thua become applicable to all programs with linear rules. This framework abo allows a simple treatment of programs factorizable into segments, which can be computed separately yielding a much faster ezecution. A simple factorization technique based on argument reduction in presented that producea optimizationa similar to those defined in the literature for RLClinear programs (i.e., programs with rightlinear rules, leftlinear rules and a combination of the two). 1