Project-Join-Repair: An Approach to Consistent Query Answering Under Functional Dependencies

Transcription

1 Project-Join-Repair: An Approach to Consistent Query Answering Under Functional Dependencies Jef Wijsen Université de Mons-Hainaut, Mons, Belgium, WWW home page: Abstract. Consistent query answering is the term commonly used for the problem of answering queries on databases that violate certain integrity constraints. We address this problem for universal relations that are inconsistent with respect to a set of functional dependencies. In order to obtain more meaningful repairs, we apply a project-join dependency prior to repairing by tuple deletion. A positive result is that the additional project-join can yield tractability of consistent query answering. 1 Motivation In the Internet age, data are ubiquitous and cannot be expected to be globally consistent. The database systems in which such data are stored and queried, should be capable of handling this inconsistency phenomenon. A way to deal with the problem is to rectify the database before proceeding to queries. Since there is usually no single best way to solve an inconsistency, we will generally end up with a set of possible database repairs. Such set of possible databases defines an incomplete database, a concept that has been studied for a long time [1]. When a query is asked on an incomplete database, the certain query answer is defined as the intersection of the answers to the query on every possible database. The motivation for intersecting query answers should be clear: although we do not know which database is the right one, we do know that it will (at least) return this certain answer. If the incomplete database is made up of repairs, the certain answer has also been called the consistent answer. Repairing with respect to functional and key dependencies is commonly done by tuple deletion (inserting new tuples will not take away the inconsistency anyway). In this article, we propose a novel approach, termed project-join-repair, for repairing a universal relation subject to a set of functional dependencies (fd s). We next motivate the approach by three examples. Example 1. The first row in the following relation states that on January 7, twenty units of product P1 have been shipped to customer C1 called A. Jones. The constraints are Cid CName (the same identifier cannot be used for different customers) and, since quantities are daily totals per product and client,

2 2 {Date, Pid, Cid} Qty. The first fd is violated, because C1 appears with two different names. We could repair this relation by deleting either the first or the second tuple. However, it may be more meaningful to assume that names are mistaken, and that A. Johnson should read A. Jones, or vice versa. I Date Pid Qty Cid CName 7 Jan P1 20 C1 A. Jones 8 Feb P2 15 C1 A. Johnson We propose a novel way to make the intended rectification. First, we apply the join dependency [{Date, Pid, Qty, Cid}, {Cid, CName}], that is, we take the join of the projections on {Date, Pid, Qty, Cid} and {Cid, CName}. This join dependency (jd) corresponds to a lossless-join decomposition in third normal form (3NF). The lossless-join property means that applying the jd will not insert new tuples into consistent relations. However, since one fd is violated in our example, the join contains two new tuples (followed by ). π Date,Pid,Qty,Cid (I) Date Pid Qty Cid 7 Jan P1 20 C1 8 Feb P2 15 C1 π Cid,CName (I) Cid C1 C1 CName A. Jones A. Johnson π Date,Pid,Qty,Cid (I) Date Pid Qty Cid CName 7 Jan P1 20 C1 A. Jones π Cid,CName (I) 8 Feb P2 15 C1 A. Johnson 7 Jan P1 20 C1 A. Johnson ( ) 8 Feb P2 15 C1 A. Jones ( ) Next, we take as repairs the maximal (under set inclusion) consistent subsets of the join relation. This gives us the two intended repairs: J 1 Date Pid Qty Cid CName 7 Jan P1 20 C1 A. Jones 8 Feb P2 15 C1 A. Jones J 2 Date Pid Qty Cid CName 8 Feb P2 15 C1 A. Johnson 7 Jan P1 20 C1 A. Johnson Example 2. The following relation I is subject to the functional dependencies Name {Birth, Sex, ZIP} and ZIP City. The latter fd is violated. I Name Birth Sex ZIP City Ed 1962 M 7000 Bergen Again, instead of deleting either tuple, it is reasonable to assume that Mons should be Bergen, or vice versa. 1 We can obtain this effect by first applying the jd [{Name, Birth, Sex, ZIP}, {ZIP, City}] and then repair by tuple deletion. Here are the two repairs that result from this project-join-repair scenario: J 1 Name Birth Sex ZIP City Ed 1962 M 7000 Mons J 2 Name Birth Sex ZIP City An 1964 F 7000 Bergen Ed 1962 M 7000 Bergen 1 Bergen is actually the Dutch name for the city of Mons situated in the French speaking part of Belgium.

3 3 Again, the intended rectifications have been made. Example 3. By varying the jd, we can fine-tune the effect of the repairing work. I Name Birth Sex ZIP City An 1952 F 8000 Namur In the above relation, both An s birth year and ZIP code are inconsistent. If we apply our project-join-repair approach relative to the join dependency [{Name, Birth, Sex, ZIP}, {ZIP, City}], then An s birth year 1964 will remain tied to ZIP code 7000, and 1952 to However, the join dependency [{Name, Birth, Sex}, {Name, ZIP}, {ZIP, City}] allows uncoupling birth years and ZIP codes. In this way, we find, among others, the following repair which combines An s birth date 1964 found in the first tuple with An s ZIP code 8000 found in the second tuple: J Name Birth Sex ZIP City An 1964 F 8000 Namur This way of repairing may be meaningful in a situation where the first row about An comes from a data source that is precise on birth dates, while the second row comes from a data source that is precise on ZIP codes. It is tempting to think that the effect of the project-join-repair approach could also be obtained by repairing the projections, instead of repairing the join relation. However, this is generally not true. The first tuple in the following relation means that An is living in Belgium, earns 10K, and pays 20% taxes. The constraints are Name Country, Name Income, and {Country, Income} Tax. The latter functional dependency expresses that the tax rate depends on the country and the income. The projections corresponding to the join dependency [{Name, Country}, {Name, Income}, {Country, Income, Tax}] are shown. I Name Country Income Tax An Belgium 10K 20% An France 12K 20% π Name,Country (I) Name Country An Belgium An France π Name,Income (I) Name Income An 10K An 12K π Country,Income,Tax (I) Country Income Tax Belgium 10K 20% France 12K 20% Now consider what happens when we repair the three components by tuple deletion. If we retain {Name : An, Country : Belgium} in the first component, and {Name : An, Income : 12K} in the second, then the joined tuple {Name : An, Country : Belgium, Income : 12K} does not match any tuple in the third component. That is, the join of the repaired components can be empty. On the other hand, the project-join-repair approach will first join the three (unrepaired) components, which in this case happens to yield the original relation I. The result of the join will then be repaired by tuple deletion. No repair will be empty.

4 4 The remainder of the article is organized as follows. Section 2 defines the query class of rooted rules. Section 3 defines the problem we are interested in, namely the complexity of consistent query answering under the project-joinrepair approach. Section 4 introduces acyclic sets of fd s and their properties. Section 5 presents the main result of the article, which is the tractability of consistent query answering under the project-join-repair approach in cases of practical interest. Section 6 contains a comparison with related work. 2 Rooted Rules We will assume a single universal relation, which will be subject to decompositions. Definition 1. We assume a set of variables disjoint from a set of constants. A symbol is either a constant or a variable. A relation schema is a sequence A 1, A 2,..., A n of distinct attributes. The definitions to follow are relative to this relation schema. For tuples and relations, we will use both the named and unnamed perspective [2], whichever is most convenient in the technical treatment. Under the unnamed perspective, a tuple is a sequence s 1,..., s n of symbols. If each s i is a constant, then the tuple is called ground. Under the named perspective, this tuple is encoded by the mapping {(A 1, s 1 ),..., (A n, s n )}. A relation is a finite set of tuples. We will require that relations be typed, meaning that the same variable cannot appear in distinct columns. A relation is ground if all its tuples are ground. The construct of conjunctive query, also called rule, is defined as usual [2], with the minor difference that we assume a single relation and hence do not need distinguished relation symbols. We then proceed by defining the subclass of rooted rules. Definition 2. A rule-based conjunctive query (or simply rule) q is an expression of the form h B where the rule body B is a (typed) relation and the rule head h is a tuple such that every variable that occurs in h also occurs in B. The answer to this rule q on a (not necessarily ground) relation I, denoted q(i), is defined by q(i) = {θ(h) θ is a substitution such that θ(b) I}. A rule B, with a head of zero arity, is called Boolean; the answer to such rule is either { } or {}. Free variables are defined as usual. To define the notion of free tuple, we assume that the relation schema under consideration has a unique key K. Then, a tuple in the body of a rule is called free if its key value is composed of constants and free variables only. A quasi-free variable is a variable that occurs only in free tuples. Definition 3. Assume relation schema A 1, A 2,..., A n with a unique key K {A 1,..., A n }. Let q : h B be a rule. A variable is called free if it occurs in h;

5 5 otherwise it is nonfree. A tuple t B is called free if for each A i K, t(a i ) is either a free variable or a constant. A nonfree variable is called quasi-free if it occurs only in free tuples. To gain some intuition, assume schema A 1,..., A n with key K = {A 1,..., A k } (k n). Let s 1,..., s k, s k+1,..., s n be a tuple in the rule body, where underlined symbols correspond to key attributes. Assume that one of s k+1,..., s n is a quasi-free variable, say z. Since quasi-free variables occur only in free tuples, each s 1,..., s k must be a constant or a free variable. If θ is a valuation that maps the rule body into a relation that satisfies the key constraint, then the value θ(z) is fully determined by the value of θ on the free variables. Finally, a rule is rooted if every variable that occurs more than once in it, is free or quasi-free. Definition 4. Assume relation schema A 1, A 2,..., A n with a unique key K {A 1,..., A n }. A rule q : h B is called rooted if every variable that occurs more than once in B, is either free or quasi-free. Two rooted rules relative to the relation schema Name, Birth, Sex, ZIP, City of Example 2 are shown next, in which the underlined positions correspond to the key Name. Since all tuples in the rule bodies are free, all variables can have multiple occurrences. Get names of male persons living in An s city. x n x n, x b, M, x z, x c, An, y b, y s, y z, x c For each male person, get names of same-aged female persons living in the same city. x n, y n x n, x b, M, x z, x c, y n, x b, F, y z, x c If we remove y n from the rule head, then this rule is no longer rooted. Indeed, after removing y n from the rule head, the last tuple is no longer free, hence x b and x c are no longer quasi-free and must not occur more than once. 3 Consistent Query Answering We assume familiarity with the notions of functional dependency (fd) and multivalued dependency (mvd) [3, 2]. Join dependencies and keys are recalled next. Definition 5. Let U = {A 1,..., A n }, the set of attributes. A join dependency (jd) σ is an expression [X 1,..., X m ] where m i=1 X i = U. The result of applying this jd σ on relation I, denoted σ(i), is defined by σ(i) = π X1 (I) π X2 (I)... π Xm (I), where π and are the projection and join operators of the relational algebra. A ground relation I satisfies σ, denoted I = σ, if I = σ(i). If Σ is a set of fd s over U, then a key of Σ is a minimal (under set inclusion) set K U such that Σ = K U.

6 6 The next definition introduces by-now-standard constructs of repair and consistent query answer. The motivation for intersecting query answers has been provided in the first paragraph of this article. Definition 6. Let Σ be a set of fd s and I a ground relation. A repair of I under Σ is a maximal (under set inclusion) relation J I such that J = Σ. The consistent query answer to a rule q on I under Σ, denoted q Σ (I), is defined as follows: q Σ (I) = {q(i) I is a repair of I under Σ}. Given a set Σ of fd s and a rule q, consistent query answering is the complexity of (testing membership of) the set: CQA(Σ, q) = {I I is a ground relation and q Σ (I) = {}}. 2 That is, on input I, decide whether I yields an empty consistent query answer. Note that the constraints and the query are fixed and the complexity is in the size of the input relation, known as data complexity. We now introduce a novel related problem. Let Σ be a set of fd s and σ a jd such that Σ = σ: CQAJD(Σ, σ, q) = {I I is a ground relation and q Σ (σ(i)) = {}}. Intuitively, we first repair by tuple insertion relative to the weaker constraint σ (weaker in the sense that Σ = σ), which yields σ(i). Next, we apply standard consistent query answering relative to Σ using tuple deletion. Clearly, if we choose σ to be the identity jd (that is, σ = [U]), then CQAJD(Σ, σ, q) = CQA(Σ, q). Also, CQAJD(Σ, σ, q) is in NP for any set Σ of fd s and rule q, because the jd σ can be applied in polynomial time and CQA(Σ, q) is in NP for fd s [4]. 4 Acyclic Fd s and Preparatory Jd s The main result of this paper will be the tractability of CQAJD(Σ, σ, q) under certain conditions for Σ and σ. These conditions, which are not too severe and allow many practical cases, are introduced next. First, we define acyclic sets of fd s. The definition is relative to a minimal cover of fd s, which is a reduced representative for a set of fd s. See [2, page 257] or [3, page 390]. Definition 7. The dependency graph of a set Σ of fd s is defined as follows: the vertices are the dependencies of Σ; there is an oriented edge from the vertex X A to the vertex Y B if A Y. We call Σ acyclic if it has a minimal cover whose dependency graph contains no cycle. 2 Note that our definition tests for emptiness of consistent query answers, whereas other authors have used the complement problem which tests for nonemptiness [4].

7 7 For example, the set {AB C, C A} is cyclic. The set {A B, C D, AD B, BC D} has minimal cover {A B, C D} and is acyclic. Theorem 1. Every acyclic set Σ of fd s has a unique minimal cover and a unique key. Next, we define a restriction on jd s. Definition 8. Let Σ be set of fd s and σ a jd, both over the same set U of attributes. We say that σ is repairing-preparing for Σ, denoted Σ σ, if the following two conditions are satisfied: 1. Σ = σ; and 2. for every X Y Σ, either Σ = X U or for every A Y, σ = X A. Because of the first condition, if Σ σ, then for every relation I, I = Σ implies σ(i) = I. That is, applying the jd is the identity on consistent relations. The second condition, which may be less intuitive, ensures that applying the jd will distribute erroneous values over tuples. In Example 1, for example, the join relation satisfies Cid CName: both the 7 Jan and the 8 Feb shipments are joined to both names (A. Jones and A. Johnson). Clearly, Σ σ can be decided using the chase technique [2]. Example 4. Assume {Name, Birth, Sex, ZIP, City} subject to the acyclic set Σ = {Name Birth, Name Sex, Name ZIP, ZIP City}. It can be verified that: Σ [{Name, Birth, Sex, ZIP}, {ZIP, City}] Σ [{Name, Birth, Sex}, {Name, ZIP}, {ZIP, City}] All jd s used in Section 1 are repairing-preparing. Given Σ, a natural question is whether a jd σ that corresponds to a good decomposition in 3NF, will satisfy Σ σ. In response, we note that even for acyclic sets of fd s, the classical 3NF Synthesis algorithm (see Algorithm in [2]) can yield a join dependency that is not repairing-preparing. For example, for Σ = {A C, B D, CD E}, the jd [AB, AC, BD, CDE] corresponds to the decomposition of ABCDE given by this algorithm (decomposition in 3NF with a lossless join and preservation of dependencies). Since it can be verified that Σ = A ABCDE and σ = A C, it follows Σ σ. Finally, we note that the relation does not depend on the representation chosen for Σ: Proposition 1. Let Σ and Σ be sets of fd s, and σ a jd. If Σ and Σ are equivalent and Σ σ, then Σ σ.

8 8 I Name Birth Sex ZIP City An 1952 F 7000 Mons Ed 1970 M 7000 Bergen H Name Birth Sex ZIP City An y F 7000 z Ed 1970 M 7000 z σ(i) Name Birth Sex ZIP City An 1964 F 7000 Bergen An 1952 F 7000 Mons An 1952 F 7000 Bergen Ed 1970 M 7000 Mons Ed 1970 M 7000 Bergen Fig. 1. Computing a relation H that returns consistent answers to rooted rules 5 Tractability of CQAJD for Rooted Rules We show that consistent query answering in the project-join-repair approach is tractable for rooted rules under certain restrictions for Σ and σ (Theorem 2). We then show that there are cases where repairing by mere tuple deletion is intractable, but becomes tractable under project-join-repair. Finally, we show that moving beyond rooted rules leads to intractability. The following lemma states the conditions under which project-join-repair preserves, in every repair, all key values of the original relation. We assume that each fd in a given set Σ of fd s is of the form X A, where A is a single attribute not in X. Lemma 1. Let Σ be an acyclic set of fd s such that no two fd s of Σ have the same right-hand side. Let σ be a jd such that Σ σ. Let K be the unique key of Σ (uniqueness follows from Theorem 1). For every relation I, if J is a repair of σ(i) under Σ, then π K (J) = π K (I) = π K (σ(i)). The following Theorem 2 shows tractability of CQAJD(Σ, σ, q). Moreover, the theorem has a constructive proof, which provides an effective way for computing consistent query answers. Figure 1 shows the construction on a simple example. First, apply the jd σ = [{Name, Birth, Sex, ZIP}, {ZIP, City}], giving σ(i). Next, the relation H contains one tuple for every distinct key value in σ(i) (the key is Name). Variables are used to represent uncertain values. Initially, all variables are distinct. Next, since An and Ed share the same ZIP code, we know that they must live in the same city (because of the constraint ZIP City), hence the double occurrence of z. The construction is in polynomial time in the size of I. The proof of Theorem 2 shows that for every rooted rule q, the ground tuples in q(h) coincide with the consistent answer q Σ (σ(i)). Note incidentally that the rooted rule Get names of male persons living in An s city returns Ed because of the double occurrence of z. Note also that there is no need to materialize the repairs of σ(i) under Σ.

9 9 Theorem 2. Let Σ be an acyclic set of fd s such that no two fd s of Σ have the same right-hand side. Let K be the unique key of Σ. Let σ be a jd such that Σ σ. Then, for every rooted rule q, CQAJD(Σ, σ, q) is in P. In Section 1, we illustrated that the project-join-repair approach can give us more natural repairs in general. The following theorem states a very pleasant result: in addition to naturalness, we may gain tractability. The jd in this theorem corresponds to a standard 3NF decomposition. Theorem 3. Assume relation schema A, B, C, D, E, F. Let Σ = {A D, B E, C F } (the key is ABC) and σ = [ABC, AD, BE, CF ]. Let q : x, y, z, 0, 0, 0, a rooted rule. Then, Σ σ, and CQAJD(Σ, σ, q) is in P, but CQA(Σ, q) is NP-complete. Proof. The P result follows from Theorem 2. NP-hardness of CQA(Σ, q) can be proved by a reduction from 3DM (three-dimensional matching). Moving beyond rooted rules results in intractability. Theorem 4. Assume relation schema A, B, C. Let Σ = {A B, A C} (the key is A) and σ = [AB, AC]. Let q : u, y, 0, w, y, 1, a rule that is not rooted since y appears twice but is neither free nor quasi-free. Then, Σ σ, but CQAJD(Σ, σ, q) is NP-complete. Proof. See Theorem 3.3 in [4]. The relation in that proof satisfies σ. 6 Related Work Main Contribution. We studied the problem of repairing a universal relation relative to a set of fd s. We illustrated by a number of examples that better repairs can be obtained by first applying a jd prior to repairing by tuple deletion. By varying the jd, attributes can be kept together or treated as being independent. As for the complexity, Theorem 3 shows that consistent query answering can be intractable under standard repairing by tuple deletion, but tractable under project-join-repair. This a pleasant result: increased naturalness and decreased complexity go hand in hand. Tractability was proved for the class of rooted rules. We next compare our contribution with existing work. Join Graphs. An elegant approach to compute consistent query answers is query rewriting: a given query is rewritten such that the new query returns the consistent answer on any, possibly inconsistent, database. Obviously, if the rewritten query is wished to be first-order expressible [5, 6], then unless P=NP, this approach is limited to sets Σ of constraints and queries q for which CQA(Σ, q) is in P. Fuxman and Miller [7] give an algorithm for first-order rewriting of a subclass of conjunctive queries under primary key constraints. They define the join graph of a rule as a graph whose vertices are the atoms in the body of the query. There

10 10 is an oriented edge from R(s 1,..., s k, s k+1,..., s n ) to a distinct atom P if some s k+1,..., s n is a nonfree variable that also occurs in P. There is a self-loop on R(s 1,..., s k, s k+1,..., s n ) if some s k+1,..., s n is a nonfree variable that occurs twice in the atom. In this representation, the underlined coordinates constitute the primary key of the relation. Fuxman and Miller [7] give a query rewriting algorithm for queries with acyclic join graphs that contain no repeated relation symbols. Moreover, they require that every join of two atoms involves all key attributes of one of the atoms, a condition that was relaxed later on by Grieco et al. [8]. Our rooted rules are more general insofar as they can have cyclic join graphs and contain repeated relation symbols. Example 5. Consider relation schema Name, Birth, Sex, ZIP, City. The following rooted rule gets, for each male person, the names of same-aged female persons living in the same city. x n, y n x n, x b, M, x z, x c, y n, x b, F, y z, x c The join graph contains a cycle, because x c is nonfree and occurs in two distinct atoms (likewise for x b ). Here is the query obtained by projecting the rule body on the components of the jd [{Name, Birth, Sex, ZIP}, {ZIP, City}]. The relation symbols R 1 and R 2 are used for the first and second component respectively. x n, y n R 1(x n, x b, M, x z ), R 2 (x z, x c ), R 1 (y n, x b, F, y z ), R 2 (y z, x c ) Each relation symbol occurs twice in the rule body, and the join graph contains two cycles, each of which connects atoms with the same relation symbol. The following example shows that rooted rules can yield queries where the join between two atoms does involve only a subset of the key attributes. Example 6. Consider relation schema Name, Country, Income, Tax and Σ with three fd s: Name Country, Name Income, and {Country, Income} Tax. Let σ = [{Name, Country}, {Name, Income}, {Country, Income, Tax}]. It can be verified that Σ σ. The following rooted rule gives the tax rate for each person: Here is the decomposed query: x n, x t R(x n, x c, x i, x t ) x n, x t R 1 (x n, x c ), R 2 (x n, x i ), R 3 (x c, x i, x t ) Note that x c in R 1 (x n, x c ) joins to the first attribute of the composite key in R 3 (x c, x i, x t ). Defining Repairs. Consistent query answering gathered much attention since the seminal article by Arenas et al. [5], where repairs are defined in terms of the sets of inserted and deleted tuples. Note that for fd s, tuple insertions are useless for restoring consistency. Most approaches minimize sets of deleted and/or inserted

11 11 tuples relative to set inclusion. Some authors also consider minimization with respect to cardinality [9, 10]. Recently, there has been a growing interest in repairing by value modification [11 14]. Our project-join-repair approach can have the effect of value modifications, but is different from earlier proposals. Consider again the relation of Example 2. I Name Birth Sex ZIP City Ed 1962 M 7000 Bergen Our update-based repairing proposed in [15, 14] would come up with the four repairs shown next, where is a placeholder for any ZIP code distinct from The project-join-repair approach will never introduce (placeholders for) new constants. However, as illustrated in Example 3, it yields J 1 and J 2 relative to the jd [{Name, Birth, Sex, ZIP}, {ZIP, City}]. In general, it remains a subjective matter as to which repairing strategy yields the most intuitive repairs. However, we may opt for project-join-repair whenever this gives us tractability. J 1 Name Birth Sex ZIP City Ed 1962 M 7000 Mons J 3 Name Birth Sex ZIP City An 1964 F Mons Ed 1962 M 7000 Bergen J 2 Name Birth Sex ZIP City An 1964 F 7000 Bergen Ed 1962 M 7000 Bergen J 4 Name Birth Sex ZIP City Ed 1962 M Bergen Computing Repairs and Consistent Query Answers. Several authors have investigated the use of logic solvers for database repairing [16, 9, 17]. They reduce database repairing and consistent query answering to the computation of models in some logical framework for which resolution methods exist. These articles focus more on expressiveness than on tractability. First-order query rewriting, discussed above, computes consistent query answers in polynomial time data complexity. The constructive proof of Theorem 2, illustrated by Fig. 1, could be termed database rewriting, as the database is modified so as to return consistent answers to any rooted rule in polynomial time. In [18, 19], a practical implementation is presented for consistent query answering relative to denial constraints. References 1. Imielinski, T., Lipski Jr., W.: Incomplete information in relational databases. J. ACM 31(4) (1984) Abiteboul, S., Hull, R., Vianu, V.: Foundations of Databases. Addison-Wesley (1995) 3. Ullman, J.D.: Principles of Database and Knowledge-Base Systems, Volume I. Computer Science Press (1988)

12 12 4. Chomicki, J., Marcinkowski, J.: Minimal-change integrity maintenance using tuple deletions. Information and Computation 197(1-2) (2005) Arenas, M., Bertossi, L.E., Chomicki, J.: Consistent query answers in inconsistent databases. In: Proc. 18th ACM Symp. on Principles of Database Systems, ACM Press (1999) Celle, A., Bertossi, L.E.: Querying inconsistent databases: Algorithms and implementation. In: Proc. 1st Int. Conf. on Computational Logic (CL 2000). Volume 1861 of LNAI, Springer (2000) Fuxman, A.D., Miller, R.J.: First-order rewriting for inconsistent databases. In: Proc. 10th Int. Conf. on Database Theory (ICDT 2005). Volume 3363 of LNCS, Springer (2005) Grieco, L., Lembo, D., Rosati, R., Ruzzi, M.: Consistent query answering under key and exclusion dependencies: Algorithms and experiments. In: Proc. 14th ACM Int. Conf. on Information and Knowledge Management (CIKM 05), ACM (2005) Arieli, O., Denecker, M., Nuffelen, B.V., Bruynooghe, M.: Database repair by signed formulae. In: Proc. 3rd Int. Symp. on Foundations of Information and Knowledge Systems (FoIKS 04). Volume 2942 of LNCS, Springer (2004) Lin, J., Mendelzon, A.O.: Merging databases under constraints. Int. J. Cooperative Inf. Syst. 7(1) (1998) Bertossi, L.E., Bravo, L., Franconi, E., Lopatenko, A.: Complexity and approximation of fixing numerical attributes in databases under integrity constraints. In: 10th Int. Symposium Database Programming Languages (DBPL 2005). Volume 3774 of LNCS, Springer (2005) Bohannon, P., Fan, W., Flaster, M., Rastogi, R.: A cost-based model and effective heuristic for repairing constraints by value modification. In: Proc. of the 24th ACM SIGMOD Int. Conf. on Management of Data, ACM Press (2005) Flesca, S., Furfaro, F., Parisi, F.: Consistent query answers on numerical databases under aggregate constraints. In: 10th Int. Symposium Database Programming Languages (DBPL 2005). Volume 3774 of LNCS, Springer (2005) Wijsen, J.: Database repairing using updates. ACM Trans. Database Syst. 30(3) (2005) Wijsen, J.: Condensed representation of database repairs for consistent query answering. In: Proc. 9th Int. Conf. on Database Theory (ICDT 2003). Volume 2572 of LNCS, Springer (2002) Arenas, M., Bertossi, L.E., Chomicki, J.: Answer sets for consistent query answering in inconsistent databases. Theory and Practice of Logic Programming 3(3-4) (2003) Greco, G., Greco, S., Zumpano, E.: A logical framework for querying and repairing inconsistent databases. IEEE Trans. Knowledge and Data Eng. 25(6) (2003) Chomicki, J., Marcinkowski, J., Staworko, S.: Computing consistent query answers using conflict hypergraphs. In: Proc. 13th ACM Int. Conf. on Information and Knowledge Management (CIKM 04), ACM (2004) Chomicki, J., Marcinkowski, J., Staworko, S.: Hippo: A system for computing consistent answers to a class of SQL queries. In: Proc. 9th Int. Conf. on Extending Database Technology (EDBT 2004). Volume 2992 of LNCS, Springer (2004)