Abstract: We present a sound and complete rule set for determining whether sorting by document order and duplicate removal operations in the query plan of XPath expressions are unnecessary. Additionally we define a deterministic automaton that illustrates how these rules can be translated into an efficient algorithm. This work is an important first step in the understanding and tackling of XPath/XQuery optimization problems that are related to ordering and duplicate removal.

Abstract: We introduce Xdπ, a peer-to-peer model for reasoning about the dynamic behaviour of web data. It is based on an idealised model of semi-structured data, and an extension of the π-calculus with process mobility and with an operation for interacting with data. Our model can be used to reason about behaviour found in, for example, dynamic web page programming, applet interaction, and service orchestration. We study behavioural equivalences for Xdπ, motivated by examples.

Abstract: A model of Java transactions is presented and the basic formal properties of this model with respect to behavioral compatibility and database integrity are proved. An implementation technique for incorporating constraints into the existing Java technology is developed, and a sophisticated theorem prover technology is integrated into this environment capable of enforcing behavioral compatibility and verifying transaction safety. The model of Java transactions developed in this paper is based on the subtle interplay of constraints, bounded parametric polymorphism and orthogonal persistence. The approach is based on a correct solution for extending Java with parametric polymorphism along with a technique for integrating logic-based constraints into Java class files and class objects. The Java Core Reflection is extended accordingly. The technique for enforcing database integrity constraints is based on the PVS theorem prover technology, and it combines static and dynamic checking to attain reasonable performance. The theorem prover technology is itself based on a sophisticated type system equipped with a form of semantic subtyping and parametric polymorphism. The higher-order features of this technology are proved to be critical in dealing with the problems of behavioral compatibility and transaction verification.

Abstract: In the context of XML data management systems, the estimation of query cardinality is becoming more and more important: the information provided by a query result estimator can be used as input to the query optimizer, as an early feedback to user queries, as well as input for determining an optimal storage schema, and it may be helpful in embedded query execution.

Abstract: Object-oriented application development often involves storing application objects in a relational database Sometimes it is desirable to develop the persistent classes and the relational database in an independent way, and to use an object persistent manager to connect them in a suitable way This paper introduces M2ORM2, a model for describing meet-in-the-middle mappings between object schemas and relational schemas, to support the transparent management of object persistence by means of relational databases

Abstract: The core of a model theory for a functional object-oriented data model extended with XML-like types is presented. The object-oriented component of this integrated paradigm is based on Featherweight Java and XML is represented by regular expression types. The main contributions are in extending both with general logic-based constraints and establishing results on schema and database evolution by inheritance that respects database integrity requirements. The paper shows that formally defined semantics of this integrated paradigm does indeed exist and in fact may be constructed in a model-theoretic fashion. The generality of the developed model theory and its relative independence of a particular logic basis makes it applicable to a variety of approaches to XML (as well as object-oriented) constraints. A pleasing property of this model theory is that it offers specific requirements for semantically acceptable evolution of these sophisticated schemas and their databases.

Abstract: XPath 1 [4] is a practical language for selecting nodes from XML document trees and plays an essential role in other XML-related technologies such as XSLT and XQuery Implementations of XPath need to scale well both with respect to the size of the XML data and the growing size and intricacy of the queries (ie, combined complexity) Unfortunately, current XPath engines use query evaluation techniques that require time exponential in the size of queries in the worst case [1]

Abstract: XQuery is a recently developed query language for XML datasets. In this paper, we focus on the use of XQuery and other XML technologies for flat-file based scientific datasets. Traditionally, complex and domain-specific data layouts have complicated the processing of large datasets arising from scientific applications. The use of XML schemas and XQuery’s high-level structure can simplify the analysis on these datasets.

Abstract: Over the last fifteen years, database management systems (DBMSs) have been enhanced by the addition of rule-based programming to obtain active DBMSs. One of the greatest challenges in this area is to formally account for all the aspects of active behavior using a uniform formalism. In this paper, we formalize active relational databases within the framework of the situation calculus by uniformly accounting for them using theories embodying non-Markovian control in the situation calculus. We call these theories active relational theories and use them to capture the dynamics of active databases. Transaction processing and rule execution is modelled as a theorem proving task using active relational theories as background axioms. We show that major components of an ADBMS may be given a clear semantics using active relational theories.

Abstract: We examine the maintenance of data consistency in the presence of application-database interactions. Currently, a programmer must insert explicit checks to ensure that data are consistent with respect to the application’s and the database’s requirements. This explicit hand-coding of integrity constraint checks is error-prone and results in less maintainable code when the integrity constraints on the application or the database change. We describe an architecture for automatically generating application-level checks from application and database integrity constraint specifications. We focus on EJB-database interactions as a concrete context for our work, but our results are applicable to other programming language-database interactions.

Abstract: We study the problem of determining whether a query is contained in another when queries can carry along annotations from source data. We say that a query is annotation-contained in another if the annotated output of the former is contained in the latter on every possible annotated input databases. We study the relationship between query containment and annotation-containment and show that annotation-containment is a more refined notion in general. As a consequence, the usual equivalences used by a typical query optimizer may no longer hold when queries can carry along annotations from the source to the output. Despite this, we show that the same annotated result is obtained whether intermediate constructs of a query are evaluated with set or bag semantics. We also give a necessary and sufficient condition, via homomorphisms, that checks whether a query is annotation-contained in another. Even though our characterization suggests that annotation-containment is more complex than query containment, we show that the annotation-containment problem is NP-complete, thus putting it in the same complexity class as query containment. In addition, we show that the annotation placement problem, which was first shown to be NP-hard in [7], is in fact DP-hard and the exact complexity of this problem still remains open.

Abstract: The increased usage of mobile devices coupled with an unprecedented demand for information has pushed the scalability problem of pull-based data service to the focus. A broadcast model of streaming data over a wireless medium has been proposed as a viable alternative for information dissemination. In the streaming broadcast model, servers broadcast data in an asynchronous and unacknowledged mode while clients process personalized and complex queries locally, relieving the load on the server. We address the query processing of streamed XML data, which is fragmented into manageable chunks for easier synchronization. Although there has been some work done in defining algebras that model XQueries on XML documents, no work has been done in defining query algebras for fragmented XML stream data. We define a model for processing fragmented XML stream data, using the concept of holes and fillers. This model offers the flexibility required by the server to disseminate data in manageable fragments, whenever they become available, and to send repetitions, replacements and removal of fragments. We then present a query algebra for XQuery that operates on this streamed XML data model. The XML fragments are operated upon in a continuous pipelined fashion without the need of materializing the transmitted document at the client site.

Abstract: Despite the recent surge of research in query processing over data streams, little attention has been devoted to defining precise semantics for continuous queries over streams. We first present an abstract semantics based on several building blocks: formal definitions for streams and relations, mappings among them, and any relational query language. From these basics we define a precise interpretation for continuous queries over streams and relations. We then propose a concrete language, CQL (for Continuous Query Language), which instantiates the abstract semantics using SQL as the relational query language and window specifications derived from SQL-99 to map from streams to relations. We have implemented most of the CQL language in a Data Stream Management System at Stanford, and we have developed a public repository of data stream applications that includes a wide variety of queries expressed in CQL.

Abstract: We introduce the new notion of XML Stream Attribute Grammars (XSAGs). XSAGs are the first scalable query language for XML streams (running strictly in linear time with bounded memory consumption independent of the size of the stream) that allows for actual data transformations rather than just document filtering. XSAGs are also relatively easy to use for humans. Moreover, the XSAG formalism provides a strong intuition for which queries can or cannot be processed scalably on streams. We introduce XSAGs together with the necessary language-theoretic machinery, study their theoretical properties such as their expressiveness and complexity, and discuss their implementation.

Abstract: In this paper, we investigate the complexity of deciding the satisfiability of XPath 2.0 expressions, i.e., whether there is an XML document for which their result is nonempty. Several fragments that allow certain types of expressions are classified as either in PTIME or NP-hard to see which type of expression make this a hard problem. Finally, we establish a link between XPath expressions and partial tree descriptions which are studied in computational linguistics.