Abstract: Commercial OLAP systems usually treat OLAP dimensions as static entities. In practice, dimension updates are often necessary in order to adapt the multidimensional database to changing requirements. In earlier work we proposed a temporal multidimensional model and TOLAP, a query language supporting it, accounting for dimension updates and schema evolution at a high level of abstraction. In this paper we present our implementation of the model and the query language. We show how to translate a TOLAP program to SQL, and present a real-life case study, a medical center in Buenos Aires. We apply our implementation to this case study in order to show how our approach can address problems that occur in real situations and that current nontemporal commercial systems cannot deal with. We present results on query and dimension update performance, and briefly describe a visualization tool that allows editing and running TOLAP queries, performing dimension updates, and browsing dimensions across time.

Abstract: Semistructured data is used in data exchange applications, like B2B and EAI, and represents data in a flexible format. Every data item has a unique tag (also called label), and data items can be nested. Formally, a semistructured data instance is a tree whose nodes are labeled with tags and leaves are labeled with data values. XML [Con98] is a standard syntax for describing such trees; Fig. 1 shows a tree representing a semistructured data instance and its XML syntax. We will refer interchangeably to semistructured data instances as trees or XML trees.

Abstract: The core of a model theory for generic schema management is developed. This theory has two distinctive features: it applies to a variety of categories of schemas, and it applies to transformations of both the schema structure and its integrity constraints. A subtle problem of schema integration is considered in its general form, not bound to any particular category of schemas. The proposed solution, as well as the overall theory, is based entirely on schema morphisms that carry both structural and semantic properties. Duality results that apply to the schema and the data levels are established. These results lead to the main contribution of this paper: a formal schema and data management framework for generic schema management. Implications of this theory are established that apply to integrity problems in schema integration. The theory is illustrated by a particular category of schemas with object-oriented features along with typical database integrity constraints.

Abstract: We address a fundamental question concerning spatio-temporal database systems: "What are exactly spatio-temporal queries?" We define spatio-temporal queries to be computable mappings that are also generic, meaning that the result of a query may only depend to a limited extent on the actual internal representation of the spatio-temporal data. Genericity is defined as invariance under transformations that preserve certain characteristics of spatio-temporal data (e.g., collinearity, distance, velocity, acceleration, ...) that are relevant to a database user. These transformations also respect the monotone nature of time.We investigate different genericity classes relative to the constraint database model for spatio-temporal databases and we identify sound and complete languages for the first-order, respectively the computable, queries in these genericity classes.

Abstract: We present XPathLog as a Datalog-style extension to XPath. The querying part extends XPath with binding variables to XML nodes that are "traversed" when evaluating an XPath expression. Data manipulation is done in a rule-based way. In contrast to other approaches, the XPath-based syntax and semantics is also used for a declarative specification how the database should be updated: XPath filters are interpreted as specifications of elements and properties that should be added to the database. In this paper, we focus on the theoretical aspects of XPathLog. XPathLog has been implemented in the LoPiX system [LoP01].

Abstract: We propose a logical framework for describing, reasoning about, and simulating transaction models that relax some of the ACID (Atomicity-Consistency-Isolation-Durability) properties of classical transactions. Such extensions, usually called advanced transaction models (ATMs), have been proposed for dealing with new database applications involving long-lived, endless, and cooperative activities. Our approach appeals to non-Markovian theories, in which one may refer to past states other than the previous one. We specify an ATM as a suitable non-Markovian theory of the situation calculus, and its properties, including the relaxed ACID properties, as formulas of the same calculus. We use our framework to formalize classical and closed nested transactions. We first formulate each ATM and its properties as a theory of a certain kind and formulas of the situation calculus, respectively. We then define a legal database log as one whose actions are all possible and in which all the Commit and Rollback actions must occur whenever they are possible. After that, we show that the known properties of the ATM, including the (possibly relaxed) ACID constraints, are properties of legal logs and logical consequences of the theory corresponding to that ATM. Finally, we show how to use such a specification as a background theory for transaction programs written in the situation calculus based programming language GOLOG.

Abstract: We present a simple Data Mining Logic (DML) that can express common data mining tasks, like "Find Boolean association rules" or "Find inclusion dependencies." At the center of the paper is the problem of characterizing DML queries that are amenable to the levelwise search strategy used in the a-priori algorithm. We relate the problem to that of characterizing monotone first-order properties for finite models.

Abstract: A key issue for active databases is optimising the execution event-condition-action rules. In this paper we show how partial evaluation provides a formal and general route to optimising such rules. We produce a specialised version of the rule execution semantics for each possible sequence of actions that may execute from the current database state. This gives the opportunity to optimise rule execution for each particular sequence of actions. We obtain information about possible sequences of rule executions actions by applying abstract interpretation to the rule execution semantics. Our techniques are applicable both statically, i.e. at rule compilation time, and dynamically, during rule execution.

Abstract: We consider n-dimensional semi-algebraic spatial databases We compute in first-order logic extended with a transitive closure operator, a linear spatial database which characterizes the semi-algebraic spatial database up to a homeomorphism In this way, we generalize our earlier results to semi-algebraic spatial databases in arbitrary dimensions, our earlier results being true for only two dimensionsConsequently, we can prove that first-order logic with a transitive closure operator extended with stop conditions, can express all Boolean topological queries on semi-algebraic spatial databases of arbitrary dimension

Abstract: SQL4X, a powerful language for simultaneously querying both relational and XML databases is presented. Using SQL4X, one can create both relations and XML documents as query results. Thus, SQL4X can be thought of as an integration language. In order to allow easy integration of XML documents with varied structures, SQL4X uses flexible semantics when querying XML. SQL4X is also a powerful query language. It can express quantification, negation, aggregation, grouping and path expressions.Datalog4x and Tree-Datalog4x, extensions of Datalog, are defined as elegant abstract models for SQL4X queries. Query containment is characterized for many common classes of SQL4X queries. Specifically, for Datalog4x queries, a complete characterization of containment of conjunctive queries and of unions of queries is presented. Equivalence of Datalog4x queries under bag-set semantics is also characterized. A sufficient condition for containment of Tree-Datalog4x queries is presented. This condition is shown to be complete for a large class of common queries.

Abstract: Signatures are evolving profiles of entities extracted from streams of transactional data. For a stream of credit card transactions, for example, an entity might be a credit card number and a signature the average purchase amount. Signatures provide a high-level view of data in a transactional data warehouse and help data analysts focus their attention on interesting subsets of the data in such warehouses. Traditional databases are not designed for such applications. They impose overhead for services not necessary in such applications, such as indexing, declarative querying, and transaction support. Hancock is a Cbased domain-specific programming language with an embedded domain-specific database designed for computing signatures. In this paper, we describe Hancock's database mechanism, evaluate its performance, and compare an application written in Hancock with an equivalent application written in Daytona [5], a very efficient relational database system.

Abstract: To build the d-dimensional datacube, for on-line analytical processing, in the relational algebra, the database programming language must support a loop of d steps. Each step of the loop involves a different attribute of the data relation being cubed, so the language must support attribute metadata. A set of attribute names is a relation on the new data type, attribute. It can be used in projection lists and in other syntactical postions requiring sets of attributes. It can also be used in nested relations, and the transpose operator is a handy way to create such nested metadata. Nested relations of attribute names enable us to build decision trees for classification data mining. This paper uses OLAP and data mining to illustrate the advantages for the relational algebra of adding the metadata type attribute and the transpose operator.

Abstract: Perspective scenarios of e-commerce applications, in particular B2B applications, based on the exchange of XML documents open new research issues in the field of information systems and XML data management. In fact, information systems will have to generate XML documents, obtained by querying the underlying DBMS.This paper informally introduces the ERX-Query Language (ERX-QL), under development as part of ERX Data Management System (developed at University of Bergamo). ERX-QL deals with the problem of formulating declarative queries to extract data from within a database and directly generate XML documents. This way, ERX-QL naturally deals with recursive and nested XML structures. Furthermore, the rich extended ER database provided by the ERX system makes ERX-QL rich and powerful, thus suitable, with minor changes, to be adopted on classical RDBMSs.

Abstract: We present new algorithms for concurrent reading and updating of B*-trees and binary search trees. Our algorithms are based on the well-known link technique, and improve previously proposed solutions in several respects. We prove formally that our algorithms are correct. We show that they satisfy a view serializability criterion, which fails for previous solutions. This stronger serializability criterion is central to the proof that several subtle (but essential) optimizations incorporated in our algorithms are correct.

Abstract: Querying XML has been the subject of much recent investigation. A formal bulk algebra is essential for applying database-style optimization to XML queries. We develop such an algebra, called TAX (Tree Algebra for XML), for manipulating XML data, modeled as forests of labeled ordered trees. Motivated both by aesthetic considerations of intuitiveness, and by efficient computability and amenability to optimization, we develop TAX as a natural extension of relational algebra, with a small set of operators. TAX is complete for relational algebra extended with aggregation, and can express most queries expressible in popular XML query languages. It forms the basis for the Timber XML database system currently under development by us.

Abstract: We study absolute and relative keys for XML, and investigate their associated decision problems. We argue that these keys are important to many forms of hierarchically structured data including XML documents. In contrast to other proposals of keys for XML, these keys can be reasoned about efficiently. We show that the (finite) satisfiability problem for these keys is trivial, and their (finite) implication problem is finitely axiomatizable and decidable in PTIME in the size of keys.

Abstract: The basic querying mechanism over semistructured data, namely regular path queries, asks for all pairs of objects that are connected by a path conforming to a regular expression. We consider conjunctive two-way regular path queries (C2RPQc's), which extend regular path queries with two features. First, they add the inverse operator, which allows for expressing navigations in the database that traverse the edges both backward and forward. Second, they allow for using conjunctions of atoms, where each atom specifies that a regular path query with inverse holds between two terms, where each term is either a variable or a constant. For such queries we address the problem of view-based query answering, which amounts to computing the result of a query only on the basis of a set of views. More specifically, we present the following results: (1) We exhibit a mutual reduction between query containment and the recognition problem for view-based query answering for C2RPQc's, i.e., checking whether a given tuple is in the certain answer to a query. Based on such a result, we can show that the problem of view-based query answering for C2RPQc's is EXPSPACE-complete. (2) By exploiting techniques based on alternating two-way automata we show that for the restricted class of tree two-way regular path queries (in which the links between variables form a tree), query containment and view-based query answering are, rather surprisingly, in PSPACE (and hence, PSPACE-complete). (3) We present a technique to obtain view-based query answering algorithms that compute the whole set of tuples in the certain answer, instead of requiring to check each tuple separately. The technique is parametric wrt the query language, and can be applied both to C2RPQc's and to tree-queries.