Olga Pons

Data summarization in relational databases through fuzzy dependencies

In this paper we deal with the problem of treating with dependencies in relational databases which do not hold in an exact manner as classical functional dependencies but in a weaker sense, i.e., we face with relations which satisfy dependencies such that ‘people with similar age and height have similar weight’. We model this relationship through the concept of fuzzy dependency. We see that these dependencies imply some kind of fuzzy redundancy, and, in order to avoid it, we propose to use a projection operator which leads us to partition a relation r into two projections, say r1 and r2 with a less amount of information. Then, we proceed to replace the original relation by these projections. In this process we must guarantee that we can recover the data we had in the original relation. This will be possible by using a special join operator applied to r1 and r2. We must also guarantee that we can test the fuzzy dependency for new entries to the database in the same way either if we consider the original relation r or if we work with the projections r1 and r2. We also show that this definition of dependency maintains the good properties of completeness of the classical case. ” 1999 Elsevier Science Inc. All rights reserved.

Complex object comparison in a fuzzy context

The comparison concept plays a determining role in many problems related to object management in an Object-Oriented Database Model. Object comparison is appropriately managed in a crisp object-oriented context by means of the concepts of identity and value equality. However, when dealing with imprecise or imperfect objects, questions like ‘To which extent may two objects be the same one?’ or ‘How similar are two objects?’ have not a clear answer, because the equality concept becomes fuzzy. In this paper we present a set of operators that are useful when comparing objects in a fuzzy environment. In particular, we introduce a generalized resemblance degree between two fuzzy sets of imprecise objects and a generalized resemblance degree to compare complex fuzzy objects within a given class. q 2003 Elsevier Science B.V. All rights reserved.

A conceptual approach for dealing with imprecision and uncertainty in object-based data models

This article treats the problem of vagueness in databases from a general point of view. Several kinds of attribute imprecise values are considered, including the case where such values are fuzzy set of objects. The possibility of managing uncertain data is also taken into account and both sources of the lack of information are studied jointly. All these vague elements are represented in a unified manner by using a semantic data model. The article shows how this representation is possible and opens the way for implementing this kind of information by using a classic object‐oriented database system.

Fuzzy Types: A New Concept of Type for Managing Vague Structures

The requirements of complex applications in the world of object‐oriented databases have motivated the study of the addition of vagueness to the existing models, giving rise to different approaches. The presence of vagueness can be considered in the type associated to a class, parallel to and independently from a fuzzy view of the set of objects that belong to the class (extent of the class). This paper offers a new perspective for representing the type associated to a class, tackling the problem of vagueness in the database schema and defining the concept of fuzzy type. Two different components of these types are defined: the structural component and the behavior component. An adaptation of the mechanism of instantiation and inheritance is presented by considering adequate union operators. A new criterion for handling the redefinition capability of the object‐oriented data model is explained. The description is accompanied by some illustrative examples. © 2000 John Wiley & Sons, Inc.

A strategy for adding fuzzy types to an object-oriented database system

Fuzzy types have been developed as a new way of managing fuzzy structures. With types of this kind, properties are ordered on different levels of precision or amplitude, according to their relationship with the concept represented by the type. In order to implement this new tool, two different strategies can be followed. On the one hand, a new system incorporating fuzzy types as an intrinsic capability can be developed. On the other hand, a new layer that implements fuzzy types can be added to an existing object‐oriented database system (OODB). This paper shows how the typical classes of an OODB can be used to represent a fuzzy type and how the mechanisms of instantiation and inheritance can be modeled using this kind of new type on an OODB. © 2001 John Wiley & Sons, Inc.

pg4DB: A fuzzy object-relational system

Object-relational systems combine the robustness of the relational data model with the powerful modeling capabilities of the object-oriented paradigm. Object-relational database management systems (ORDBMS) allow us to implement a set of relations to store and retrieve objects coming from a hierarchy of classes. If we want to manipulate imprecise objects in this kind of systems, we have to properly extend them. In this paper we introduce pOSTgRESQL Fuzzy Object Relational DataBase (pg4DB), a framework that supports the management of fuzzy objects in ORDBMS such as PostgreSQL. As we will see pg4DB allows users to create imprecise objects and operate with them using object-relational SQL compliant sentences.

Using OWA operator in flexible query processing

The use of OWA operators has been widely used in database contexts to process flexible queries where linguistic quantifiers are involved. This paper is devoted to comparing these operators’ use with other ways of addressing the same problems such as the Zadeh’s approach. Furthermore a new proposal is presented in order to avoid some inconveniences which the former approaches have in a wider class of problems. Finally, the paper analyzes the different types of queries with linguistic quantifiers which may appear in connection with relational databases and proposes the most appropiate way to solving them,in each case.

FUZZY INTERVALS TO REPRESENT FUZZY VALID TIME IN A TEMPORAL RELATIONAL DATABASE

Temporal databases offer a common framework to those database applications that need to store or handle different types of temporal data from a variety of sources. They allow the concept of time to be handled from the point of view of meaning, representation, and manipulation. Although at first sight the incorporation of time into a database might appear to be a direct and simple task, it is, however, quite complex: not only must new structures and specific operators be included, but the semantics of conventional DML sentences (insert, update, or delete) and queries must be appropriately changed. In addition, temporal information is not always as precise as desired since it might be affected by imprecision due to the use of natural language or to the nature of the information source. In this paper, we deal with the problem of the update (and, implicitly, insert and delete) and query operations when time is expressed by means of a fuzzy interval of dates.

Managing Fuzziness on Conventional Object-Oriented Platforms

During the last few years, many database researchers have aimed their efforts at extending the object‐oriented model for dealing with different kinds of imperfect information. Some of these scholars have used the Fuzzy Set Theory to deal with imperfection because it has proved to be useful in problems where imprecision and uncertainty play important roles. This article describes an architecture that can be used to develop a fuzzy object‐oriented system on top of an existing classical one. This article also introduces a general framework as the basis for managing fuzziness in conventional object‐oriented systems. Foodbi, a fuzzy object‐oriented database interface, is presented as a prototype that allows the creation of fuzzy object‐oriented schemata that can be translated into sets of standard Java classes.

A logic approach to fuzzy relational databases

A new definition of Fuzzy Relational Database is given by using logical concepts. With this definition it is possible to consider several kinds of fuzziness for the database attributes. A Domain Calculus‐based query language is also established for the model. It allows us to formulate several types of queries with different lack of precision levels.