Rules for Migrating from Entity Relationship (ER) Diagrams to Object Relationship (OR) Diagrams

2006 ◽  
Vol 2 (4) ◽  
pp. 177-191 ◽  
Author(s):  
Sikha Bagui
Keyword(s):  
Conceptual Design ◽  
Relational Databases ◽  
Object Oriented ◽  
Design Tool ◽  
Data Migration ◽  
Mapping Rules ◽  
Er Model ◽  
Entity Relationship ◽  
Object Relationship ◽  
Structural Aspects

In this paper, we provide detailed mapping rules (a methodology) to convert an ER schema into an object relationship (OR) schema. The mapping rules are presented in a manner that will keep as much of the semantics of the database intact, in order to smoothen the important step of data migration from an ER schema to an OR schema. This OR schema should also serve as a conceptual design tool for object-oriented data models, very much like the ER diagrams are a conceptual design tool for relational databases. Since we are mainly discussing the conversion from an ER model to an OR model, we are limiting the discussion in this paper to the structural aspects of the OR model.

Mapping Generalizations and Specializations and Categories to Relational Databases

2009 ◽  
pp. 1-11
Author(s):  
Sikha Bagui
Keyword(s):  
Relational Databases ◽  
Web Data ◽  
Structural Validity ◽  
Short Article ◽  
Database Applications ◽  
Mapping Rules ◽  
Basic Concepts ◽  
Er Model ◽  
Entity Relationship

An Entity Relationship (ER) model that includes all the concepts of the original ER model and the additional concepts of generalizations/specializations and categories is often referred to as the Extended ER (EER) model (Elmasri & Navathe, 2007). With the rising complexity of database applications, and also in light of today’s web data applications (Necasky, 2006), the basic concepts of the ER model, as originally developed by Chen(1976), are no longer sufficient. Hence the basic ER model has been extended to include generalizations and specializations (Bagui & Earp, 2003; Elmasri & Navathe, 2007), and the concept of categories (Elmasri, et al., 1985). In this short article we shed some light on these relationship concepts, concepts that database designers often find difficult to directly model (Engels et al., 1992/93). We also discuss the mapping rules for generalizations/specializations and categories. Important contributions in this area are also reported in (Elmasri et al., 1985; Gogolla & Hohenstein, 1991; Markowitz & Shoshani, 1992; Dey, et. al., 1999). Dullea, et. al. (2003) discusses the structural validity of modeling structures with ER models.

Object-Relational Modeling

2009 ◽  
pp. 162-170
Author(s):  
Jaroslav Zendulka
Keyword(s):  
Relational Database ◽  
Relational Databases ◽  
Conceptual Modeling ◽  
Object Oriented ◽  
Database Systems ◽  
Object Relational ◽  
The Difference ◽  
Object Oriented Approach ◽  
Entity Relationship ◽  
Oriented Approach

Modeling techniques play an important role in the development of database applications. Well-known entity-relationship modeling and its extensions have become a widely-accepted approach for relational database conceptual design. An object-oriented approach has brought a new view of conceptual modeling. A class as a fundamental concept of the object-oriented approach encapsulates both data and behavior, whereas traditional relational databases are able to store only data. In the early 1990s, the difference between the relational and object-oriented (OO) technologies, which were, and are still used together to build complex software systems, was labeled the object-relational impedance mismatch (Ambler, 2003). The object-oriented approach and the need of new application areas to store complex data have greatly influenced database technology since that time. Besides appearance of object-oriented database systems, which fully implement objectoriented paradigm in a database environment (Catell et al., 2003), traditional relational database management systems become object-relational (Stonebraker & Brown, 1999). The most recent versions of the SQL standard, SQL: 1999 (Melton & Simon (2001) and SQL: 2003 (Eisenberg et al., 2004), introduced object-relational features to the standard and leading database producers have already released packages which incorporate them.

Extended Entity Relationship Modeling

2005 ◽  
pp. 233-239 ◽  
Author(s):  
Sikha Bagui
Keyword(s):  
Comparative Analysis ◽  
Short Paper ◽  
Database Applications ◽  
Mapping Rules ◽  
Basic Concepts ◽  
Er Model ◽  
Entity Relationship ◽  
Entity Relationship Modeling

With the rising complexity of database applications, the basic concepts of Entity-Relationship (ER) modeling (as originally developed by Chen, 1976) were no longer sufficient. So the basic ER model was extended to include generalizations and specializations (Bagui & Earp, 2003; Elmasri & Navathe, 2003) and the concept of categories (Elmasri, Weeldreyer & Hevner, 1985). An ER model which includes all the concepts of the original ER model and the additional concepts of generalizations/specializations and categories is often referred to as the Extended ER (EER) model (Elmasri & Navathe, 2003). In this short paper, we shed some light on these relationship concepts, concepts that database designers often find difficult to model directly (Engels et al., 1992/1993). We also discuss the mapping rules for generalizations/specializations and categories. Important contributions in this area are also reported in (Elmasri et al., 1985; Markowitz & Shoshani, 1992; Dey, Storey & Barron, 1999; Wiederhold & Elmasri, 1980). Song, Evans, and Park (1995) also give a good comparative analysis of other types of ER diagrams and their notations.

Conceptual Modeling for XML

2011 ◽  
pp. 148-173
Author(s):  
Sriram Mohan ◽  
Arijit Sengupta
Keyword(s):  
Conceptual Design ◽  
Relational Databases ◽  
Conceptual Modeling ◽  
Future Trend ◽  
Major Influence ◽  
Design Phase ◽  
Application Development ◽  
Current Application ◽  
Development Processes ◽  
Entity Relationship

The process of conceptual design is independent of the final platform and the medium of implementation, and is usually in a form that is understandable and usable by managers and other personnel who may not be familiar with the low-level implementation details, but have a major influence in the development process. Although a strong design phase is involved in most current application development processes (e.g., Entity Relationship design for relational databases), conceptual design for XML has not been explored significantly in literature or in practice. Most XML design processes start by directly marking up data in XML, and the metadata is typically designed at the time of encoding the documents. In this chapter, the reader is introduced to existing methodologies for modeling XML. A discussion is then presented comparing and contrasting their capabilities and deficiencies, and delineating the future trend in conceptual design for XML applications.

Conceptual Modeling for XML

2009 ◽  
pp. 527-549
Author(s):  
Sriram Mohan ◽  
Arijit Sengupta
Keyword(s):  
Conceptual Design ◽  
Relational Databases ◽  
Conceptual Modeling ◽  
Future Trend ◽  
Major Influence ◽  
Design Phase ◽  
Application Development ◽  
Current Application ◽  
Development Processes ◽  
Entity Relationship

The process of conceptual design is independent of the final platform and the medium of implementation, and is usually in a form that is understandable and usable by managers and other personnel who may not be familiar with the low-level implementation details, but have a major influence in the development process. Although a strong design phase is involved in most current application development processes (e.g., Entity Relationship design for relational databases), conceptual design for XML has not been explored significantly in literature or in practice. Most XML design processes start by directly marking up data in XML, and the metadata is typically designed at the time of encoding the documents. In this chapter, the reader is introduced to existing methodologies for modeling XML. A discussion is then presented comparing and contrasting their capabilities and deficiencies, and delineating the future trend in conceptual design for XML applications.

Transforming UML Class Diagrams into Relational Data Models

2011 ◽  
pp. 217-236 ◽  
Author(s):  
Devang Shah ◽  
Sandra Slaughter
Keyword(s):  
Relational Databases ◽  
Unified Modeling Language ◽  
Systems Design ◽  
Object Oriented ◽  
Relational Data ◽  
Unified Modeling ◽  
Software Designers ◽  
Mapping Process ◽  
Uml Class Diagram ◽  
Entity Relationship

The Entity-Relationship (ER) method is the most popular method for relational database design. On the other hand, the Unified Modeling Language (UML) is widely used in object- oriented analysis and design. Despite the increasing use of object-oriented techniques for software design and development, there is a large installed base of relational databases. Additionally, object-oriented databases are still not in widespread use. Thus, software designers and developers often turn to the relational databases to make their application objects persistent. Considering the fundamental differences between the two methods, the transformation from UML to a relational data model could be a non-trivial task. The purpose of this chapter is to describe a process that can be used to map a UML class diagram into an ER diagram, and to discuss the potential of using the UML notation to draw ER diagrams. An example of an actual systems design is used throughout to illustrate the mapping process, the associated problems encountered, and how they could be resolved.

Enforcing Cardinality Constraints in the ER Model with Integrity Methods

2002 ◽  
pp. 1-16 ◽  
Author(s):  
Mira Balaban ◽  
Peretz Shoval
Keyword(s):  
Data Model ◽  
Object Oriented ◽  
Database Schema ◽  
Direct Impact ◽  
Cardinality Constraints ◽  
Relationship Type ◽  
Er Model ◽  
Entity Relationship

Entity-Relationship (ER) schemas include cardinality constraints that restrict the dependencies among entities within a relationship type. The cardinality constraints have direct impact on application transactions, since insertions or deletions of entities or relationships might affect related entities. Application transactions can be strengthened to preserve the consistency of a database with respect to the cardinality constraints in a schema. Yet, once an ER schema is translated into a logical database schema, the direct correlation between the cardinality constraints and application transaction is lost, since the components of the ER schema might be decomposed among those of the logical database schema. We suggest extending the Enhanced-ER (EER) data model with integrity methods that can enforce the cardinality constraints. The integrity methods can be fully defined by the cardinality constraints, using a small number of primitive update methods, and are automatically created for a given EER diagram. A translation of an EER schema into a logical database schema can create integrity routines by translating the primitive update methods alone. These integrity routines may be implemented as database procedures, if a relational DBMS is utilized, or as class methods, if an object-oriented DBMS is utilized.

Objects and Domains for Managing Medical Data and Knowledge

1995 ◽  
Vol 34 (01/02) ◽  
pp. 40-46
Author(s):  
G. Wiederhold
Keyword(s):  
Domain Knowledge ◽  
Relational Databases ◽  
Structural Model ◽  
Algebraic Approach ◽  
Object Oriented ◽  
Relationship Model ◽  
Large Systems ◽  
Entity Relationship ◽  
Data Objects ◽  
Matching Rules

Abstract:This paper assesses the object-oriented data paradigm, and describes an algebraic approach which permits the generation of data objects from relational data, based on the knowledge captured in a formal Entity-Relationship model, the Structural Model. The advantage is that now objects can be created that satisfy a variety of particular views, as long as the hierarchies represented by the views are subsumed in the network represented by the overall structural model.The disadvantage of creating view-objects dynamically is that the additional layering has performance implications, so that the speedup expected from object-oriented databases versus relational databases, due to their hierarchical object storage, cannot be realized. However, scalability of systems is increased since large systems tend to have multiple objectives, and hence often multiple valid hierarchical views over the data. This approach has been implemented in the Penguin project, and recently some commercial successors are emerging.In truly large systems new problems arise, namely that now not only multiple views will exist, but also that the domains to be covered by the data will be autonomous and hence heterogeneous. One result is that ontologies associated with the multiple domains will differ as well. This paper proposes a knowledge-based algebra over the ontologies, so that the domain knowledge can be partitioned for maintenance. Only the articulation points, where the domains intersect, have to be agreed upon as defined by matching rules which define the shared ontologies.

scholarly journals An ER-based framework for declarative web programming

2012 ◽  
Vol 14 (3) ◽  
pp. 269-291 ◽  
Author(s):  
MICHAEL HANUS ◽  
SVEN KOSCHNICKE
Keyword(s):  
User Interface ◽  
Data Model ◽  
Relational Databases ◽  
Declarative Programming ◽  
Customer Requirements ◽  
Web Based ◽  
Data Dependencies ◽  
Er Model ◽  
Entity Relationship ◽  
High Level

AbstractWe describe a framework to support the implementation of web-based systems intended to manipulate data stored in relational databases. Since the conceptual model of a relational database is often specified as an entity-relationship (ER) model, we propose to use the ER model to generate a complete implementation in the declarative programming language Curry. This implementation contains operations to create and manipulate entities of the data model, supports authentication, authorization, session handling, and the composition of individual operations to user processes. Furthermore, the implementation ensures the consistency of the database w.r.t. the data dependencies specified in the ER model, i.e., updates initiated by the user cannot lead to an inconsistent state of the database. In order to generate a high-level declarative implementation that can be easily adapted to individual customer requirements, the framework exploits previous works on declarative database programming and web user interface construction in Curry.

Sign in / Sign up

Export Citation Format

Share Document