Abstract not found

this paper, we extend XML DTDs with several classes of integrity constraints and investigate the complexity of reasoning about these constraints. The constraints range over keys, foreign keys, inverse constraints as well as ID constraints for capturing the semantics of object identities. They improve semantic specifications and provide a better reference mechanism for native XML applications. They are also useful in information exchange and data integration for preserving the semantics of data originating in relational and object-oriented databases. We establish complexity and axiomatization results for the (finite) implication problems associated with these constraints. In addition, we study implication of more general constraints, such as functional, inclusion and inverse constraints defined in terms of navigation paths

Abstract. We state and solve the query reformulation problem for XML publishing in a general setting that allows mixed (XML and relational) storage for the proprietary data and exploits redundancies (materialized views, indexes and caches) to enhance performance. The correspondence between published and proprietary schemas is specified by views in both directions, and the same algorithm performs rewriting-with-views, composition-with-views, or the combined effect of both, unifying the Global-As-View and Local-As-View approaches to data integration. We prove a completeness theorem which guarantees that under certain conditions, our algorithm will find a minimal reformulation if one exists. Moreover, we identify conditions when this algorithm achieves optimal complexity bounds. We solve the reformulation problem for constraints by exploiting a reduction to the problem of query reformulation. 1

We present a system for publishing as XML data from mixed (relational+XML) proprietary storage, while supporting redundancy in storage for tuning purposes. The correspondence between public and proprietary schemas is given by a combination of LAVand GAV-style views expressed in XQuery.

XML specifications often consist of a type definition (typically, a DTD) and a set of integrity constraints. It has been shown previously that such specifications can be inconsistent, and thus it is often desirable to check consistency at compile-time. It is known that for general keys and foreign keys, and DTDs, the consistency problem is undecidable; however, it becomes NP-complete when all keys are one-attribute (unary), and tractable, if no foreign keys are used.

Let Σ1, Σ2 be two schemas, which may overlap, C be a set of constraints on the joint schema Σ1 ∪ Σ2, and q1 be a Σ1-query. An (equivalent) reformulation of q1 in the presence of C is a Σ2-query, q2, such that q2 gives the same answers as q1 on

We study the problem of generating efficient, equivalent rewritings using views to compute the answer to a query. We take the closed-world assumption, in which views are materialized from base relations, rather than views describing sources in terms of abstract predicates, as is common when the open-world assumption is used. In the closed-world model, there can be an infinite number of different rewritings that compute the same answer, yet have quite different performance. Query optimizers take a logical plan (a rewriting of the query) as an input, and generate efficient physical plans to compute the answer. Thus our goal is to generate a small subset of the possible logical plans without missing an optimal physical plan. We first consider a cost model that counts the number of subgoals in a physical plan, and show a search space that is guaranteed to include an optimal rewriting, if the query has a rewriting in terms of the views. We also develop an efficient algorithm for finding rewritings with the minimum number of subgoals. We then consider a cost model that counts the sizes of intermediate relations of a physical plan, without dropping any attributes, and give a search space for finding optimal rewritings. Our final cost model allows attributes to be dropped in intermediate relations. We show that, by careful variable renaming, it is possible to do better than the standard “supplementary relation ” approach, by dropping attributes that the latter approach would retain. Experiments show that our algorithm of generating optimal rewritings has good efficiency and scalability.

We investigate finite implication problems associated with key and foreign key constraints for XML data. We demonstrate that there is interaction between DTDs and these constraints, and the interaction complicates the analysis of finite implication. In particular, we establish complexity results for reasoning about two classes of constraints for XML. One class, L u , defines unary keys and foreign keys, and the other, L, consists of multi-attribute keys and foreign keys. We show that the finite implication problem for L u constraints is coNP-complete, and the finite implication problem for L constraints is undecidable. We also identify several PTIME decidable cases of the finite implication problems. In addition, we improve the results established in [16] by showing that the finite satisfiability problem for unary keys, unary inclusion constraints and their negations is NP-complete. 1 Introduction Although a number of dependency formalisms were developed for relational databases, fun...

Abstract. The problem of rewriting queries using views has received significant attention because of its applications in a wide variety of datamanagement problems. For select-project-join SQL (a.k.a. conjunctive) queries and views, there are efficient algorithms in the literature, which find equivalent and maximally contained rewritings. In the presence of arithmetic comparisons (ACs) the problem becomes more complex. We do not know how to find maximally contained rewritings in the general case. There are algorithms which find maximally contained rewritings only for special cases such as when ACs are restricted to be semi-interval. However, we know that the problem of finding an equivalent rewriting (if there exists one) in the presence of ACs is decidable, yet still doubly exponential. This complexity calls for an efficient algorithm which will perform better on average than the complete enumeration algorithm. In this work we present such an algorithm which is sound and complete. Its efficiency lies in that it considers fewer candidate rewritings because it includes a preliminary test to decide for each view whether it is potentially useful in some rewriting. 1

Abstract. Data integration and query reformulation are classical examples of problems that require techniques developed in both AI and database systems fields. In this work we address the problem of rewriting queries using views which has many applications. In particular, we consider queries and views that are conjunctive queries with safe negation (CQNs). We prove that given a CQN query and a set of CQN views, finding equivalent rewritings is decidable in both cases where the rewriting is in the language of CQNs or unions of CQNs. We prove decidability by giving upper bounds on the number of subgoals of the rewritings. We limit the search space of potential equivalent CQN rewritings and Maximally Contained CQN Rewritings (MCRs) to the language of unions of CQs in the case where the query is CQ. Finally, we give a sound and complete algorithm for finding equivalent rewritings in the language of unions of CQNs and we prove that if we consider the rewritings without negated subgoals, then they compute only certain answers under the OWA. Of independent interest is a simple test for checking containment between two unions of CQNs.