Ingo Schmitt

Merging inheritance hierarchies for database integration

Merging inheritance hierarchies with overlapping class extensions and types is an essential task in database design. In the context of view integration and schema integration for federated databases and multidatabases conflicting inheritance hierarchies have to be merged. Inheritance hierarchies often occur explicitly in object-oriented databases as well as implicitly in relational databases. Since a concept lattice can be regarded as an inheritance hierarchy we propose to apply the theory of concept analysis to the problem of merging inheritance hierarchies. After investigating the power and complexity of concept analysis algorithms we provide a new algorithm tailored to our problem. The new algorithm has polynomial complexity and helps to optimize the resulting hierarchy with respect to certain quality criteria, e.g. number of classes and null values. An example demonstrates the practicability of our approach to merge conflicting inheritance hierarchies.

Integration of Inheritance Trees as Part of View Generation For Database Federations

Schema integration is the basis for successfully building a database federation. Current proposals directly integrate the different schemata using a semantical powerful data model, for example an extended ER model or an object-oriented model. We propose instead to use for integration a semantical poor model and build semantically rich representations as external views only. This approach enables a flexible integration and derivation especially for inheritance trees. We present an algorithm enabling the derivation of different inheritance trees as external views onto an integrated schema. The resulting inheritance tree can be influenced by giving priorities to input classes or attribute combinations and satisfies several formalized quality criteria for external views.

A preference-based approach for interactive weight learning: learning weights within a logic-based query language

The result quality of queries incorporating impreciseness can be improved by the specification of user-defined weights. Existing approaches evaluate weighted queries by applying arithmetic evaluations on top of the query’s intrinsic logic. This complicates the usage of logic-based optimization. Therefore, we suggest a weighting approach that is completely embedded in a logic.In order to facilitate the user interaction with the system, we exploit the intuitively comprehensible concept of preferences. In addition, we use a machine-based learning algorithm to learn weighting values in correspondence to the user’s intended semantics of a posed query. Experiments show the utility of our approach.

Similarity Relational Calculus and Its Reduction to a Similarity Algebra

Traditional database query languages are based on set theory and crisp logic. Many applications, however, need similarity or retrieval-like queries producing results with truth values from the interval [0,1]. Such truth values can be regarded as continuous membership values of tuples expressing how strongly a query is matched. Formulating queries by applying existing similarity relational algebras means to express the user’s need in a procedural manner. In order to support a declarative way of formulating queries, we generalize the classical relational domain calculus by incorporating fuzzy operations and user weights. Besides defining syntax and semantics we show how to map any calculus expression onto a corresponding similarity algebra expression. In this way, we present a theoretical foundation for a declarative query language combining retrieval functionality and traditional relational databases.

Considering Integrity Constraints During Federated Database Design

Correct transformations and integrations of schemata within the process of federated database design have to encompass existing local integrity constraints. Most of the proposed methods for schema transformation and integration do not sufficiently consider explicit integrity constraints. In this paper we present an approach to deal with integrity constraints. Our approach bases on the idea to relate integrity constraints to extensions. A set of elementary operations for schema restructuring and integration is identified. For these operations we define major rules for dealing with integrity constraints. By means of a small example we then demonstrate the application of these rules.

Schema Integration with Integrity Constraints

In this paper we discuss the use and treatment of integrity constraints in the federated database design process. We consider different situations occurring frequently in the schema transformation and schema integration process. Based on that, general rules are given which describe the correct treatment of integrity constraints. Other proposed integration approaches do not consider integrity constraints at all or are restricted to special kinds of constraints. Therefore, our approach can be used to extend or complete existing integration methodologies.

WS-QBE: A QBE-Like Query Language for Complex Multimedia Queries

The visual database query language QBE (query by example) is a classical, declarative query language based on the relational domain calculus. However, due to insufficient support of vagueness QBE is not an appropriate query language for formulating similarity queries required in the context of multimedia databases. In this work we propose the query language WS-QBE which combines a schema to weight query terms as well as concepts from fuzzy logic and QBE into one language. WS-QBE enables a visual, declarative formulation of complex similarity queries. The semantics of WS-QBE is defined by a mapping of WS-QBE queries onto the similarity domain calculus SDC which is proposed here, too.

A comprehensive database schema integration method based on the theory of formal concepts

Integrating heterogeneous database schemata is a major task in federated database design where preexisting and heterogeneous database systems need to be integrated virtually by providing a homogenization database interface. Most proposed schema integration methods suffer from very complex result schemata and insufficient handling of extensional relations, i.e. in the way how redundant data of the input systems are dealt with. Redundancy among the input systems may thus remain undetected and, hence, remains uncontrolled.Our GIM (Generic Integration Model) method is based on the elegant and mathematically founded theory of formal concept analysis (FCA). The main idea is to integrate schemata into one formal context which is a binary relation between a set of attributes and a set of base extensions (set of potential objects). From that context we apply an FCA-algorithm to semi-automatically derive a concept lattice which we interpret as an inheritance hierarchy of classes for a homogenized schema. Thus, the integration task following our method can be supported by tools.

Towards quantum-based DB+IR processing based on the principle of polyrepresentation

The cognitively motivated principle of polyrepresentation still lacks a theoretical foundation in IR. In this work, we discuss two competing polyrepresentation frameworks that are based on quantum theory. Both approaches support different aspects of polyrepresentation, where one is focused on the geometric properties of quantum theory while the other has a strong logical basis. We compare both approaches and outline how they can be combined to express further aspects of polyrepresentation.

QSQL: incorporating logic-based retrieval conditions into SQL

Evaluating a traditional database query against a data tuple yields true on match and false on mismatch. Unfortunately, there are many application scenarios where such an evaluation is not possible or does not adequately meet user expectations about vague and uncertain conditions. Thus, there is a need for incorporating impreciseness and proximity into a logic-based query language. The calculus query language CQQL [24] has been developed for such scenarios by exploiting results from quantum logic. In this work we will show how to integrate underlying ideas and concepts of CQQL into SQL.