Luca Cabibbo

A Logical Approach to Multidimensional Databases

In this paper we present MD, a logical model for OLAP systems, and show how it can be used in the design of multidimensional databases. Unlike other models for multidimensional databases, MD is independent of any specific implementation (relational or proprietary multidimensional) and as such it provides a clear separation between practical and conceptual aspects. In this framework, we present a design methodology, to obtain an MD scheme from an operational database. We then show how an MD database can be implemented, describing translations into relational tables and into multidimensional arrays.

Querying Multidimensional Databases

Multidimensional databases are large collections of data, often historical, used for sophisticated analysis oriented to decision making. This activity is supported by an emerging category of software technology, called On-Line Analytical Processing (OLAP). In spite of a lot of commercial tools already available, a fundamental study for OLAP systems is still lacking. In this paper we introduce a model and a query language to establish a theoretical basis for multi-dimensional data. The model is based on the notions of dimension and f-table. Dimensions are linguistic categories corresponding to different ways of looking at the information. F-tables are the constructs used to represent factual data, and are the logical counterpart of multi-dimensional arrays, the way in which current analytical tools store data. The query language is a calculus for f-tables, and as such it offers a high-level support to multi-dimensional data analysis. Scalar and aggregate functions can be embedded in calculus expressions in a natural way. We discuss on conceptual problems related with the design of multidimensional query languages, and compare our model and language with other approaches.

From a procedural to a visual query language for OLAP

We address the issue of designing effective query languages for OLAP databases. The basis of our investigation is MD, a new data model for multidimensional databases that, unlike other multidimensional models, is independent of any specific implementation and as such provides a clear separation between practical and conceptual aspects. In this framework, we present and compare two query languages, based on different paradigms, for OLAP databases. The first language is algebraic and provides an effective way to manipulate multidimensional data in a procedural fashion. Although this language is clean and powerful, it is clearly not suited for final users. We therefore propose a high-level graphical language that allows the user to specify analytical queries in a natural and intuitive way. It turns out that the two languages have the same expressive power.

The Expressive Power of Stratified Logic Programs with Value Invention

The expressive power of the family wILOG(?)of relational query languages is investigated. The languages are rule based, with value invention and stratified negation. The semantics for value invention is based on Skolem functor terms. We study a hierarchy of languages based on the number of strata allowed in programs. We first show that, in presence of value invention, the class of stratified programs made of two strata has the expressive power of the whole family, thus expressing the computable queries. We then show that the language wILOG?of programs with nonequality and without negation expresses the mono- tone computable queries, and that the language wILOG1/2, ?of semipositive programs expresses the semimonotone computable queries.

Database Design for NoSQL Systems

We propose a database design methodology for NoSQL systems. The approach is based on NoAM (NoSQL Abstract Model), a novel abstract data model for NoSQL databases, which exploits the commonalities of various NoSQL systems and is used to specify a system-independent representation of the application data. This intermediate representation can be then implemented in target NoSQL databases, taking into account their specific features. Overall, the methodology aims at supporting scalability, performance, and consistency, as needed by next-generation web applications.

Managing inheritance hierarchies in object/relational mapping tools

We study, in the context of object/relational mapping tools, the problem of describing mappings between inheritance hierarchies and relational schemas. To this end, we introduce a novel mapping model, called M2ORM2 + HIE, and investigate its mapping capabilities. We first show that M2ORM2 + HIE subsumes three well-know basic representation strategies for mapping a hierarchy to relations. We then show that M2ORM2 + HIE also allows expressing further mappings, e.g., where the three basic strategies are applied independently to different parts of a multi-level hierarchy. We describe the semantics of M2ORM2 + HIE in term of how CRUD (i.e., Create, Read, Update, and Delete) operations on objects (in a hierarchy) can be translated into operations over a corresponding relational database. We also investigate correctness conditions.

On the integration of autonomous data marts

We address the problem of integrating a federation of dimensional data marts. This problem arises when, e.g., a large organization (or a federation thereof) needs to combine independently developed data warehouses. We show that this problem can be tackled in a systematic way because of two main reasons. First, data marts are structured in a rather uniform way, along dimensions and facts. Second, data quality in data marts is usually higher than in generic databases, since they are obtained by reconciling several data sources. Our scenario of reference is a federation (i.e., a logical integration) of various data marts, which we need to query in a unified way, that is, by means of drill-across operations. We propose a novel notion of dimension compatibility and characterize its general property. We then show the significance of dimension compatibility in performing drill-across queries over autonomous data marts. We also discuss general strategies for the integration of data marts.

A Framework for the Investigation of Aggregate Functions in Database Queries

In this paper we present a new approach for studying aggregations in the context of database query languages. Starting from a broad definition of aggregate function, we address our investigation from two different perspectives. We first propose a declarative notion of uniform aggregate function that refers to a family of scalar functions uniformly constructed over a vocabulary of basic operators by a bounded Turing Machine. This notion yields an effective tool to study the effect of the embedding of a class of built-in aggregate functions in a query language. All the aggregate functions most used in practice are included in this classification. We then present an operational notion of aggregate function, by considering a high-order folding constructor, based on structural recursion, devoted to compute numeric aggregations over complex values. We show that numeric folding over a given vocabulary is sometimes not able to compute, by itself, the whole class of uniform aggregate function over the same vocabulary. It turns out however that this limitation can be partially remedied by the restructuring capabilities of a query language.

On keys, foreign keys and nullable attributes in relational mapping systems

We consider the following scenario for a mapping system: given a source schema, a target schema, and a set of value correspondences between these two schemas, generate an executable transformation (i.e., a set of queries) to compute target instances from source instances. We base this computation on two main components: (i) a schema mapping generation algorithm, to compute a declarative schema mapping from the correspondences, and (ii) a query generation algorithm, to compute a transformation from the schema mapping. In this paper, we introduce novel schema mapping and query generation algorithms for mappings between relational schemas with keys, foreign keys and nullable attributes. We extend current relational mapping algorithms (e.g., those proposed in the Clio framework), which are able to deal only in a more limited way with such integrity constraints. As a further contribution, we propose referenced-attribute correspondences, which permit to specify more precise mappings than traditional attribute correspondences, while retaining a simple and intuitive semantics.

Applying an update method to a set of receivers

In the context of object databases, we study the application of an update method to a collection of receivers rather than to a single one. The obvious strategy of applying the update to the receivers one after the other, in some arbitrary order, brings up the problem of order independence. On a very general level, we investigate how update behavior can be analyzed in terms of certain schema annotations, called colorings. We are able to characterize those colorings that always describe order-independedent updates. We also consider a more specific model of update methods implemented in the relational algebra. Order-independence of such algebraic methods is undecidable in general, but decidable if the expressions used are positive. Finally, we consider an alternative parallel strategy for set-oriented applications of algebraic update methods and compare and relate it to the sequential strategy.