An Extended Magic Sets Strategy for a Rule. Paulo J Azevedo. Departamento de Informatica Braga, Portugal.

Transcription

1 An Extended Magic Sets Strategy for a Rule language with Updates and Transactions Paulo J Azevedo Departamento de Informatica Universidade do Minho, Campus de Gualtar 4700 Braga, Portugal pja@diuminhopt Danilo Montesi y Knowldge Systems Group Department of Computer Systems and Telematics The University of Trondheim N-7034, Trondheim, Norway danilo@idtunitno Abstract Deductive databases with updates in rule bodies do not allow to use bottom-up execution model This is due to the introduction of control in rule bodies induced by update sequences However, bottom-up strategies are very important due to the set oriented query-answering process of database systems In [7] an extended rule language was proposed that allows to accommodate updates and support transactions while avoiding the above drawback In this paper we present an extension of the Magic Sets transformation and the Semi-Naive strategy for eciently evaluating the extended rule language This new transformation enables the collection of updates during the query-answering process performed by the Semi-Naive strategy The collected updates are executed as transactions at the end of the evaluation, provided that they are consistent This strategy turns out to be as ecient as in the case without updates The use of trie structures [12] to store the collected updates justies this claim Trie structures enable the operations of inserting a new update, checking an update and consistency checking among updates to be performed in the same pass These collapsed operations have a linear cost with respect to the number of collected updates The work of this author has been supported by Junta Nacional de Investigac~ao Cientca e Tecnologica - Programa, PRAXIS XXI, grant number BD/2832/94 y The work of this author has been supported by the ERCIM fellowship Information and Knowledge Systems

2 1 Introduction Database languages have been deeply inuenced by the introduction of logic languages Indeed, the database community has realized that rule languages are the most natural tool for uniformly modeling several database concepts such as: data, views, constraints and queries Due to the nature of data, the update language should be integrated with the query language In many cases, data to be modied are determined by issuing queries Moreover, updates should be collected into atomic execution units which are executed in a all-or-nothing style, that is, as transactions Transactions are a crucial functionality, since data integrity is a major requirement for database applications In [7] a language based on a new approach to smoothly integrate a declarative query language with an update language was introduced Such integration is achieved by taking into account the transactional behavior The resulting language, called U-Datalog, provides both update and query capabilities and has a formal semantics U-Datalog databases are based on a two phases computation In the rst phase updates are collected and their consistency is checked In the second phase the updates are executed together modeling a transactional behavior The formal semantics is given in [6], while two optimization techniques are presented in [3, 5] and an object oriented extension was proposed in [4] In this paper we describe an extended Magic Sets strategy for the ecient evaluation of U-Datalog databases The strategy is based on the Semi-Naive procedure [8] combined with a renement of the Magic Sets transformation [9] which handles the processes of queryanswering and the collection of updates, characteristic of U-Datalog Collecting an update is computationally equivalent to deriving a new tuple Checking consistency among updates is embedded into the collection process These two characteristics are obtained by inserting updates into tries data-structures (introduced in [12]), as they are collected during the evaluation process The remainder of this paper is organized as follows Section 2 introduces the rule language and some examples Section 3 presents the bottom-up strategy based on the Extended Magic Sets for U-Datalog Finally, Section 4 concludes the work 2 U-Datalog A Datalog program consists of a set of base relations (EDB) and a set of rules (IDB) Many extensions to Datalog have been proposed to express updates (see [1] for a survey) In the following we summarize our approach based on non-immediate update semantics Update- Datalog (U-Datalog) is a rule language which allows declarative specication of updates in program rules The execution model of U-Datalog consist of two phases, the marking phase and the update phase [13] The rst phase collects the updates found during the evaluation process without, however, executing them During the update phase they are executed altogether only if they are consistent If the set of updates is not consistent, the query is aborted and no update in the set is performed The notion of consistency is an important one, in that it prevents a set of updates containing both an insertion and a deletion of the same fact to be executed By contrast in DLP and LDL, updates are executed as soon as they are evaluated (in sequence), that is, they are executed as side eect of the derivation process In this section we recall some basic notions on the syntax and the semantics of U- Datalog, which are dened by means of an instance of constraint logic programming schema (CLP) [10] called CLP (AD) [7]

3 Updates in U-Datalog are in rule bodies Updates to base relations are expressed as a set of special atoms prexed by or?, denoting insertion and deletion The relations can be either extensional or intensional The current version of our language allows only updates to extensional relations Denition 21 (Extensional database) The EDB is a set of ground (ie, without variables) relations A state EDB 2 S is a (possibly empty) set of ground relations S denotes the set of all possible database states In the following we denote with EDB i ; i = 1; : : :; n the possible extensional databases Denition 22 (Intensional database) The intensional database IDB is a set of rules of the form H U 1 ; : : :; U s ; B 1 ; : : :; B t : where B 1 ; : : :; B t (as in Datalog) is the query part and U 1 ; : : :; U s is the update part update and query parts cannot be both empty The The intuitive meaning of a rule is: \if B 1 ; : : :; B t is true and the updates U 1 ; : : :; U s are consistent, then H is true" The notion of consistency is given informally Intuitively, the updates p(x);?p(x), ie complementary updates, are not consistent The updates p(y );?p(x) could be consistent if the related bindings were for example X=tom; Y =bob By contrast with the bindings X=tom; Y =tom, p(y );?p(x) are not consistent We will consider only intensional databases that are range-restricted That is, the variables of the head and of the updates in a rule appear in the query part of the rule itself Denition 23 (Query) A query (or simple query) is a rule with no head of the form U 1 ; : : :; U s ; B 1 ; : : :; B t where B 0 i s and U 0 j s are as in Denition 22 and B 1; : : :; B t cannot be empty The condition that B 1 ; : : :; B t cannot be empty is due to the fact that the update phase must always follow the marking phase Therefore, before updating a database, it must be queried, by means of a query in order to compute the bindings for the variables of the language We refer to a query also as a simple transaction, to stress the transactional behavior of a query Following the tradition in the examples we always prex a query with the symbol `?' A complex transaction T is a sequence of transaction T 1 ; : : :; T n In the following the words query, goal, update query, and transaction are synonymous Denition 24 (U-Datalog) An U-Datalog program (or database) DB = IDB [ EDB consists of the extensional database EDB and of the intensional database IDB The following examples provide the intended semantics of an U-Datalog database Example 21 Consider EDB i = q(b) and IDB = p(x)?q(x); q(x): r(x) s(x) t(x); p(x): t(x):

4 The user transaction T 1 =?r(x) evaluated in EDB i [ IDB computes the binding X=b and collects the updates?q(b); t(b) Note that such updates form a transaction Informally the new extensional database EDB i1 = t(b) is the result of the application of these updates to EDB i The transaction T 2 =?s(x) evaluated in EDB i1 [IDB computes the binding X=b and does not compute any update, thus the new extensional database is still EDB i1 The transaction T 3 =? q(x); s(x) evaluated in EDB i1 [ IDB computes the binding X=b and collect the update q(b), thus the new extensional database is EDB i2 = t(b); q(b) The transaction T 4 =? q(x); p(x) computes the binding X=b, and collects the updates q(b);?q(b) They are not consistent and therefore T 4 aborts The semantics of an U-Datalog program is given in three steps The rst step semantics models the marking phase The second step provides the transactional behavior, modeling the update phase; the updates collected by the marking phase are executed with a transactional mechanism, ie with an all-or-nothing style If the collected updates are consistent, the new database state is computed and the transaction commits, otherwise the transaction aborts Note that in such a way we model a transactional behavior Transactions are evaluated by the same mechanisms as queries The third step semantics is related to complex transactions, formed from simple ones Obviously, the abort of a simple transaction in a sequence results in the abort of the entire sequence The formal semantics is in [6] Finally note that due to the special range-restricted condition, the collected updates are always ground 3 A Bottom-up Strategy for evaluating U-Datalog Several evaluation strategies have been proposed for rule languages [2] We will extend the Magic Sets transformation introduced in [9] in conjunction with the Semi-Naive strategy [8] to provide an ecient strategy for U-Datalog language This choice lead to an ecient query evaluation free of redundant computations The basic idea is to compute both the bindings for the query and to collect updates in the same evaluation process We will transform the original rules with updates of the intensional part of the database using the Magic Sets rewriting The rules are transformed in such a way that in the same step of the Semi-Naive strategy both new tuples as well as updates can be derived Finally a further step is added to incrementally check the consistency among updates as soon as a new update is derived 31 Transformation for the U-Datalog rules As we have seen in the previous section the basic idea of U-Datalog is: updates, instead of being executed as soon as they are derived, are rst collected and later executed in a allor-nothing style This implements the transaction execution model To store the collected updates we need a special structure which will enable an ecient checking of consistency among them We refer to this structure as the collect structure Our aim is to provide a transformation that enables a derivation of updates in the same way as new tuples are derived in a Semi-Naive evaluation step Consider the following rule of an intensional database p(~x) u 1 (~x 1 ); :::; u m (~x m ); b 1 (~y 1 ); :::; b n (~y n )

5 Applying the Magic Sets transformation the rule becomes: p(~x) u 1 (~x 1 ); :::; u m (~x m ); b 1 (~y 1 ); :::; b n (~y n ); mag p(~x) Note that, as mentioned in [9], we do not apply neither adornments nor derive magic rules from the update literals since they are not part of the IDB database The intensional part of the database requires the magic sets transformation to obtain a goal-oriented evaluation, deriving only relevant tuples in relation to a query The intuitive reading of the above rule is: if b 1 (~y 1 ); :::; b n (~y n ); mag p(~x) are true and u 1 (~x 1 ); :::; u m (~x m ) are consistent then we collect u 1 (~x 1 ); :::; u m (~x m ) and derived p(~x) As described before, our execution model consists of two phases: The marking phase and the update phase To implement the marking phase, where the updates are collected without being executed, the intensional U-Datalog database is transformed and split into the following way: The rule introduced above yields and I) p(~x) b 1 (~y 1 ); :::; b n (~y n ); mag p(~x) II) u 1 (~x 1 ); :::; u m (~x m ) b 1 (~y 1 ); :::; b n (~y n ); mag p(~x) The set of clauses composed of rules type I) also includes the normal magic rules obtained from the magic rewriting For instance, if b j belongs to the IDB then the following magic rule is generated: mag b j (~x) b 1 (~y 1 ); :::; b j?1 (~y j?1 ); mag p(~x) The rule II) is equivalent to the following set of rules: III) u 1 (~x 1 ) b 1 (~y 1 ); :::; b n (~y n ); mag p(~x) u m (~x m ) b 1 (~y 1 ); :::; b n (~y n ); mag p(~x) As we have said, since these rules are range-restricted, only ground updates are derived We recall that range-restriction is the standard restriction in the Magic Sets strategy (also called well-formedness condition in [9]) In this form, rules of type III) yield duplication of work since the same conjunction of literals appears in the body of dierent rules Thus, some \joins" are repeated To avoid this

6 duplication, we will follow the idea introduced in [9] for Supplementary Magic Sets using an additional relation to store the intermediate results associated with the common conjunction of literals Hence, the rules become: IV) extra(~y) b 1 (~y 1 ); :::; b n (~y n ); mag p(~x) u 1 (~x 1 ) u m (~x m ) extra(~y) extra(~y) The Semi-Naive strategy is applied in the standard way to the sets of rules of types I) and IV) ie to the database IDB I) [ IDB IV ) [ EDB From IDB I) [ EDB the semi-naive strategy derives new tuples to answer the initial query whereas from IDB IV ) [ EDB derives the updates The latter corresponds to the marking phase Formally, one has only one Semi-Naive derivation step but in each step both new tuples and updates are derived In summary, the algorithm for the Extended Magic Sets Strategy for U-Datalog is: 1 Apply the magic sets transformation to the rules, as described in [9] This will generate the transformed rules and the magic rules 2 Split the rules according to transformation I) and II) 3 Create rules of type III) for the derivation of updates 4 Create rules type IV) to avoid duplication of work 5 Apply the Semi-Naive Strategy [8] to the database IDB I) [ IDB IV ) [ EDB 6 Execute the updates (modeling a transactional behavior) In step 5, the evaluation process terminates if one of the following two cases holds: inconsistency among the updates is detected In this case the collected updates are not executed and the transaction aborts a xpoint is reached and the updates stored in the trie structures are executed at step 6 In this case the transaction commits Step 1 of the algorithm is the standard application of the Magic Sets transformation The second and third steps create the rules that enables the derivation of updates by the Semi-Naive strategy The fourth step avoids the possible recomputation obtained from the duplication of the same conjunction of literals in the body of the rules type III) Note that step 6 performs the execution phase Step 5 is where the real evaluation occurs and where the bindings and updates are derived This step also includes the consistency checking process that will be introduced in the next section

7 p/2 a/1 b/1 a/1 a/1 b/1 - Figure 1: The Trie structure after the collection of p(a; a),?p(b; a) and p(b; b) 32 Checking update consistency As we have seen, the collected updates must be consistent There are two complementary ways to check consistency: incrementally whenever a new update is collected or at the end when all the updates are available The former approach detects an inconsistency as early as possible and consequently is more ecient if complementary updates are derived during evaluation The latter detects at the end of the query-answer process these cases and potentially performs redundant computations For this reason we will consider the former approach Note that, as referred before, by considering only range-restricted rules we guarantee groundness among updates Thus, checking for groundness is substituted by checking for range-restrictness among the rules of the database This process is performed at compile-time In the sequel we will substantiate the advantages of our approach by proposing an ecient procedure to check consistency This procedure contributes to an overall ecient evaluation of U-Datalog databases In [12] a trie-like structure was used to eciently store answers to a call in tabulated topdown proof procedure The major advantages of these structures is that it gives a collapsed check/insert operation Thus, checking the existence of an answer and inserting a new answer requires only one visit to the structure where the answers are stored Since all updates must be ground, following the conditions of range-restriction, checking consistency can be reduced to the referred collapsed operation This reduction is obtained by checking for the complement of an update atom using the same techniques that are performed for checking/inserting new answers in a tabulated top-down proof procedure We use tries to store updates as they are derived during the Semi-Naive evaluation These are our collect structures The symbol that indicates the type of update is included at the end of the path dening the atom This allows the collapsing of the following operations: inserting a new update, checking duplicates and checking for complementer updates in the trie structure ie consistency checking For instance, if we derive p(a) and?p(a) already exists in the trie structure then the operations of inserting, checking duplication of the same update and consistency are performed with only one term traversal (atom examination) Figure 1 describes the state of the trie after the updates p(a; a);?p(b; a) and p(b; b) had been inserted If after these three updates?p(a; a) is inserted inconsistency is detected since the trie is followed along the path that denes p(a; a) nding at the end the terminal symbol Figure 2 illustrates this situation

8 a/1 a/1 - INCONSISTENCY!! p/2 new update previous updates b/1 a/1 b/1 - Figure 2: Detecting an inconsistency 33 Examples Consider the Example 21 where the following database was introduced with EDB 1 = q(b) and IDB = p(x)?q(x); q(x): r(x) s(x) t(x); p(x): t(x): and the user transaction T 1 =? q(a); r(b) evaluated in EDB 1 [ IDB Applying step 1) of the Extended Magic Sets strategy algorithm, we obtain: IDB mag = p(x)?q(x); q(x); mag p(x): r(x) t(x); p(x); mag r(x): s(x) t(x); mag s(x): mag p(x) mag r(x): mag r(b): Step 2 of the algorithm yields rules of type I) and III) which are: I) mag r(b): p(x) q(x); mag p(x) mag p(x) mag r(x): r(x) p(x); mag r(x) s(x) t(x); mag s(x) and III)?q(X) t(x) q(x); mag p(x) p(x); mag r(x)

9 a/1 q/1 b/1 t/1 b/1 - Figure 3: The structures for storing the collected updates q/1 b/1 - Inconsistency!! Figure 4: Detecting inconsistency with q(b) and?q(b) We do not apply step 3 since no duplication of literals exists in the body of the rules type III) The Semi-Naive evaluation trace in this database for the T 1 transaction, including the collected updates, is: I 1 = fmag r(b)g, C 1 = fq(a)g I 2 = I 1 [ fmag p(b)g, C 2 = C 1 I 3 = I 2 [ fp(b)g, C 3 = C 2 [ f?q(b)g I 4 = I 3 [ fr(b)g, C 4 = C 3 [ ft(b)g I i represents the derived facts in each iteration i and C i the collected updates in iteration i Note that each collected update is inserted in the correspondent trie The trie structures where the collected updates are stored are pictorially represented in Figure 3 In this example the transaction commits, following the second case in step 5 of the algorithm Consider another user transaction that is T 2 =? q(b); p(b) Evaluated in EDB 1 [ IDB yields: I 1 = fmag p(b)g I 2 = I 1 [ fp(b)g C 1 = fq(b)g C 2 = C 1 [ f?q(b)g In this example, evaluation terminates due to the rst case in step 5 of the algorithm Thus, at iteration I 2 inconsistency is detected and consequently the transaction is aborted according to the informal semantics of U-Datalog Figure 4 shows the trie mechanism when it detects inconsistency between?q(b) and q(b) 4 Conclusions and future work We have seen an extended Magic Sets strategy for U-Datalog that uses a familiar transformation technique This strategy has a computational cost that is higher then the traditional

10 one for Datalog The additional cost is due to the collection of updates The price paid in this collection is reduced to the price of inserting/checking updates into the trie structure Checking consistency among updates is negligible because it is embedded into the collapsed operations of checking and inserting new updates Since U-Datalog has been extended with the object oriented paradigm [4] and integrity constraints [11] the above strategy is promising also for these cases References [1] S Abiteboul Updates, a New Frontier In M Gyssens, JParedaens, and D Van Gucht, editors, ProcSecond Int'l Conf on Database Theory, Vol 326 of Lecture Notes in Computer Science, pages 1{18, Springer-Verlag, Berlin, 1988 [2] F Bancilhon and R Ramakrishnan An Amateur's Introduction to Recursive Query Processing Strategies In Proc Int'l Conf ACM on Management of Data, pages 16{52, 1986 [3] E Bertino, B Catania, G Guerrini and D Montesi Static Analysis of Transactional Intensional Databases Proc Second ICLP-Workshop on Deductive Databases and Logic Programming of International Conference on Logic Programming, pages 57-73, Genova, 1994 [4] E Bertino, G Guerrini and D Montesi Deductive Object Databases, Proc Eighth European Conference on Object Oriented Programming, Vol 821 of Lecture Notes in Computer Science, pages , Springer -Verlag, Bologna, 1994 [5] E Bertino, B Catania, G Guerrini, and D Montesi Transaction Optimization in Rule Databases 1993 Fourth IEEE Research Issues in Data Engineering: Active Database Systems (RIDE-ADS'94), IEEE Computer Society Press, pages 137{145, 1994 [6] E Bertino, M Martelli, and D Montesi An Incremental Semantics for CLP(AD) In A Marchetti, Spaccamela, P Mentrasti, and M Venturini Zilli, editors, Proc Fourth Italian Conference on Theoretical Computer Science, pages 53{67 World Scientic, 1992 [7] E Bertino, M Martelli, and D Montesi Modeling Database Updates with Constraint Logic Programming In U W Lipeck and B Thalheim, editors, Proc Fourth Int'l Work on Foundations of Models and Languages for Data and Objects, pages 120{132, 1992 [8] I Balbin, K Ramamohanarao A Generalization of the Dierential Approach to Recursive Query Evaluation in Journal of Logic Programming, Vol 4, pag , 1987 [9] C Beeri, R Ramakrishnan On the Power of Magic in Journal of Logic Programming, pag , Vol 10, 1991 [10] J Jaar and J-L Lassez Constraint Logic Programming In Proc Fourteenth Annual ACM Symp on Principles of Programming Languages, pages 111{119 ACM, New York, USA, 1987 [11] D Montesi and F Turini Knowledge Evolution in Deductive Databases Proc International Symposium on Knowledge Retrieval, Use and Storage for Eciency, Santa Cruz, 1995, To appear [12] P Rao, I Ramakrishnan, T Swift, DS Warren Dynamic Argument Reduction for the In- Memory Data Queries in Proc Second ICLP-Workshop on Deductive Databases and Logic Programming of International Conference on Logic Programming, pag , Genova, 1994 [13] M Zloof Query-by-example: a Data Base Language IBM Systems Journal, 16(4):324{343, 1977