David Toman

A comprehensive XQuery to SQL translation using dynamic interval encoding

The W3C XQuery language recommendation, based on a hierarchical and ordered document model, supports a wide variety of constructs and use cases. There is a diversity of approaches and strategies for evaluating XQuery expressions, in many cases only dealing with limited subsets of the language. In this paper we describe an implementation approach that handles XQuery with arbitrarily-nested FLWR expressions, element constructors and built-in functions (including structural comparisons). Our proposal maps an XQuery expression to a single equivalent SQL query using a novel dynamic interval encoding of a collection of XML documents as relations, augmented with information tied to the query evaluation environment. The dynamic interval technique enables (suitably enhanced) relational engines to produce predictably good query plans that do not preclude the use of sort-merge join query operators. The benefits are realized despite the challenges presented by intermediate results that create arbitrary documents and the need to preserve document order as prescribed by semantics of XQuery. Finally, our experimental results demonstrate that (native or relational) XML systems can benefit from the above technique to avoid a quadratic scale up penalty that effectively prevents the evaluation of nested FLWR expressions for large documents.

Temporal logic in information systems

Temporal logic is obtained by adding temporal connectives to a logic language. Explicit references to time are hidden inside the temporal connectives. Different variants of temporal logic use different sets of such connectives. In this chapter, we survey the fundamental varieties of temporal logic and describe their applications in information systems.

Querying ATSQL databases with temporal logic

We establish a correspondence between temporal logic and a subset of ATSQL, a temporal extension of SQL-92. In addition, we provide an effective translation from temporal logic to ATSQL that enables a user to write high-level queries which are then evaluated against a space-efficient representation of the database. A reverse translation, also provided in this paper, characterizes the expressive power of a syntactically defined subset of ATSQL queries.

The Combined Approach to OBDA: Taming Role Hierarchies Using Filters

The basic idea of the combined approach to query answering in the presence of ontologies is to materialize the consequences of the ontology in the data and then use a limited form of query rewriting to deal with infinite materializations. While this approach is efficient and scalable for ontologies that are formulated in the basic version of the description logic DL-Lite, it incurs an exponential blowup during query rewriting when DL-Lite is extended with the popular role hierarchies. In this paper, we show how to replace the query rewriting with a filtering technique. This is natural from an implementation perspective and allows us to handle role hierarchies without an exponential blowup. We also carry out an experimental evaluation that demonstrates the scalability of this approach.

On Keys and Functional Dependencies as First-Class Citizens in Description Logics

We investigate whether identification constraints such as keys and functional dependencies can be granted full status as concept constructors in a Boolean-complete description logic. In particular, we show that surprisingly simple forms of such constraints lead to undecidability of the associated logical implication problem if they are allowed within the scope of a negation or on the left-hand side of inclusion dependencies. We then show that allowing a very general form of identification constraint to occur in the scope of monotone concept constructors on the right-hand side of inclusion dependencies still leads to decidable implication problems. We consider the relationship between certain classes of identification constraints and nominals.

Implementing temporal integrity constraints using an active DBMS

The paper proposes a general architecture for implementing temporal integrity constraints by compiling them into a set of active DBMS rules. The modularity of the design allows easy adaptation to different environments. Both differences in the specification languages and in the target rule systems can be easily accommodated. The advantages of this architecture are demonstrated on a particular temporal constraint compiler. This compiler allows automatic translation of integrity constraints formulated in Past Temporal Logic into rules of an active DBMS (in the current version of the compiler two active DBMS are supported: Starburst and INGRES). During the compilation the set of constraints is checked for the safe evaluation property. The result is a set of SQL statements that includes all the necessary rules needed for enforcing the original constraints. The rules are optimized to reduce the space overhead introduced by the integrity checking mechanism. There is no need for an additional runtime constraint monitor. When the rules are activated, all updates to the database that violate any of the constraints are automatically rejected (i.e., the corresponding transaction is aborted). In addition to straightforward implementation, this approach offers a clean separation of application programs and the integrity checking code. >

On Decidability and Complexity of Description Logics with Uniqueness Constraints

We establish the equivalence of: (1) the logical implication problem for a description logic dialect called DLClass that includes a concept constructor for expressing uniqueness constraints, (2) the logical implication problem for path functional dependencies (PFDs), and (3) the problem of answering queries in deductive databases with limited use of successor functions. As a consequence, we settle an open problem concerning lower bounds for the PFD logical implication problem and show that a regularity condition for DLClass that ensures low order polynomial time decidability for its logical implication problem is tight.

First-Order Queries over Temporal Databases Inexpressible in Temporal Logic

Queries over temporal databases involve references to time. We study differences between two approaches of including such references into a first-order query language (e.g., relational calculus): explicit (using typed variables and quantifiers) vs. implicit (using a finite set of modal connectives). We also show that though the latter approach—a first-order query language with implicit references to time—is appealing by its simplicity and ease of use, it cannot express all queries expressible using the first one in general. This result also settles a longstanding open problem about the expressive power of first-order temporal logic. A consequence of this result is that there is no first-order complete query language subquery-closed with respect to a uniform database schema, and thus we cannot use temporal relational algebra over uniform relations to evaluate all first-order definable queries.

Reasoning about Duplicate Elimination with Description Logic

Queries commonly perform much better if they manage to avoid duplicate elimination operations in their execution plans. In this paper, we report on a technique that provides a necessary and sufficient condition for removing such operators from object relational conjunctive queries under the standard duplicate semantics. The condition is fully captured as a membership problem in a dialect of description logic called CFD, which is capable of expressing a number of common constraints implicit in object relational database schemas. We also present a PTIME algorithm for arbitrary membership problems in CFD.

Memoing Evaluation for Constraint Extensions of Datalog

This paper proposes an efficient method for evaluation of deductive queries over constraint databases. The method is based on a combination of the top-down resolution with memoing and the closed form bottom-up evaluation. In this way the top-down evaluation is guaranteed to terminate for all queries for which the bottom-up evaluation terminates. The main advantage of the proposed method is the direct use of the information present in partially instantiated queries without the need for rewriting of the original program. The evaluation algorithm automatically propagates the necessary constraints during the computation. In addition, the top-down evaluation potentially allows the use of compilation techniques, developed for compilers of logic programming languages, which can make the query evaluation very efficient.